Bus

Overview: Bus

class Bus(series: static_frame.core.series.Series, *, store: Optional[static_frame.core.store.Store] = None, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, max_persist: Optional[int] = None)[source]

A randomly-accessible container of Frame. When created from a multi-table storage format (such as a zip-pickle or XLSX), a Bus will lazily read in components as they are accessed. When combined with the max_persist parameter, a Bus will not hold on to more than max_persist references, permitting low-memory reading of collections of Frame.

Bus: Constructor

Overview: Bus: Constructor

Bus.__init__(series: static_frame.core.series.Series, *, store: Optional[static_frame.core.store.Store] = None, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, max_persist: Optional[int] = None)[source]

Default Bus constructor.

Parameters

  • store – A Store subclass.

  • config – A StoreConfig, or a mapping of label ot StoreConfig

  • max_persist – When loading Frame from a Store, optionally define the maximum number of Frame to remain in the Bus, regardless of the size of the Bus. If more than max_persist number of Frame are loaded, least-recently loaded Frame will be replaced by FrameDeferred. A max_persist of 1, for example, permits reading one Frame at a time without ever holding in memory more than 1 Frame.

classmethod Bus.from_concat(containers: Iterable[static_frame.core.bus.Bus], *, index: Optional[Union[static_frame.core.index_base.IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]], Type[static_frame.core.index_auto.IndexAutoFactory]]] = None, name: Optional[Hashable] = <object object>) → static_frame.core.bus.Bus[source]

Concatenate multiple Bus into a new Bus. All Bus will load all Frame into memory if any are deferred.

classmethod Bus.from_dict(mapping: Dict[Hashable, Any], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[…], static_frame.core.index_base.IndexBase]] = None) → static_frame.core.bus.Bus[source]

Bus construction from a dictionary, where the first pair value is the index and the second is the value.

Parameters

  • mapping – a dictionary or similar mapping interface.

  • dtype – dtype or valid dtype specifier.

Returns

Bus

classmethod Bus.from_frames(frames: Iterable[static_frame.core.frame.Frame], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, name: Optional[Hashable] = None) → static_frame.core.bus.Bus[source]

Return a Bus from an iterable of Frame; labels will be drawn from Frame.name.

classmethod Bus.from_hdf5(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, max_persist: Optional[int] = None) → static_frame.core.bus.Bus[source]

Given a file path to a HDF5 Bus store, return a Bus instance.

Parameters

  • fp – A string file path or Path instance.

  • config – A StoreConfig, or a mapping of label ot StoreConfig

  • max_persist – When loading Frame from a Store, optionally define the maximum number of Frame to remain in the Bus, regardless of the size of the Bus. If more than max_persist number of Frame are loaded, least-recently loaded Frame will be replaced by FrameDeferred. A max_persist of 1, for example, permits reading one Frame at a time without ever holding in memory more than 1 Frame.

classmethod Bus.from_items(pairs: Iterable[Tuple[Hashable, static_frame.core.frame.Frame]], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, name: Optional[Hashable] = None, index_constructor: Optional[Callable[[…], static_frame.core.index_base.IndexBase]] = None) → static_frame.core.bus.Bus[source]

Return a Bus from an iterable of pairs of label, Frame.

Returns

Bus

classmethod Bus.from_sqlite(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, max_persist: Optional[int] = None) → static_frame.core.bus.Bus[source]

Given a file path to an SQLite Bus store, return a Bus instance.

Parameters

  • fp – A string file path or Path instance.

  • config – A StoreConfig, or a mapping of label ot StoreConfig

  • max_persist – When loading Frame from a Store, optionally define the maximum number of Frame to remain in the Bus, regardless of the size of the Bus. If more than max_persist number of Frame are loaded, least-recently loaded Frame will be replaced by FrameDeferred. A max_persist of 1, for example, permits reading one Frame at a time without ever holding in memory more than 1 Frame.

classmethod Bus.from_xlsx(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, max_persist: Optional[int] = None) → static_frame.core.bus.Bus[source]

Given a file path to an XLSX Bus store, return a Bus instance.

Parameters

  • fp – A string file path or Path instance.

  • config – A StoreConfig, or a mapping of label ot StoreConfig

  • max_persist – When loading Frame from a Store, optionally define the maximum number of Frame to remain in the Bus, regardless of the size of the Bus. If more than max_persist number of Frame are loaded, least-recently loaded Frame will be replaced by FrameDeferred. A max_persist of 1, for example, permits reading one Frame at a time without ever holding in memory more than 1 Frame.

classmethod Bus.from_zip_csv(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, max_persist: Optional[int] = None) → static_frame.core.bus.Bus[source]

Given a file path to zipped CSV Bus store, return a Bus instance.

Parameters

  • fp – A string file path or Path instance.

  • config – A StoreConfig, or a mapping of label ot StoreConfig

  • max_persist – When loading Frame from a Store, optionally define the maximum number of Frame to remain in the Bus, regardless of the size of the Bus. If more than max_persist number of Frame are loaded, least-recently loaded Frame will be replaced by FrameDeferred. A max_persist of 1, for example, permits reading one Frame at a time without ever holding in memory more than 1 Frame.

classmethod Bus.from_zip_parquet(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, max_persist: Optional[int] = None) → static_frame.core.bus.Bus[source]

Given a file path to zipped parquet Bus store, return a Bus instance.

Parameters

  • fp – A string file path or Path instance.

  • config – A StoreConfig, or a mapping of label ot StoreConfig

  • max_persist – When loading Frame from a Store, optionally define the maximum number of Frame to remain in the Bus, regardless of the size of the Bus. If more than max_persist number of Frame are loaded, least-recently loaded Frame will be replaced by FrameDeferred. A max_persist of 1, for example, permits reading one Frame at a time without ever holding in memory more than 1 Frame.

classmethod Bus.from_zip_pickle(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, max_persist: Optional[int] = None) → static_frame.core.bus.Bus[source]

Given a file path to zipped pickle Bus store, return a Bus instance.

Parameters

  • fp – A string file path or Path instance.

  • config – A StoreConfig, or a mapping of label ot StoreConfig

  • max_persist – When loading Frame from a Store, optionally define the maximum number of Frame to remain in the Bus, regardless of the size of the Bus. If more than max_persist number of Frame are loaded, least-recently loaded Frame will be replaced by FrameDeferred. A max_persist of 1, for example, permits reading one Frame at a time without ever holding in memory more than 1 Frame.

classmethod Bus.from_zip_tsv(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None, max_persist: Optional[int] = None) → static_frame.core.bus.Bus[source]

Given a file path to zipped TSV Bus store, return a Bus instance.

Parameters

  • fp – A string file path or Path instance.

  • config – A StoreConfig, or a mapping of label ot StoreConfig

  • max_persist – When loading Frame from a Store, optionally define the maximum number of Frame to remain in the Bus, regardless of the size of the Bus. If more than max_persist number of Frame are loaded, least-recently loaded Frame will be replaced by FrameDeferred. A max_persist of 1, for example, permits reading one Frame at a time without ever holding in memory more than 1 Frame.

Bus: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary

Bus: Exporter

Overview: Bus: Exporter

Bus.to_hdf5(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None) → None

Write the complete Bus as an HDF5 table.

Parameters
Bus.to_series() → static_frame.core.series.Series[source]

Return a Series with the Frame contained in this Bus. If the Bus is associated with a Store, all Frame will be loaded into memory and the returned Bus will no longer be associated with the Store.

Bus.to_sqlite(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None) → None

Write the complete Bus as an SQLite database file.

Parameters
Bus.to_visidata() → None

Open an interactive VisiData session.

Bus.to_xlsx(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None) → None

Write the complete Bus as a XLSX workbook.

Parameters
Bus.to_zip_csv(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None) → None

Write the complete Bus as a zipped archive of CSV files.

Parameters
Bus.to_zip_parquet(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None) → None

Write the complete Bus as a zipped archive of parquet files.

Parameters
Bus.to_zip_pickle(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None) → None

Write the complete Bus as a zipped archive of pickles.

Parameters
Bus.to_zip_tsv(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, static_frame.core.store.StoreConfigMap] = None) → None

Write the complete Bus as a zipped archive of TSV files.

Parameters

Bus: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary

Bus: Attribute

Overview: Bus: Attribute

Bus.STATIC: bool = False
Bus.dtype

Return the dtype of the underlying NumPy array.

Returns

numpy.dtype

Bus.dtypes

Returns a Frame of dtype per column for all loaded Frames.

Bus.index

The index instance assigned to this container.

Returns

Index

Bus.mloc

Returns a Series showing a tuple of memory locations within each loaded Frame.

Bus.name

A hashable label attached to this container.

Returns

Hashable

Bus.nbytes

Total bytes of data currently loaded in the Bus.

Bus.ndim

Return the number of dimensions, which for a Bus is always 1.

Returns

int

Bus.shape

Return a tuple describing the shape of the underlying NumPy array.

Returns

Tuple[int]

Bus.shapes

A Series describing the shape of each loaded Frame. Unloaded Frame will have a shape of None.

Returns

Series

Bus.size

Return the size of the underlying NumPy array.

Returns

int

Bus.status

Return a Frame indicating loaded status, size, bytes, and shape of all loaded Frame.

Bus: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary

Bus: Method

Overview: Bus: Method

Bus.__bool__() → bool

Raises ValueError to prohibit ambiguous use of truethy evaluation.

Bus.__len__() → int[source]

Length of values.

Bus.equals(other: Any, *, compare_name: bool = False, compare_dtype: bool = False, compare_class: bool = False, skipna: bool = True) → bool[source]

Return a bool from comparison to any other object.

Note: this will attempt to load and compare all Frame managed by the Bus.

Parameters

  • compare_name – Include equality of the container’s name (and all composed containers) in the comparison.

  • compare_dtype – Include equality of the container’s dtype (and all composed containers) in the comparison.

  • compare_class – Include equality of the container’s class (and all composed containers) in the comparison.

  • skipna – If True, comparisons between missing values are equal.

Bus.head(count: int = 5) → static_frame.core.bus.Bus[source]

Return a Bus consisting only of the top elements as specified by count.

Parameters

count – Number of elements to be returned from the top of the Bus

Returns

Bus

Bus.rehierarch(depth_map: Sequence[int]) → static_frame.core.bus.Bus[source]

Return a new Bus with new a hierarchy based on the supplied depth_map.

Bus.reindex(index: Union[static_frame.core.index_base.IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]]], *, fill_value: Any, own_index: bool = False, check_equals: bool = True) → static_frame.core.bus.Bus[source]

Return a new Bus with labels defined by the provided index. The size and ordering of the data is determined by the newly provided index, where data will continue to be aligned under labels found in both the new and the old index. Labels found only in the new index will be filled with fill_value.

Parameters

  • index – An iterable of unique, hashable values, or another Index or IndexHierarchy, to be used as the labels of the index.

  • columns – An iterable of unique, hashable values, or another Index or IndexHierarchy, to be used as the labels of the index.

  • fill_value – A value to be used to fill space created by a new index that has values not found in the previous index.

  • own_index – Flag the passed index as ownable by this static_frame.Bus. Primarily used by internal clients.

Bus.relabel(index: Optional[Union[Callable[[…], Any], Mapping[Hashable, Any], static_frame.core.series.Series, Type[static_frame.core.index_auto.IndexAutoFactory], static_frame.core.index_base.IndexBase, Iterable[Hashable], Iterable[Sequence[Hashable]]]]) → static_frame.core.bus.Bus[source]

Return a new Bus with transformed labels on the index. The size and ordering of the data is never changed in a relabeling operation. The resulting index must be unique.

Parameters

index – One of the following types, used to create a new Index with the same size as the previous index. (a) A mapping (as a dictionary or Series), used to lookup and transform the labels in the previous index. Previous labels not found in the mapping will be reused. (b) A function, returning a hashable, that is applied to each label in the previous index. (c) The IndexAutoFactory type, to apply an auto-incremented integer index. (d) An index initializer, i.e., either an iterable of hashables or an Index instance.

Bus.relabel_flat() → static_frame.core.bus.Bus[source]

Return a new Bus, where an IndexHierarchy (if defined) is replaced with a flat, one-dimension index of tuples.

Bus.relabel_level_add(level: Hashable) → static_frame.core.bus.Bus[source]

Return a new Bus, adding a new root level to an existing IndexHierarchy, or creating an IndexHierarchy if one is not yet defined.

Parameters

level – A hashable value to be used as a new root level, extending or creating an IndexHierarchy

Bus.relabel_level_drop(count: int = 1) → static_frame.core.bus.Bus[source]

Return a new Bus, dropping one or more levels from a either the root or the leaves of an IndexHierarchy. The resulting index must be unique.

Parameters

count – A positive integer drops that many outer-most (root) levels; a negative integer drops that many inner-most (leaf)levels.

Bus.rename(name: Optional[Hashable]) → static_frame.core.bus.Bus[source]

Return a new Series with an updated name attribute.

Bus.roll(shift: int, *, include_index: bool = False) → static_frame.core.bus.Bus[source]

Return a Bus with values rotated forward and wrapped around the index (with a positive shift) or backward and wrapped around the index (with a negative shift).

Parameters

  • shift – Positive or negative integer shift.

  • include_index – Determine if the Index is shifted with the underlying data.

Returns

Bus

Bus.shift(shift: int, *, fill_value: Any) → static_frame.core.bus.Bus[source]

Return a Bus with values shifted forward on the index (with a positive shift) or backward on the index (with a negative shift).

Parameters

  • shift – Positive or negative integer shift.

  • fill_value – Value to be used to fill data missing after the shift.

Returns

Bus

Bus.sort_index(*, ascending: Union[bool, Iterable[bool]] = True, kind: str = 'mergesort', key: Optional[Callable[[static_frame.core.index_base.IndexBase], Union[numpy.ndarray, static_frame.core.index_base.IndexBase]]] = None) → static_frame.core.bus.Bus[source]

Return a new Bus ordered by the sorted Index.

Parameters

  • * –

  • ascending – Boolean, or iterable of Booleans; if True, the lowest ranks correspond to the lowest values; if an iterable, apply per column or row. The default is True.

  • kind – Name of the sort algorithm as passed to NumPy.

  • key – A function that is used to pre-process the selected columns or rows and derive new values to sort by.

Returns

Bus

Bus.sort_values(*, ascending: bool = True, kind: str = 'mergesort', key: Callable[[static_frame.core.series.Series], Union[numpy.ndarray, static_frame.core.series.Series]]) → static_frame.core.bus.Bus[source]

Return a new Bus ordered by the sorted values. Note that as a Bus contains Frames, a key argument must be provided to extract a sortable value, and this key function will process a Series of Frame.

Parameters

  • * –

  • ascending – If True, sort in ascending order; if False, sort in descending order.

  • kind – Name of the sort algorithm as passed to NumPy.

  • key – A function that is used to pre-process the selected columns or rows and derive new values to sort by.

Returns

Bus

Bus.tail(count: int = 5) → static_frame.core.bus.Bus[source]
Return a Bus consisting only of the bottom elements as specified by count.

s

Parameters

count – Number of elements to be returned from the bottom of the Bus

Returns

Bus

Bus: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary

Bus: Dictionary-Like

Overview: Bus: Dictionary-Like

Bus.__contains__(value: Hashable) → bool[source]

Inclusion of value in index labels.

Returns

bool

Bus.__iter__() → Iterator[Hashable][source]

Iterator of index labels, same as static_frame.Series.keys.

Returns

Iterator[Hashasble]

Bus.__reversed__() → Iterator[Hashable][source]

Returns a reverse iterator on the Bus index.

Returns

Index

Bus.get(key: Hashable, default: Optional[Any] = None) → Any[source]

Return the value found at the index key, else the default if the key is not found.

Returns

Any

Bus.items() → Iterator[Tuple[Hashable, static_frame.core.frame.Frame]][source]

Iterator of pairs of Bus label and contained Frame.

Bus.keys() → static_frame.core.index_base.IndexBase[source]

Iterator of index labels.

Returns

Iterator[Hashable]

Bus.values

A 1D object array of all Frame contained in the Bus.

Bus: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary

Bus: Display

Overview: Bus: Display

Bus.interface

A Frame documenting the interface of this class.

>>> sf.Bus.interface.loc[sf.Bus.interface['group'] == 'Exporter']
<Frame: Bus>
<Index>                       cls_name group    doc                  <<U18>
<Index: signature>
to_hdf5(fp, *, config)        Bus      Exporter Write the complet...
to_series()                   Bus      Exporter Return a Series w...
to_sqlite(fp, *, config)      Bus      Exporter Write the complet...
to_visidata()                 Bus      Exporter Open an interacti...
to_xlsx(fp, *, config)        Bus      Exporter Write the complet...
to_zip_csv(fp, *, config)     Bus      Exporter Write the complet...
to_zip_parquet(fp, *, config) Bus      Exporter Write the complet...
to_zip_pickle(fp, *, config)  Bus      Exporter Write the complet...
to_zip_tsv(fp, *, config)     Bus      Exporter Write the complet...
<<U65>                        <<U3>    <<U15>   <<U83>
Bus.__repr__() → str

Return repr(self).

Bus.__str__()

Return str(self).

Bus.display(config: Optional[static_frame.core.display_config.DisplayConfig] = None, *, style_config: Optional[static_frame.core.style_config.StyleConfig] = None) → static_frame.core.display.Display[source]

Return a static_frame.Display, capable of providing a string representation.

Parameters

config – A static_frame.DisplayConfig instance. If not provided, the static_frame.DisplayActive will be used.

Bus.display_tall(config: Optional[static_frame.core.display_config.DisplayConfig] = None) → static_frame.core.display.Display

Maximize vertical presentation. Return a static_frame.Display, capable of providing a string representation.

Parameters

config – A static_frame.DisplayConfig instance. If not provided, the static_frame.DisplayActive will be used.

Bus.display_wide(config: Optional[static_frame.core.display_config.DisplayConfig] = None) → static_frame.core.display.Display

Maximize horizontal presentation. Return a static_frame.Display, capable of providing a string representation.

Parameters

config – A static_frame.DisplayConfig instance. If not provided, the static_frame.DisplayActive will be used.

Bus: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary

Bus: Selector

Overview: Bus: Selector

Bus.drop[key]
Bus.drop

Interface for dropping elements from static_frame.Bus.

InterfaceSelectTrio.__getitem__(key: Union[int, numpy.integer, slice, List[Any], None, Index, Series, numpy.ndarray]) → Any[source]

Label-based selection.

Bus.drop.iloc[key]
Bus.drop

Interface for dropping elements from static_frame.Bus.

InterfaceSelectTrio.iloc

Integer-position based selection.

Bus.drop.loc[key]
Bus.drop

Interface for dropping elements from static_frame.Bus.

InterfaceSelectTrio.loc

Label-based selection.

Bus[key]
Bus.__getitem__ = <function Bus.__getitem__>[source]
Bus.iloc[key]
Bus.iloc
Bus.loc[key]
Bus.loc

Bus: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary

Bus: Iterator

Overview: Bus: Iterator

Bus.iter_element
iter_element

Iterator of elements.

Bus.iter_element().apply(func, *, dtype, name)
iter_element

Iterator of elements.

IterNodeDelegate.apply(func: Callable[[…], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None) → FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

  • func – A function that takes a value.

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

Bus.iter_element().apply_iter(func)
iter_element

Iterator of elements.

IterNodeDelegate.apply_iter(func: Callable[[…], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters

func – A function that takes a value.

Bus.iter_element().apply_iter_items(func)
iter_element

Iterator of elements.

IterNodeDelegate.apply_iter_items(func: Callable[[…], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters

func – A function that takes a value.

Bus.iter_element().apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_element

Iterator of elements.

IterNodeDelegate.apply_pool(func: Callable[[…], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

  • func – A function that takes a value.

  • * –

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

  • name – A hashable object to label the container.

  • max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.

  • chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.

  • use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

Bus.iter_element().map_all(mapping, *, dtype, name)
iter_element

Iterator of elements.

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None) → FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

Bus.iter_element().map_all_iter(mapping)
iter_element

Iterator of elements.

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.

Bus.iter_element().map_all_iter_items(mapping)
iter_element

Iterator of elements.

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.

Bus.iter_element().map_any(mapping, *, dtype, name)
iter_element

Iterator of elements.

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None) → FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

Bus.iter_element().map_any_iter(mapping)
iter_element

Iterator of elements.

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.

Bus.iter_element().map_any_iter_items(mapping)
iter_element

Iterator of elements.

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.

Bus.iter_element().map_fill(mapping, *, fill_value, dtype, name)
iter_element

Iterator of elements.

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None) → FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • fill_value – Value to be returned if the values is not a key in the mapping.

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

Bus.iter_element().map_fill_iter(mapping, *, fill_value)
iter_element

Iterator of elements.

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • fill_value – Value to be returned if the values is not a key in the mapping.

Bus.iter_element().map_fill_iter_items(mapping, *, fill_value)
iter_element

Iterator of elements.

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • fill_value – Value to be returned if the values is not a key in the mapping.

Bus.iter_element_items
iter_element_items

Iterator of label, element pairs.

Bus.iter_element_items().apply(func, *, dtype, name)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.apply(func: Callable[[…], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None) → FrameOrSeries[source]

Apply a function to each value. Returns a new container.

Parameters

  • func – A function that takes a value.

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

Bus.iter_element_items().apply_iter(func)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.apply_iter(func: Callable[[…], Any]) → Iterator[Any][source]

Apply a function to each value. A generator of resulting values.

Parameters

func – A function that takes a value.

Bus.iter_element_items().apply_iter_items(func)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.apply_iter_items(func: Callable[[…], Any]) → Iterator[Tuple[Any, Any]][source]

Apply a function to each value. A generator of resulting key, value pairs.

Parameters

func – A function that takes a value.

Bus.iter_element_items().apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.apply_pool(func: Callable[[…], Any], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None, max_workers: Optional[int] = None, chunksize: int = 1, use_threads: bool = False) → FrameOrSeries[source]

Apply a function to each value. Employ parallel processing with either the ProcessPoolExecutor or ThreadPoolExecutor.

Parameters

  • func – A function that takes a value.

  • * –

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

  • name – A hashable object to label the container.

  • max_workers – Number of parallel executors, as passed to the Thread- or ProcessPoolExecutor; None defaults to the max number of machine processes.

  • chunksize – Units of work per executor, as passed to the Thread- or ProcessPoolExecutor.

  • use_threads – Use the ThreadPoolExecutor instead of the ProcessPoolExecutor.

Bus.iter_element_items().map_all(mapping, *, dtype, name)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.map_all(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None) → FrameOrSeries[source]

Apply a mapping; for values not in the mapping, an Exception is raised. Returns a new container.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

Bus.iter_element_items().map_all_iter(mapping)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.map_all_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.

Bus.iter_element_items().map_all_iter_items(mapping)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.map_all_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, an Exception is raised. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.

Bus.iter_element_items().map_any(mapping, *, dtype, name)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.map_any(mapping: Union[Mapping[Hashable, Any], Series], *, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None) → FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the value is returned. Returns a new container.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

Bus.iter_element_items().map_any_iter(mapping)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.map_any_iter(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting values.

Parameters

mapping – A mapping type, such as a dictionary or Series.

Bus.iter_element_items().map_any_iter_items(mapping)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.map_any_iter_items(mapping: Union[Mapping[Hashable, Any], Series]) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the value is returned. A generator of resulting key, value pairs.

Parameters

mapping – A mapping type, such as a dictionary or Series.

Bus.iter_element_items().map_fill(mapping, *, fill_value, dtype, name)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.map_fill(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan, dtype: Optional[Union[str, numpy.dtype, type]] = None, name: Optional[Hashable] = None) → FrameOrSeries[source]

Apply a mapping; for values not in the mapping, the fill_value is returned. Returns a new container.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • fill_value – Value to be returned if the values is not a key in the mapping.

  • dtype – A value suitable for specyfying a NumPy dtype, such as a Python type (float), NumPy array protocol strings (‘f8’), or a dtype instance.

Bus.iter_element_items().map_fill_iter(mapping, *, fill_value)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.map_fill_iter(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Any][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting values.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • fill_value – Value to be returned if the values is not a key in the mapping.

Bus.iter_element_items().map_fill_iter_items(mapping, *, fill_value)
iter_element_items

Iterator of label, element pairs.

IterNodeDelegate.map_fill_iter_items(mapping: Union[Mapping[Hashable, Any], Series], *, fill_value: Any = nan) → Iterator[Tuple[Any, Any]][source]

Apply a mapping; for values not in the mapping, the fill_value is returned. A generator of resulting key, value pairs.

Parameters

  • mapping – A mapping type, such as a dictionary or Series.

  • fill_value – Value to be returned if the values is not a key in the mapping.

Bus: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary

Bus: Operator Binary

Overview: Bus: Operator Binary

Bus.__eq__(value, /)

Return self==value.

Bus.__ge__(value, /)

Return self>=value.

Bus.__gt__(value, /)

Return self>value.

Bus.__le__(value, /)

Return self<=value.

Bus.__lt__(value, /)

Return self<value.

Bus.__ne__(value, /)

Return self!=value.

Bus: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary