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 aBus
. With the Quilt,Frame
contained in aBus
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 containedFrame, ``retain_labels`
can be set toFalse
and underlying labels are simply concatenated; otherwise,retain_labels
must be set toTrue
and an additional depthlevel is added to the primary axis labels. AQuilt
can only be created if labels of the opposite axis of all containedFrame
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
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 anIndexHierarchy
. This is required to beTrue
if componentFrame
labels are not globally unique along the axis of concatenation.deepcopy_from_bus – Boolean to determine if containers are deepcopied from the contained
Bus
during extraction. Set toTrue
to avoid holding references from theBus
.

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 aQuilt
by partitioning it along the specifiedaxis
in units ofchunksize
, whereaxis
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 ofFrame
; labels will be drawn fromFrame.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 aQuilt
instance. Parameters
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig
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 anIndexHierarchy
. This is required to beTrue
if componentFrame
labels are not globally unique along the axis of concatenation.deepcopy_from_bus – Boolean to determine if containers are deepcopied from the contained
Bus
during extraction. Set toTrue
to avoid holding references from theBus
.max_persist – When loading
Frame
from aStore
, optionally define the maximum number ofFrame
to remain in theBus
, regardless of the size of theBus
. If more thanmax_persist
number ofFrame
are loaded, leastrecently loadedFrame
will be replaced byFrameDeferred
. Amax_persist
of 1, for example, permits reading oneFrame
at a time without ever holding in memory more than 1Frame
.

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]

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 aQuilt
instance. Parameters
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig
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 anIndexHierarchy
. This is required to beTrue
if componentFrame
labels are not globally unique along the axis of concatenation.deepcopy_from_bus – Boolean to determine if containers are deepcopied from the contained
Bus
during extraction. Set toTrue
to avoid holding references from theBus
.max_persist – When loading
Frame
from aStore
, optionally define the maximum number ofFrame
to remain in theBus
, regardless of the size of theBus
. If more thanmax_persist
number ofFrame
are loaded, leastrecently loadedFrame
will be replaced byFrameDeferred
. Amax_persist
of 1, for example, permits reading oneFrame
at a time without ever holding in memory more than 1Frame
.

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 aQuilt
instance. Parameters
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig
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 anIndexHierarchy
. This is required to beTrue
if componentFrame
labels are not globally unique along the axis of concatenation.deepcopy_from_bus – Boolean to determine if containers are deepcopied from the contained
Bus
during extraction. Set toTrue
to avoid holding references from theBus
.max_persist – When loading
Frame
from aStore
, optionally define the maximum number ofFrame
to remain in theBus
, regardless of the size of theBus
. If more thanmax_persist
number ofFrame
are loaded, leastrecently loadedFrame
will be replaced byFrameDeferred
. Amax_persist
of 1, for example, permits reading oneFrame
at a time without ever holding in memory more than 1Frame
.

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 aQuilt
instance. Parameters
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig
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 anIndexHierarchy
. This is required to beTrue
if componentFrame
labels are not globally unique along the axis of concatenation.deepcopy_from_bus – Boolean to determine if containers are deepcopied from the contained
Bus
during extraction. Set toTrue
to avoid holding references from theBus
.max_persist – When loading
Frame
from aStore
, optionally define the maximum number ofFrame
to remain in theBus
, regardless of the size of theBus
. If more thanmax_persist
number ofFrame
are loaded, leastrecently loadedFrame
will be replaced byFrameDeferred
. Amax_persist
of 1, for example, permits reading oneFrame
at a time without ever holding in memory more than 1Frame
.

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 aQuilt
instance. Parameters
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig
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 anIndexHierarchy
. This is required to beTrue
if componentFrame
labels are not globally unique along the axis of concatenation.deepcopy_from_bus – Boolean to determine if containers are deepcopied from the contained
Bus
during extraction. Set toTrue
to avoid holding references from theBus
.max_persist – When loading
Frame
from aStore
, optionally define the maximum number ofFrame
to remain in theBus
, regardless of the size of theBus
. If more thanmax_persist
number ofFrame
are loaded, leastrecently loadedFrame
will be replaced byFrameDeferred
. Amax_persist
of 1, for example, permits reading oneFrame
at a time without ever holding in memory more than 1Frame
.

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 aQuilt
instance. Parameters
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig
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 anIndexHierarchy
. This is required to beTrue
if componentFrame
labels are not globally unique along the axis of concatenation.deepcopy_from_bus – Boolean to determine if containers are deepcopied from the contained
Bus
during extraction. Set toTrue
to avoid holding references from theBus
.max_persist – When loading
Frame
from aStore
, optionally define the maximum number ofFrame
to remain in theBus
, regardless of the size of theBus
. If more thanmax_persist
number ofFrame
are loaded, leastrecently loadedFrame
will be replaced byFrameDeferred
. Amax_persist
of 1, for example, permits reading oneFrame
at a time without ever holding in memory more than 1Frame
.

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 aQuilt
instance. Parameters
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig
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 anIndexHierarchy
. This is required to beTrue
if componentFrame
labels are not globally unique along the axis of concatenation.deepcopy_from_bus – Boolean to determine if containers are deepcopied from the contained
Bus
during extraction. Set toTrue
to avoid holding references from theBus
.max_persist – When loading
Frame
from aStore
, optionally define the maximum number ofFrame
to remain in theBus
, regardless of the size of theBus
. If more thanmax_persist
number ofFrame
are loaded, leastrecently loadedFrame
will be replaced byFrameDeferred
. Amax_persist
of 1, for example, permits reading oneFrame
at a time without ever holding in memory more than 1Frame
.
Quilt: Constructor  Exporter  Attribute  Method  DictionaryLike  Display  Selector  Iterator  Operator Binary
Quilt: Exporter¶
Overview: Quilt: Exporter

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
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig

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
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig

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
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig

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
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig

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
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig

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
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig

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
fp – A string file path or
Path
instance.config – A
StoreConfig
, or a mapping of label otStoreConfig
Quilt: Constructor  Exporter  Attribute  Method  DictionaryLike  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 loadedFrame
in the containedQuilt
.
Quilt: Constructor  Exporter  Attribute  Method  DictionaryLike  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 bycount
. 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 bycount
. Parameters
count – Number of elements to be returned from the bottom of the
Quilt
Quilt: Constructor  Exporter  Attribute  Method  DictionaryLike  Display  Selector  Iterator  Operator Binary
Quilt: DictionaryLike¶
Overview: Quilt: DictionaryLike

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 dictionarylike 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  DictionaryLike  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 entireFrame
.

Quilt.
__str__
() Return str(self).

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

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, thestatic_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, thestatic_frame.DisplayActive
will be used.
Quilt: Constructor  Exporter  Attribute  Method  DictionaryLike  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  DictionaryLike  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)

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

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) 

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) 

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) 

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) 

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) 

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) 

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) 

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) 

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) 

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) 

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) 

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) 

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)

Quilt.
iter_series_items
(*, axis).apply(func, *, dtype, name) 
iter_series_items
Iterator of pairs of label,
Series
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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
, whereSeries
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 optionalconstructor
callable can be used to provide aNamedTuple
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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 nonoverlapping 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 rightmost 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 thansize
.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 settingstep
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  DictionaryLike  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  DictionaryLike  Display  Selector  Iterator  Operator Binary