Skip to content

chunking module

Utilities for chunking.

chunked function

chunked(
    *args,
    chunker=None,
    replace_chunker=None,
    merge_to_execute_kwargs=None,
    prepend_chunk_meta=None,
    **kwargs
)

Decorator that chunks the inputs of a function using Chunker.

Returns a new function with the same signature as the passed one.

Each option can be modified in the options attribute of the wrapper function or directly passed as a keyword argument with a leading underscore.

Chunking can be disabled using disable argument. Additionally, the entire wrapping mechanism can be disabled by using the global setting disable_wrapping (=> returns the wrapped function).

Keyword arguments not listed in Chunker and execute_kwargs are merged into execute_kwargs if merge_to_execute_kwargs is True, otherwise, they are passed directly to Chunker.

If a chunker instance is provided and replace_chunker is True, will create a new Chunker instance by replacing any arguments that are not None.

Usage

For testing purposes, let's divide the input array into 2 chunks and compute the mean in a sequential manner:

>>> from vectorbtpro import *

>>> @vbt.chunked(
...     n_chunks=2,
...     size=vbt.LenSizer(arg_query='a'),
...     arg_take_spec=dict(a=vbt.ChunkSlicer())
... )
... def f(a):
...     return np.mean(a)

>>> f(np.arange(10))
[2.0, 7.0]

Same can be done using annotations:

>>> @vbt.chunked(n_chunks=2)
... def f(a: vbt.LenSizer() | vbt.ChunkSlicer()):
...     return np.mean(a)

>>> f(np.arange(10))
[2.0, 7.0]

Sizer can be omitted most of the time:

>>> @vbt.chunked(n_chunks=2)
... def f(a: vbt.ChunkSlicer()):
...     return np.mean(a)

>>> f(np.arange(10))
[2.0, 7.0]

Another way is by using specialized Chunker subclasses that depend on the type of the argument:

>>> @vbt.chunked(n_chunks=2)
... def f(a: vbt.ChunkedArray()):
...     return np.mean(a)

>>> f(np.arange(10))

Also, instead of specifying the chunk taking specification beforehand, it can be passed dynamically by wrapping each value to be chunked with Chunked or any of its subclasses:

>>> @vbt.chunked(n_chunks=2)
... def f(a):
...     return np.mean(a)

>>> f(vbt.ChunkedArray(np.arange(10)))
[2.0, 7.0]

The chunked function is a decorator that takes f and creates a function that splits passed arguments, runs each chunk using an engine, and optionally, merges the results. It has the same signature as the original function:

>>> f
<function __main__.f(a)>

We can change any option at any time:

>>> # Change the option directly on the function
>>> f.options.n_chunks = 3

>>> f(np.arange(10))
[1.5, 5.0, 8.0]

>>> # Pass a new option with a leading underscore
>>> f(np.arange(10), _n_chunks=4)
[1.0, 4.0, 6.5, 8.5]

When we run the wrapped function, it first generates a list of chunk metadata of type ChunkMeta. Chunk metadata contains the chunk index that can be used to split any input:

>>> list(vbt.iter_chunk_meta(n_chunks=2))
[ChunkMeta(uuid='84d64eed-fbac-41e7-ad61-c917e809b3b8', idx=0, start=None, end=None, indices=None),
 ChunkMeta(uuid='577817c4-fdee-4ceb-ab38-dcd663d9ab11', idx=1, start=None, end=None, indices=None)]

Additionally, it may contain the start and end index of the space we want to split. The space can be defined by the length of an input array, for example. In our case:

>>> list(vbt.iter_chunk_meta(n_chunks=2, size=10))
[ChunkMeta(uuid='c1593842-dc31-474c-a089-e47200baa2be', idx=0, start=0, end=5, indices=None),
 ChunkMeta(uuid='6d0265e7-1204-497f-bc2c-c7b7800ec57d', idx=1, start=5, end=10, indices=None)]

If we know the size of the space in advance, we can pass it as an integer constant. Otherwise, we need to tell chunked to derive the size from the inputs dynamically by passing any subclass of Sizer. In the example above, we instruct the wrapped function to derive the size from the length of the input array a.

Once all chunks are generated, the wrapped function attempts to split inputs into chunks. The specification for this operation can be provided by the arg_take_spec argument, which in most cases is a dictionary of ChunkTaker instances keyed by the input name. Here's an example of a complex specification:

>>> arg_take_spec = dict(
...     a=vbt.ChunkSelector(),
...     args=vbt.ArgsTaker(
...         None,
...         vbt.ChunkSelector()
...     ),
...     b=vbt.SequenceTaker([
...         None,
...         vbt.ChunkSelector()
...     ]),
...     kwargs=vbt.KwargsTaker(
...         c=vbt.MappingTaker(dict(
...             d=vbt.ChunkSelector(),
...             e=None
...         ))
...     )
... )

>>> @vbt.chunked(
...     n_chunks=vbt.LenSizer(arg_query='a'),
...     arg_take_spec=arg_take_spec
... )
... def f(a, *args, b=None, **kwargs):
...     return a + sum(args) + sum(b) + sum(kwargs['c'].values())

>>> f([1, 2, 3], 10, [1, 2, 3], b=(100, [1, 2, 3]), c=dict(d=[1, 2, 3], e=1000))
[1114, 1118, 1122]

After splitting all inputs into chunks, the wrapped function forwards them to the engine function. The engine argument can be either the name of a supported engine, or a callable. Once the engine has finished all tasks and returned a list of results, we can merge them back using merge_func:

>>> @vbt.chunked(
...     n_chunks=2,
...     size=vbt.LenSizer(arg_query='a'),
...     arg_take_spec=dict(a=vbt.ChunkSlicer()),
...     merge_func="concat"
... )
... def f(a):
...     return a

>>> f(np.arange(10))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

The same using annotations:

>>> @vbt.chunked(n_chunks=2)
... def f(a: vbt.ChunkSlicer()) -> vbt.MergeFunc("concat"):
...     return a

>>> f(np.arange(10))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Instead of (or in addition to) specifying arg_take_spec, we can define our function with the first argument being chunk_meta to be able to split the arguments during the execution. The chunked decorator will automatically recognize and replace it with the actual ChunkMeta object:

>>> @vbt.chunked(
...     n_chunks=2,
...     size=vbt.LenSizer(arg_query='a'),
...     arg_take_spec=dict(a=None),
...     merge_func="concat"
... )
... def f(chunk_meta, a):
...     return a[chunk_meta.start:chunk_meta.end]

>>> f(np.arange(10))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

This may be a good idea in multi-threading, but a bad idea in multi-processing.

The same can be accomplished by using templates (here we tell chunked to not replace the first argument by setting prepend_chunk_meta to False):

>>> @vbt.chunked(
...     n_chunks=2,
...     size=vbt.LenSizer(arg_query='a'),
...     arg_take_spec=dict(a=None),
...     merge_func="concat",
...     prepend_chunk_meta=False
... )
... def f(chunk_meta, a):
...     return a[chunk_meta.start:chunk_meta.end]

>>> f(vbt.Rep('chunk_meta'), np.arange(10))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Templates in arguments are substituted right before taking a chunk from them.

Keyword arguments to the engine can be provided using execute_kwargs:

>>> @vbt.chunked(
...     n_chunks=2,
...     size=vbt.LenSizer(arg_query='a'),
...     arg_take_spec=dict(a=vbt.ChunkSlicer()),
...     show_progress=True
... )
... def f(a):
...     return np.mean(a)

>>> f(np.arange(10))
100% |█████████████████████████████████| 2/2 [00:00<00:00, 81.11it/s]
[2.0, 7.0]

get_chunk_meta_key function

get_chunk_meta_key(
    chunk_meta
)

Get key corresponding to chunk meta.

iter_chunk_meta function

iter_chunk_meta(
    size=None,
    min_size=None,
    n_chunks=None,
    chunk_len=None
)

Yield meta of each successive chunk from a sequence with a number of elements.

Args

size : int
Size of the space to split.
min_size : int

Minimum size.

If size is lower than this number, returns a single chunk.

n_chunks : int or str

Number of chunks.

If "auto", becomes the number of cores.

chunk_len : int or str

Length of each chunk.

If "auto", becomes the number of cores.

If size, n_chunks, and chunk_len are None (after resolving them from settings), returns a single chunk. If only n_chunks and chunk_len are None, sets n_chunks to "auto".

resolve_chunked function

resolve_chunked(
    func,
    option=None,
    **kwargs
)

Decorate with chunked based on an option.

resolve_chunked_option function

resolve_chunked_option(
    option=None
)

Return keyword arguments for chunked.

option can be:

  • True: Chunk using default settings
  • None or False: Do not chunk
  • string: Use option as the name of an execution engine (see execute)
  • dict: Use option as keyword arguments passed to chunked

For defaults, see option in chunking.

specialize_chunked_option function

specialize_chunked_option(
    option=None,
    **kwargs
)

Resolve option and merge it with kwargs if it's not None so the dict can be passed as an option to other functions.

ArgChunkMeta class

ArgChunkMeta(
    *args,
    **kwargs
)

Class for generating chunk metadata from an argument.

Superclasses

Inherited members

Subclasses

ArgGetter class

ArgGetter(
    *args,
    **kwargs
)

Class for getting an argument from annotated arguments.

Superclasses

Inherited members

Subclasses

arg_query field

Query for annotated argument to derive the size from.

get_arg method

ArgGetter.get_arg(
    ann_args
)

Get argument using match_ann_arg.

ArgSizer class

ArgSizer(
    *args,
    **kwargs
)

Class for getting the size from an argument.

Superclasses

Inherited members

Subclasses

single_type field

One or multiple types to consider as a single value.

ArgsTaker class

ArgsTaker(
    *args,
    single_type=None,
    ignore_none=True,
    mapper=None
)

Class for taking from a variable arguments container.

Superclasses

Inherited members

ArraySelector class

ArraySelector(
    *args,
    **kwargs
)

Class for selecting one element from an array's axis based on the chunk index.

Superclasses

Inherited members

Subclasses

ArraySizer class

ArraySizer(
    *args,
    **kwargs
)

Class for getting the size from the length of an axis in an array.

Superclasses

Inherited members

Subclasses

ArraySlicer class

ArraySlicer(
    *args,
    **kwargs
)

Class for slicing multiple elements from an array's axis based on the chunk range.

Superclasses

Inherited members

Subclasses

AxisSpecifier class

AxisSpecifier(
    *args,
    **kwargs
)

Class with an attribute for specifying an axis.

Superclasses

Inherited members

Subclasses

axis field

Axis of the argument to take from.

ChunkMapper class

ChunkMapper(
    *args,
    **kwargs
)

Abstract class for mapping chunk metadata.

Implements the abstract ChunkMapper.map method.

Supports caching of each pair of incoming and outgoing ChunkMeta instances.

Note

Use ChunkMapper.apply instead of ChunkMapper.map.

Superclasses

Inherited members

Subclasses

apply method

ChunkMapper.apply(
    chunk_meta,
    **kwargs
)

Apply the mapper.

chunk_meta_cache field

Cache for outgoing ChunkMeta instances keyed by UUID of the incoming ones.

map method

ChunkMapper.map(
    chunk_meta,
    **kwargs
)

Abstract method for mapping chunk metadata.

Takes the chunk metadata of type ChunkMeta and returns a new chunk metadata of the same type.

should_cache field

Whether should cache.

ChunkMeta class

ChunkMeta(
    *args,
    **kwargs
)

Class that represents a chunk metadata.

Superclasses

Inherited members

end field

End of the chunk range (excluding). Can be None.

idx field

Chunk index.

indices field

Indices included in the chunk range. Can be None.

Has priority over ChunkMeta.start and ChunkMeta.end.

start field

Start of the chunk range (including). Can be None.

uuid field

Unique identifier of the chunk.

Used for caching.

ChunkMetaGenerator class

ChunkMetaGenerator()

Abstract class for generating chunk metadata from annotated arguments.

Superclasses

Inherited members

Subclasses

get_chunk_meta method

ChunkMetaGenerator.get_chunk_meta(
    ann_args,
    **kwargs
)

Get chunk metadata.

ChunkSelector class

ChunkSelector(
    *args,
    **kwargs
)

Class for selecting one element based on the chunk index.

Superclasses

Inherited members

Subclasses

ChunkSlicer class

ChunkSlicer(
    *args,
    **kwargs
)

Class for slicing multiple elements based on the chunk range.

Superclasses

Inherited members

Subclasses

ChunkTaker class

ChunkTaker(
    *args,
    **kwargs
)

Abstract class for taking one or more elements based on the chunk index or range.

Note

Use ChunkTaker.apply instead of ChunkTaker.take.

Superclasses

Inherited members

Subclasses

apply method

ChunkTaker.apply(
    obj,
    chunk_meta,
    **kwargs
)

Apply the taker.

eval_id field

One or more identifiers at which to evaluate this instance.

get_size method

ChunkTaker.get_size(
    obj,
    **kwargs
)

Get the actual size of the argument.

ignore_none field

Whether to ignore None.

mapper field

Chunk mapper of type ChunkMapper.

should_take method

ChunkTaker.should_take(
    obj,
    chunk_meta,
    **kwargs
)

Check whether to take a chunk or leave the argument as it is.

single_type field

One or multiple types to consider as a single value.

suggest_size method

ChunkTaker.suggest_size(
    obj,
    **kwargs
)

Suggest a global size based on the argument's size.

take method

ChunkTaker.take(
    obj,
    chunk_meta,
    **kwargs
)

Abstract method for taking subset of data.

Takes the argument object, the chunk meta (tuple out of the index, start index, and end index of the chunk), and other keyword arguments passed down the stack, such as chunker and silence_warnings.

Chunkable class

Chunkable()

Abstract class representing a value and a chunk taking specification.

Superclasses

Inherited members

Subclasses

get_take_spec method

Chunkable.get_take_spec()

Get the chunk taking specification.

get_value method

Chunkable.get_value()

Get the value.

Chunked class

Chunked(
    *args,
    **kwargs
)

Class representing a chunkable value.

Can take a variable number of keyword arguments, which will be used as Chunked.take_spec_kwargs.

Superclasses

Inherited members

Subclasses

eval_id field

One or more identifiers at which to evaluate this instance.

resolve_take_spec method

Chunked.resolve_take_spec()

Resolve take_spec.

select field

Whether to chunk by selection.

take_spec field

Chunk taking specification.

take_spec_kwargs field

Keyword arguments passed to the respective ChunkTaker subclass.

If Chunked.take_spec is an instance rather than a class, will "evolve" it.

take_spec_missing field

Check whether Chunked.take_spec is missing.

value field

Value.

ChunkedArray class

ChunkedArray(
    *args,
    **kwargs
)

Class representing a chunkable array.

Superclasses

Inherited members

flex field

Whether the array is flexible.

ChunkedCount class

ChunkedCount(
    *args,
    **kwargs
)

Class representing a chunkable count.

Superclasses

Inherited members

ChunkedShape class

ChunkedShape(
    *args,
    **kwargs
)

Class representing a chunkable shape.

Superclasses

Inherited members

Chunker class

Chunker(
    size=None,
    min_size=None,
    n_chunks=None,
    chunk_len=None,
    chunk_meta=None,
    prepend_chunk_meta=None,
    skip_single_chunk=None,
    arg_take_spec=None,
    template_context=None,
    merge_func=None,
    merge_kwargs=None,
    return_raw_chunks=None,
    silence_warnings=None,
    forward_kwargs_as=None,
    execute_kwargs=None,
    disable=None,
    **kwargs
)

Class responsible for chunking arguments of a function and running the function.

Does the following:

  1. Generates chunk metadata by passing n_chunks, size, min_size, chunk_len, and chunk_meta to Chunker.get_chunk_meta_from_args.
  2. Splits arguments and keyword arguments by passing chunk metadata, arg_take_spec, and template_context to Chunker.iter_tasks, which yields one chunk at a time.
  3. Executes all chunks by passing **execute_kwargs to execute.
  4. Optionally, post-processes and merges the results by passing them and **merge_kwargs to merge_func.

For defaults, see chunking.

Superclasses

Inherited members

adapt_ann_args class method

Chunker.adapt_ann_args(
    ann_args,
    eval_id=None
)

Adapt annotated arguments.

arg_take_spec class property

See iter_tasks.

chunk_len class property

See Chunker.get_chunk_meta_from_args.

chunk_meta class property

See Chunker.get_chunk_meta_from_args.

disable class property

Whether to disable chunking.

execute_kwargs class property

Keyword arguments passed to execute.

fill_arg_take_spec class method

Chunker.fill_arg_take_spec(
    arg_take_spec,
    ann_args
)

Fill the chunk taking specification with None to avoid warnings.

find_take_spec class method

Chunker.find_take_spec(
    i,
    ann_arg_name,
    ann_arg,
    arg_take_spec
)

Resolve the specification for an argument.

forward_kwargs_as class property

Map to rename keyword arguments.

Can also pass any variable from the scope of Chunker.run

get_chunk_meta_from_args class method

Chunker.get_chunk_meta_from_args(
    ann_args,
    size=None,
    min_size=None,
    n_chunks=None,
    chunk_len=None,
    chunk_meta=None,
    **kwargs
)

Get chunk metadata from annotated arguments.

Args

ann_args : dict
Arguments annotated with annotate_args.
size : int, Sizer, or callable

See iter_chunk_meta.

Can be an integer, an instance of Sizer, or a callable taking the annotated arguments and returning a value.

min_size : int
See iter_chunk_meta.
n_chunks : int, str, Sizer, or callable

See iter_chunk_meta.

Can be an integer, a string, an instance of Sizer, or a callable taking the annotated arguments and other keyword arguments and returning a value.

chunk_len : int, str, Sizer, or callable

See iter_chunk_meta.

Can be an integer, a string, an instance of Sizer, or a callable taking the annotated arguments and returning a value.

chunk_meta : iterable of ChunkMeta, ChunkMetaGenerator, or callable

Chunk meta.

Can be an iterable of ChunkMeta, an instance of ChunkMetaGenerator, or a callable taking the annotated arguments and other arguments and returning an iterable.

**kwargs
Other keyword arguments passed to any callable.

iter_tasks class method

Chunker.iter_tasks(
    func,
    ann_args,
    chunk_meta,
    arg_take_spec=None,
    template_context=None,
    **kwargs
)

Split annotated arguments into chunks using Chunker.take_from_args and yield each chunk as a task.

Args

func : callable
Callable.
ann_args : dict
Arguments annotated with annotate_args.
chunk_meta : iterable of ChunkMeta
Chunk metadata.
arg_take_spec : mapping, sequence, callable, or CustomTemplate

Chunk taking specification.

Can be a dictionary (see Chunker.take_from_args), or a sequence that will be converted into a dictionary. If a callable, will be called instead of Chunker.take_from_args, thus it must have the same arguments apart from arg_take_spec.

template_context : mapping
Context used to substitute templates in arguments and specification.
**kwargs
Keyword arguments passed to Chunker.take_from_args or to arg_take_spec if it's a callable.

merge_func class property

Merging function.

Resolved using resolve_merge_func.

merge_kwargs class property

Keyword arguments passed to the merging function.

min_size class property

See Chunker.get_chunk_meta_from_args.

n_chunks class property

See Chunker.get_chunk_meta_from_args.

parse_sizer_from_func class method

Chunker.parse_sizer_from_func(
    func,
    eval_id=None
)

Parse the sizer from a function.

parse_spec_from_annotations class method

Chunker.parse_spec_from_annotations(
    annotations,
    eval_id=None
)

Parse the chunk taking specification from annotations.

parse_spec_from_args class method

Chunker.parse_spec_from_args(
    ann_args,
    eval_id=None
)

Parse the chunk taking specification from (annotated) arguments.

parse_spec_from_func class method

Chunker.parse_spec_from_func(
    func,
    eval_id=None
)

Parse the chunk taking specification from a function.

prepend_chunk_meta class property

Whether to prepend an instance of ChunkMeta to the arguments.

If None, prepends automatically if the first argument is named 'chunk_meta'.

resolve_take_spec class method

Chunker.resolve_take_spec(
    take_spec
)

Resolve the chunk taking specification.

return_raw_chunks class property

Whether to return chunks in a raw format.

run method

Chunker.run(
    func,
    *args,
    eval_id=None,
    **kwargs
)

Chunk arguments and run the function.

silence_warnings class property

Whether to silence any warnings.

size class property

See Chunker.get_chunk_meta_from_args.

skip_single_chunk class property

Whether to execute the function directly if there's only one chunk.

suggest_size class method

Chunker.suggest_size(
    ann_args,
    arg_take_spec,
    eval_id=None,
    **kwargs
)

Suggest a global size given the annotated arguments and the chunk taking specification.

take_from_arg class method

Chunker.take_from_arg(
    arg,
    take_spec,
    chunk_meta,
    eval_id=None,
    **kwargs
)

Take from the argument given the specification take_spec.

If take_spec is None or it's an instance of NotChunked, returns the original object. Otherwise, must be an instance of ChunkTaker.

**kwargs are passed to ChunkTaker.apply.

take_from_args class method

Chunker.take_from_args(
    ann_args,
    arg_take_spec,
    chunk_meta,
    silence_warnings=False,
    eval_id=None,
    **kwargs
)

Take from each in the annotated arguments given the specification using Chunker.take_from_arg.

Additionally, passes to Chunker.take_from_arg as keyword arguments ann_args and arg_take_spec.

arg_take_spec must be a dictionary, with keys being argument positions or names as generated by annotate_args. For values, see Chunker.take_from_arg.

Returns arguments and keyword arguments that can be directly passed to the function using func(*args, **kwargs).

template_context class property

Template context.

Any template in both execute_kwargs and merge_kwargs will be substituted. You can use the keys ann_args, chunk_meta, arg_take_spec, and tasks to be replaced by the actual objects.

ContainerTaker class

ContainerTaker(
    cont_take_spec=None,
    single_type=None,
    ignore_none=True,
    mapper=None
)

Class for taking from a container with other chunk takers.

Accepts the specification of the container.

Superclasses

Inherited members

Subclasses

check_cont_take_spec method

ContainerTaker.check_cont_take_spec()

Check that ContainerTaker.cont_take_spec is not None.

cont_take_spec field

Specification of the container.

CountAdapter class

CountAdapter(
    *args,
    **kwargs
)

Class for adapting a count based on the chunk range.

Superclasses

Inherited members

CountSizer class

CountSizer(
    *args,
    **kwargs
)

Class for getting the size from a count.

Superclasses

Inherited members

get_obj_size class method

CountSizer.get_obj_size(
    obj,
    single_type=None
)

Get size of an object.

DimRetainer class

DimRetainer(
    *args,
    **kwargs
)

Class with an attribute for retaining dimensions.

Superclasses

Inherited members

Subclasses

keep_dims field

Whether to retain dimensions.

KwargsTaker class

KwargsTaker(
    single_type=None,
    ignore_none=True,
    mapper=None,
    **kwargs
)

Class for taking from a variable keyword arguments container.

Superclasses

Inherited members

LenChunkMeta class

LenChunkMeta(
    *args,
    **kwargs
)

Class for generating chunk metadata from a sequence of chunk lengths.

Superclasses

Inherited members

LenSizer class

LenSizer(
    *args,
    **kwargs
)

Class for getting the size from the length of an argument.

Superclasses

Inherited members

get_obj_size class method

LenSizer.get_obj_size(
    obj,
    single_type=None
)

Get size of an object.

MappingTaker class

MappingTaker(
    cont_take_spec=None,
    single_type=None,
    ignore_none=True,
    mapper=None
)

Class for taking from a mapping container.

Calls Chunker.take_from_arg on each element.

Superclasses

Inherited members

Subclasses

adapt_cont_take_spec method

MappingTaker.adapt_cont_take_spec(
    obj
)

Prepare the specification of the container to the object.

NotChunked class

NotChunked(
    *args,
    **kwargs
)

Class that represents an argument that shouldn't be chunked.

Superclasses

Inherited members

eval_id field

One or more identifiers at which to evaluate this instance.

SequenceTaker class

SequenceTaker(
    cont_take_spec=None,
    single_type=None,
    ignore_none=True,
    mapper=None
)

Class for taking from a sequence container.

Calls Chunker.take_from_arg on each element.

Superclasses

Inherited members

Subclasses

adapt_cont_take_spec method

SequenceTaker.adapt_cont_take_spec(
    obj
)

Prepare the specification of the container to the object.

ShapeSelector class

ShapeSelector(
    *args,
    **kwargs
)

Class for selecting one element from a shape's axis based on the chunk index.

Superclasses

Inherited members

Subclasses

ShapeSizer class

ShapeSizer(
    *args,
    **kwargs
)

Class for getting the size from the length of an axis in a shape.

Superclasses

Inherited members

Subclasses

get_obj_size class method

ShapeSizer.get_obj_size(
    obj,
    axis,
    single_type=None
)

Get size of an object.

ShapeSlicer class

ShapeSlicer(
    *args,
    **kwargs
)

Class for slicing multiple elements from a shape's axis based on the chunk range.

Superclasses

Inherited members

Subclasses

Sizer class

Sizer()

Abstract class for getting the size from annotated arguments.

Note

Use Sizer.apply instead of Sizer.get_size.

Superclasses

Inherited members

Subclasses

apply method

Sizer.apply(
    ann_args,
    **kwargs
)

Apply the sizer.

eval_id field

One or more identifiers at which to evaluate this instance.

get_size method

Sizer.get_size(
    ann_args,
    **kwargs
)

Get the size given the annotated arguments.