HighLevelGraph for slicing chunks from an array-like according to a chunk pattern. If ``inline_array`` is True, this make a Blockwise layer

Handle out parameters If out is a dask.array then this overwrites the contents of that array with the result

Make dask.array slices as intersection of old and new chunks. >>> intersections = intersect_chunks(((4, 4), (2,)), ...

Duck-typed check for “emptiness” of an object. Works for standard sequences (lists, tuples, etc.), NumPy arrays, and sparse-like objects

Get all keys of all the layers. This will in many cases materialize layers, which makes it a relatively expensive operation. See :met

Returns the average of the array elements along given axis. Refer to :func:`dask.array.mean` for full documentation. See Also

Persist multiple Dask collections into memory This turns lazy Dask collections into Dask collections with the same metadata, but now with the

Return a list of arrays that can initialize ``np.random.RandomState``. Parameters ---------- n : int Number of arrays to retu

Reorders one dimensions of a Dask Array based on an indexer. The indexer defines a list of positional groups that will end up in the same ch

slice_with_newaxis : handle None/newaxis case slice_wrap_lists : handle fancy indexing with lists slice_slices_and_integers : handle ever

Perform a substitution on a task Examples -------- >>> def inc(x): ... return x + 1 >>> subs((inc, 'x'), 'x', 1) # doctest:

Reverse or permute the axes of an array. Return the modified array. Refer to :func:`dask.array.transpose` for full documentation. Se

Return a Blockwise-task argument

Helper function for finding shapes and chunks for *_like() array creation functions.

Utility function to raise an error if an object column does not support a certain operation like `mean`.

Are all elements truthy? Examples -------- >>> import dask.bag as db >>> bool_bag = db.from_sequence([True, True, Fal

Tries to infer output dtype of ``func`` for a small set of input arguments. Parameters ---------- func: Callable Function fo

Return evenly spaced values from `start` to `stop` with step size `step`. The values are half-open [start, stop), so including start and exc

If `a` is `dask.array`, return `dask.array.asarray(a, **kwargs)`, otherwise return `np.asarray(a, like=like, **kwargs)`, dispatching the

Ensure the categories in this series are unknown

Recursive np.concatenate Input should be a nested list of numpy arrays arranged in the order they should appear in the array itself. Each ar

Filter elements in collection by a predicate function. >>> def iseven(x): ... return x % 2 == 0 >>> import dask.bag as d

Construct a Dask DataFrame from a Python Dictionary Parameters ---------- data : dict Of the form {field : array-like} or {f

Allow function to be taken over by globals This modifies a method so that occurrences of it may be taken over by functions registered in the

Arithmetic mean

Return a serial Series constructor Parameters ---------- like : Any series-like, Index-like or dataframe-like object.

Return the indices of the elements that are non-zero. Refer to :func:`dask.array.nonzero` for full documentation. See Also -

Remove axes of length one from array. Refer to :func:`dask.array.squeeze` for full documentation. See Also --------

Returns the standard deviation of the array elements along given axis. Refer to :func:`dask.array.std` for full documentation. See A

Return type depends on input. Delayed if scalar, otherwise same as input. For errors, only "raise" and "coerce" are allowed.

Extract collections in preparation for compute/persist/etc... Intended use is to find all collections in a set of (possibly nested) python ob

Update a nested dictionary with values from another This is like dict.update except that it smoothly merges nested values This operates in-p

Generate a random dataset according to provided spec Parameters ---------- spec : DatasetSpec Specify all the parameters of the d

Determine for every node which root nodes are connected to it (i.e. ancestors). If arguments of dependencies and dependents are switched, this

Groupby, but raise if df and `by` key are unaligned. Pandas supports grouping by a column that doesn't align with the input frame/series/inde

Returns True if all elements evaluate to True. Refer to :func:`dask.array.all` for full documentation. See Also --------

Return indices of the minimum values along the given axis. Refer to :func:`dask.array.argmin` for full documentation. See Also

Determines output shape from broadcasting arrays. Parameters ---------- shapes : tuples The shapes of the arguments. Re

Clone a key from a Dask collection, producing a new key with the same prefix and indices and a token which is a deterministic function of the prev

Concatenate, handling some edge cases: - Unions categoricals between partitions - Ignores empty partitions Parameters ----------

Create a Dask DataFrame from a Dask Array. Converts a 2d array into a DataFrame and a 1d array into a Series. Parameters ----------

Get the parquet engine backend implementation. Parameters ---------- engine : {'auto', 'pyarrow'} or Engine subclass Parquet libr

Inline cheap functions into larger operations Examples -------- >>> inc = lambda x: x + 1 >>> add = lambda x, y: x + y >>> double

Update a sequence of nested dictionaries This prefers the values in the latter dictionaries to those in the former Examples --------

Return a serial DataFrame constructor Parameters ---------- like : Any series-like, Index-like or dataframe-like object.

Minimum element

Helper to build old_chunks to new_chunks. Handles missing values, as long as the dimension with the missing chunk values is unchanged. N

Share boundaries between neighboring blocks Parameters ---------- x: da.Array A dask array depth: dict The size of t

Convert a block of bytes to a Pandas DataFrame Parameters ---------- reader : callable ``pd.read_csv`` or ``pd.read_table``.

Select item from all tuples/dicts in collection. >>> import dask.bag as db >>> b = db.from_sequence([{'name': 'Alice', 'credits': [1,

Read ORC files into a DataFrame collection Parameters ---------- path : str or list Source path(s). **kwa

Return array with each element rounded to the given number of decimals. Refer to :func:`dask.array.round` for full documentation. Se

Stack arrays along a new axis Given a sequence of dask arrays, form a new dask array by stacking them along a new dimension (axis=0 by d

Start state from a dask Examples -------- >>> inc = lambda x: x + 1 >>> add = lambda x, y: x + y >>> dsk = {'x': 1, 'y': 2, 'z':

Substitute specific `Expr` parameters Parameters ---------- substitutions: Mapping of parameter keys to new value

Parallel version of pandas GroupBy.transform This mimics the pandas version except for the following: 1. If the grouper does not al