>>> digit(1234, 0, 10) 4 >>> digit(1234, 1, 10) 3 >>> digit(1234, 2, 10) 2 >>> digit(1234, 3, 10) 1

Return the desired backend entrypoint

Wrap a simple property.

Distinct elements of collection Unordered without repeats. Parameters ---------- key: {callable,str} Def

Minimally divide the given chunks so as to make the largest chunk width less or equal than *max_width*.

* Dump a JS config object to a set of dot notation Python examples. * * @param {string} config - Config object * @return {string} Python dot notati

* Dump a JS config object to a set of environment variable declarations. * * @param {string} config - Config object * @return {string} environment

* Dump a JS config object to a YAML string. * * @param {string} config - Config object * @return {str} YAML configuration

Elementwise operation for Dask dataframes Parameters ---------- op: callable Function to apply across input dataframes *args:

Return a new array with the same shape and type as a given array. Parameters ---------- a : array_like The shape and data-ty

Ensure a partd.File is cleaned up. We have several tasks referring to a `partd.File` instance. We want to ensure that the file is cleaned up

Determine new chunks to ensure that every chunk >= size Parameters ---------- size: int The maximum size of any chunk. chunks

Ensure that an attribute added to 'obj' during the test is removed when we're done

Estimate the graph size during a rechunk computation.

>>> expand_tuple((2, 4), 2) (1, 1, 2, 2) >>> expand_tuple((2, 4), 3) (1, 1, 1, 1, 2) >>> expand_tuple((3, 4), 2) (1, 2, 2,

Extract filesystem object from urlpath or user arguments This classmethod should only be overridden for engines that need to handle f

Update execution state after a task finishes Mutates. This should run atomically (with a lock).

Combined reduction and groupby. Foldby provides a combined groupby and reduce for efficient parallel split-apply-combine tasks.

format integers as time >>> from dask.utils import format_time >>> format_time(1) '1.00 s' >>> format_time(0.001234) '1.23 ms'

>>> fractional_slice(('x', 5.1), {0: 2}) (<built-in function getitem>, ('x', 5), (slice(-2, None, None),)) >>> fractional_slice(('x', 3

Set of functions contained within nested task Examples -------- >>> inc = lambda x: x + 1 >>> add = lambda x, y: x + y >>> mul =

Get dependencies of all keys This will in most cases materialize all layers, which makes it an expensive operation. Returns

Get dependencies of `key` in the layer Parameters ---------- key: The key to find dependencies of all_hlg

Get all non ``*args/**kwargs`` arguments for a function

Return a set of all output keys Output keys are all keys in the layer that might be referenced by other layers. Classes over

Hash a bytes-like (buffer-compatible) object. This function returns a good quality hash but is not cryptographically secure. The fastest

Get the layer from a HighLevelGraph at position ``i``, topologically

>>> insert(('a', 'b', 'c'), 0, 'x') ('x', 'b', 'c')

Return whether the layer is materialized or not

Check if given array is of a valid type to operate with

Check if given type is a valid chunk and downcast array type

Handle special cases where conversion to bool does not work correctly. xref: https://github.com/numpy/numpy/issues/9479

A generator that lazily finds matchings for term from the RuleSet. Parameters ---------- term : task Yields

Remove unnecessary calls to ``list`` in tasks. See Also -------- dask.bag.core.lazify_task

Given a task, remove unnecessary calls to ``list`` and ``reify``. This traverses tasks and small lists. We choose not to traverse down list

A function inserted in a Dask graph for storing a chunk. Parameters ---------- x: array-like An array (potentially a NumPy o

List of list of tuple keys Parameters ---------- head : tuple The known tuple so far ind : Iterable An iterable of in

Generate blockwise-sorted index pairs for shuffling an array. Parameters ---------- index : ndarray An array of index positions.

Map a function over blocks of arrays with some overlap We share neighboring zones between blocks of the array, map a function, and then trim

Map a function over blocks of arrays with some overlap We share neighboring zones between blocks of the array, map a function, and then trim

Map a function over blocks of the array with some overlap Refer to :func:`dask.array.map_overlap` for full documentation. See Also

* Deep merge a set of objects * * @param {list} objects - Objects to be merged (wrapped arguments) * @return {object} Merged object * * @example

Minimally merge the given chunks so as to drop the number of chunks below *max_number*, while minimizing the largest width.

Calculate the nth centralized moment. Refer to :func:`dask.array.moment` for the full documentation. See Also --------

Number of True index elements preceding position loc0. The index is the input assignment index that is defined in the namespace of th

Number of total data elements on which this key depends For each key we return the number of tasks that must be run for us to run this task.