Quilt

Overview: Quilt

class Quilt(bus: static_frame.core.bus.Bus, *, axis: int = 0, retain_labels: bool, axis_map: Optional[static_frame.core.series.Series] = None, axis_opposite: Optional[static_frame.core.index_base.IndexBase] = None, deepcopy_from_bus: bool = False)[source]

A Frame-like view of the contents of a Bus. With the Quilt, Frame contained in a Bus can be conceived as stacking vertically (primary axis 0) or horizontally (primary axis 1). If the labels of the primary axis are unique accross all contained Frame, ``retain_labels` can be set to False and underlying labels are simply concatenated; otherwise, retain_labels must be set to True and an additional depth-level is added to the primary axis labels. A Quilt can only be created if labels of the opposite axis of all contained Frame are aligned.

Quilt: Constructor

Overview: Quilt: Constructor

Quilt.__init__(bus: static_frame.core.bus.Bus, *, axis: int = 0, retain_labels: bool, axis_map: Optional[static_frame.core.series.Series] = None, axis_opposite: Optional[static_frame.core.index_base.IndexBase] = None, deepcopy_from_bus: bool = False)None[source]
Parameters
  • busBus of Frame to be used for virtual concatenation.

  • axis – Integer specifying axis of virtual concatenation, where 0 is vertically (stacking rows) and 1 is horizontally (extending columns).

  • retain_labels – Boolean to determine if, along the axis of virtual concatentation, if component Frame labels should be used to form the outer depth of an IndexHierarchy. This is required to be True if component Frame labels are not globally unique along the axis of concatenation.

  • deepcopy_from_bus – Boolean to determine if containers are deep-copied from the contained Bus during extraction. Set to True to avoid holding references from the Bus.

classmethod Quilt.from_frame(frame: static_frame.core.frame.Frame, *, chunksize: int, retain_labels: bool, axis: int = 0, name: Optional[Hashable] = None, label_extractor: Optional[Callable[[static_frame.core.index_base.IndexBase], Hashable]] = None, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, StoreConfigMap] = None, deepcopy_from_bus: bool = False)Quilt[source]

Given a Frame, create a Quilt by partitioning it along the specified axis in units of chunksize, where axis 0 partitions vertically (retaining aligned columns) and 1 partions horizontally (retaining aligned index).

Parameters

label_extractor – Function that, given the partitioned index component along the specified axis, returns a string label for that chunk.

classmethod Quilt.from_frames(frames: Iterable[static_frame.core.frame.Frame], *, axis: int = 0, name: Optional[Hashable] = None, retain_labels: bool, deepcopy_from_bus: bool = False)static_frame.core.quilt.Quilt[source]

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

classmethod Quilt.from_hdf5(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, StoreConfigMap] = None, axis: int = 0, retain_labels: bool, deepcopy_from_bus: bool = False, max_persist: Optional[int] = None)Quilt[source]

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

Parameters
  • fp – A string file path or Path instance.

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

  • axis – Integer specifying axis of virtual concatenation, where 0 is vertically (stacking rows) and 1 is horizontally (extending columns).

  • retain_labels – Boolean to determine if, along the axis of virtual concatentation, if component Frame labels should be used to form the outer depth of an IndexHierarchy. This is required to be True if component Frame labels are not globally unique along the axis of concatenation.

  • deepcopy_from_bus – Boolean to determine if containers are deep-copied from the contained Bus during extraction. Set to True to avoid holding references from the Bus.

  • 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 Quilt.from_items(items: Iterable[Tuple[Hashable, static_frame.core.frame.Frame]], *, axis: int = 0, name: Optional[Hashable] = None, retain_labels: bool, deepcopy_from_bus: bool = False)static_frame.core.quilt.Quilt[source]

Given an iterable of pairs of label, Frame, create a Quilt.

classmethod Quilt.from_sqlite(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, StoreConfigMap] = None, axis: int = 0, retain_labels: bool, deepcopy_from_bus: bool = False, max_persist: Optional[int] = None)Quilt[source]

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

Parameters
  • fp – A string file path or Path instance.

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

  • axis – Integer specifying axis of virtual concatenation, where 0 is vertically (stacking rows) and 1 is horizontally (extending columns).

  • retain_labels – Boolean to determine if, along the axis of virtual concatentation, if component Frame labels should be used to form the outer depth of an IndexHierarchy. This is required to be True if component Frame labels are not globally unique along the axis of concatenation.

  • deepcopy_from_bus – Boolean to determine if containers are deep-copied from the contained Bus during extraction. Set to True to avoid holding references from the Bus.

  • 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 Quilt.from_xlsx(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, StoreConfigMap] = None, axis: int = 0, retain_labels: bool, deepcopy_from_bus: bool = False, max_persist: Optional[int] = None)Quilt[source]

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

Parameters
  • fp – A string file path or Path instance.

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

  • axis – Integer specifying axis of virtual concatenation, where 0 is vertically (stacking rows) and 1 is horizontally (extending columns).

  • retain_labels – Boolean to determine if, along the axis of virtual concatentation, if component Frame labels should be used to form the outer depth of an IndexHierarchy. This is required to be True if component Frame labels are not globally unique along the axis of concatenation.

  • deepcopy_from_bus – Boolean to determine if containers are deep-copied from the contained Bus during extraction. Set to True to avoid holding references from the Bus.

  • 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 Quilt.from_zip_csv(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, StoreConfigMap] = None, axis: int = 0, retain_labels: bool, deepcopy_from_bus: bool = False, max_persist: Optional[int] = None)Quilt[source]

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

Parameters
  • fp – A string file path or Path instance.

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

  • axis – Integer specifying axis of virtual concatenation, where 0 is vertically (stacking rows) and 1 is horizontally (extending columns).

  • retain_labels – Boolean to determine if, along the axis of virtual concatentation, if component Frame labels should be used to form the outer depth of an IndexHierarchy. This is required to be True if component Frame labels are not globally unique along the axis of concatenation.

  • deepcopy_from_bus – Boolean to determine if containers are deep-copied from the contained Bus during extraction. Set to True to avoid holding references from the Bus.

  • 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 Quilt.from_zip_parquet(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, StoreConfigMap] = None, axis: int = 0, retain_labels: bool, deepcopy_from_bus: bool = False, max_persist: Optional[int] = None)Quilt[source]

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

Parameters
  • fp – A string file path or Path instance.

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

  • axis – Integer specifying axis of virtual concatenation, where 0 is vertically (stacking rows) and 1 is horizontally (extending columns).

  • retain_labels – Boolean to determine if, along the axis of virtual concatentation, if component Frame labels should be used to form the outer depth of an IndexHierarchy. This is required to be True if component Frame labels are not globally unique along the axis of concatenation.

  • deepcopy_from_bus – Boolean to determine if containers are deep-copied from the contained Bus during extraction. Set to True to avoid holding references from the Bus.

  • 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 Quilt.from_zip_pickle(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, StoreConfigMap] = None, axis: int = 0, retain_labels: bool, deepcopy_from_bus: bool = False, max_persist: Optional[int] = None)Quilt[source]

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

Parameters
  • fp – A string file path or Path instance.

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

  • axis – Integer specifying axis of virtual concatenation, where 0 is vertically (stacking rows) and 1 is horizontally (extending columns).

  • retain_labels – Boolean to determine if, along the axis of virtual concatentation, if component Frame labels should be used to form the outer depth of an IndexHierarchy. This is required to be True if component Frame labels are not globally unique along the axis of concatenation.

  • deepcopy_from_bus – Boolean to determine if containers are deep-copied from the contained Bus during extraction. Set to True to avoid holding references from the Bus.

  • 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 Quilt.from_zip_tsv(fp: Union[str, os.PathLike], *, config: Union[static_frame.core.store.StoreConfig, Mapping[Any, static_frame.core.store.StoreConfig], None, StoreConfigMap] = None, axis: int = 0, retain_labels: bool, deepcopy_from_bus: bool = False, max_persist: Optional[int] = None)Quilt[source]

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

Parameters
  • fp – A string file path or Path instance.

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

  • axis – Integer specifying axis of virtual concatenation, where 0 is vertically (stacking rows) and 1 is horizontally (extending columns).

  • retain_labels – Boolean to determine if, along the axis of virtual concatentation, if component Frame labels should be used to form the outer depth of an IndexHierarchy. This is required to be True if component Frame labels are not globally unique along the axis of concatenation.

  • deepcopy_from_bus – Boolean to determine if containers are deep-copied from the contained Bus during extraction. Set to True to avoid holding references from the Bus.

  • 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.

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

Quilt: Exporter

Overview: Quilt: Exporter

Quilt.to_frame()static_frame.core.frame.Frame[source]

Return a consolidated Frame.

Quilt.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
Quilt.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
Quilt.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
Quilt.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
Quilt.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
Quilt.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
Quilt.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

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

Quilt: Attribute

Overview: Quilt: Attribute

Quilt.STATIC: bool = True
Quilt.columns

The IndexBase instance assigned for column labels.

Quilt.index

The IndexBase instance assigned for row labels.

Quilt.name

A hashable label attached to this container.

Returns

Hashable

Quilt.nbytes

Return the total bytes of the underlying NumPy arrays.

Returns

int

Quilt.ndim

Return the number of dimensions, which for a Frame is always 2.

Returns

int

Quilt.shape

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

Returns

tp.Tuple[int]

Quilt.size

Return the size of the underlying NumPy array.

Returns

int

Quilt.status

Return a Frame indicating loaded status, size, bytes, and shape of all loaded Frame in the contained Quilt.

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

Quilt: Method

Overview: Quilt: Method

Quilt.__bool__()bool

Raises ValueError to prohibit ambiguous use of truethy evaluation.

Quilt.equals(other: Any, *, compare_name: bool = False, compare_dtype: bool = False, compare_class: bool = False, skipna: bool = True)bool
Quilt.head(count: int = 5)static_frame.core.frame.Frame[source]

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

Parameters

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

Quilt.rename(name: Optional[Hashable])static_frame.core.quilt.Quilt[source]

Return a new Quilt with an updated name attribute.

Quilt.tail(count: int = 5)static_frame.core.frame.Frame[source]

Return a Quilt consisting only of the bottom elements as specified by count.

Parameters

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

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

Quilt: Dictionary-Like

Overview: Quilt: Dictionary-Like

Quilt.__contains__(value: Hashable)bool[source]

Inclusion of value in column labels.

Quilt.__iter__()Iterable[Hashable][source]

Iterator of column labels, same as Frame.keys().

Quilt.get(key: Hashable, default: Optional[static_frame.core.series.Series] = None)Optional[static_frame.core.series.Series][source]

Return the value found at the columns key, else the default if the key is not found. This method is implemented to complete the dictionary-like interface.

Quilt.items()Iterator[Tuple[Hashable, static_frame.core.series.Series]][source]

Iterator of pairs of column label and corresponding column Series.

Quilt.keys()Iterable[Hashable][source]

Iterator of column labels.

Quilt.values

A 2D NumPy array of all values in the Quilt. As this is a single array, heterogenous columnar types might be coerced to a compatible type.

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

Quilt: Display

Overview: Quilt: Display

Quilt.interface

A Frame documenting the interface of this class.

Quilt.__repr__()str[source]

Provide a display of the Quilt that does not realize the entire Frame.

Quilt.__str__()

Return str(self).

Quilt.display(config: Optional[static_frame.core.display_config.DisplayConfig] = None)static_frame.core.display.Display[source]

Provide a Frame-style display of the Quilt.

Quilt.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.

Quilt.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.

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

Quilt: Selector

Overview: Quilt: Selector

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

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

Quilt: Iterator

Overview: Quilt: Iterator

Quilt.iter_array(*, axis)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

Quilt.iter_array(*, axis).apply(func, *, dtype, name)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).apply_iter(func)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).apply_iter_items(func)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).map_all(mapping, *, dtype, name)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).map_all_iter(mapping)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).map_all_iter_items(mapping)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).map_any(mapping, *, dtype, name)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).map_any_iter(mapping)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).map_any_iter_items(mapping)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).map_fill(mapping, *, fill_value, dtype, name)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).map_fill_iter(mapping, *, fill_value)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array(*, axis).map_fill_iter_items(mapping, *, fill_value)
iter_array

Iterator of np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

Quilt.iter_array_items(*, axis).apply(func, *, dtype, name)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).apply_iter(func)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).apply_iter_items(func)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).map_all(mapping, *, dtype, name)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).map_all_iter(mapping)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).map_all_iter_items(mapping)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).map_any(mapping, *, dtype, name)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).map_any_iter(mapping)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).map_any_iter_items(mapping)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).map_fill(mapping, *, fill_value, dtype, name)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).map_fill_iter(mapping, *, fill_value)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_array_items(*, axis).map_fill_iter_items(mapping, *, fill_value)
iter_array_items

Iterator of pairs of label, np.array, where arrays are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

Quilt.iter_series(*, axis).apply(func, *, dtype, name)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).apply_iter(func)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).apply_iter_items(func)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).map_all(mapping, *, dtype, name)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).map_all_iter(mapping)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).map_all_iter_items(mapping)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).map_any(mapping, *, dtype, name)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).map_any_iter(mapping)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).map_any_iter_items(mapping)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).map_fill(mapping, *, fill_value, dtype, name)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).map_fill_iter(mapping, *, fill_value)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series(*, axis).map_fill_iter_items(mapping, *, fill_value)
iter_series

Iterator of Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

Quilt.iter_series_items(*, axis).apply(func, *, dtype, name)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).apply_iter(func)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).apply_iter_items(func)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).map_all(mapping, *, dtype, name)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).map_all_iter(mapping)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).map_all_iter_items(mapping)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).map_any(mapping, *, dtype, name)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).map_any_iter(mapping)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).map_any_iter_items(mapping)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).map_fill(mapping, *, fill_value, dtype, name)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).map_fill_iter(mapping, *, fill_value)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_series_items(*, axis).map_fill_iter_items(mapping, *, fill_value)
iter_series_items

Iterator of pairs of label, Series, where Series are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple(*, axis, constructor)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

Quilt.iter_tuple(*, axis, constructor).apply(func, *, dtype, name)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).apply_iter(func)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).apply_iter_items(func)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).map_all(mapping, *, dtype, name)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).map_all_iter(mapping)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).map_all_iter_items(mapping)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).map_any(mapping, *, dtype, name)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).map_any_iter(mapping)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).map_any_iter_items(mapping)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).map_fill(mapping, *, fill_value, dtype, name)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).map_fill_iter(mapping, *, fill_value)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple(*, axis, constructor).map_fill_iter_items(mapping, *, fill_value)
iter_tuple

Iterator of NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1). An optional constructor callable can be used to provide a NamedTuple class (or any other constructor called with a single iterable) to be used to create each yielded axis value.

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.

Quilt.iter_tuple_items(*, axis, constructor)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

Quilt.iter_tuple_items(*, axis, constructor).apply(func, *, dtype, name)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).apply_iter(func)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).apply_iter_items(func)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).map_all(mapping, *, dtype, name)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).map_all_iter(mapping)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).map_all_iter_items(mapping)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).map_any(mapping, *, dtype, name)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).map_any_iter(mapping)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).map_any_iter_items(mapping)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).map_fill(mapping, *, fill_value, dtype, name)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).map_fill_iter(mapping, *, fill_value)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_tuple_items(*, axis, constructor).map_fill_iter_items(mapping, *, fill_value)
iter_tuple_items

Iterator of pairs of label, NamedTuple, where tuples are drawn from columns (axis=0) or rows (axis=1)

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply(func, *, dtype, name)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter(func)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter_items(func)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all(mapping, *, dtype, name)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter(mapping)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter_items(mapping)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any(mapping, *, dtype, name)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter(mapping)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter_items(mapping)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill(mapping, *, fill_value, dtype, name)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter(mapping, *, fill_value)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter_items(mapping, *, fill_value)
iter_window

Iterator of windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply(func, *, dtype, name)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter(func)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter_items(func)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all(mapping, *, dtype, name)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter(mapping)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter_items(mapping)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any(mapping, *, dtype, name)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter(mapping)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter_items(mapping)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill(mapping, *, fill_value, dtype, name)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter(mapping, *, fill_value)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter_items(mapping, *, fill_value)
iter_window_array

Iterator of windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply(func, *, dtype, name)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter(func)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter_items(func)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all(mapping, *, dtype, name)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter(mapping)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter_items(mapping)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any(mapping, *, dtype, name)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter(mapping)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter_items(mapping)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill(mapping, *, fill_value, dtype, name)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter(mapping, *, fill_value)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_array_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter_items(mapping, *, fill_value)
iter_window_array_items

Iterator of pairs of label, windowed values, where values are given as a np.array.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply(func, *, dtype, name)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter(func)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_iter_items(func)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).apply_pool(func, *, dtype, name, max_workers, chunksize, use_threads)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all(mapping, *, dtype, name)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter(mapping)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_all_iter_items(mapping)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any(mapping, *, dtype, name)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter(mapping)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_any_iter_items(mapping)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill(mapping, *, fill_value, dtype, name)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter(mapping, *, fill_value)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

Quilt.iter_window_items(*, size, axis, step, window_sized, window_func, window_valid, label_shift, start_shift, size_increment).map_fill_iter_items(mapping, *, fill_value)
iter_window_items

Iterator of pairs of label, windowed values, where values are given as a Frame.

Parameters
  • size – Elements per window, given as an integer greater than 0.

  • axis – Integer specifying axis, where 0 is rows and 1 is columns. Axis 0 is set by default.

  • step – Element shift per window, given as an integer greater than 0. Determines the step size between windows. A step of 1 shifts each window 1 element; a step equal to the size will result in non-overlapping windows.

  • window_sized – if True, windows with fewer elements than size are skipped.

  • window_func – Array processor of window values, executed before function application (if used): can be used for applying a weighting function to each window.

  • window_valid – Function that, given an array window, returns True if the window is valid; invalid windows are skipped.

  • label_shift – A shift, relative to the right-most element contained in the window, to derive the label to be paired with the window. For example, to label each window with the label found at the start of the window, label_shift can be set to one less than size.

  • start_shift – A shift to determine the first element where window collection begins.

  • size_increment – A value to be added to size with each window after the first, so as to, in combination with setting step to 0, permit iterating over expanding windows.

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.

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

Quilt: Operator Binary

Overview: Quilt: Operator Binary

Quilt.__eq__(value, /)

Return self==value.

Quilt.__ge__(value, /)

Return self>=value.

Quilt.__gt__(value, /)

Return self>value.

Quilt.__le__(value, /)

Return self<=value.

Quilt.__lt__(value, /)

Return self<value.

Quilt.__ne__(value, /)

Return self!=value.

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