Function _optimize_slices

dask/array/optimization.py:94–187

Optimize slices 1. Fuse repeated slices, like x[5:][2:6] -> x[7:11] This is generally not very important since we are fusing those tasks anyway. There is one specific exception to how xarray implements opening netcdf files and subsequent slices. Not merging them together can cause

(dsk)

def _optimize_slices(dsk):
    """Optimize slices
    1.  Fuse repeated slices, like x[5:][2:6] -> x[7:11]

    This is generally not very important since we are fusing those tasks anyway. There
    is one specific exception to how xarray implements opening netcdf files and subsequent
    slices. Not merging them together can cause reading the whole netcdf file before
    we drop the unnecessary data. Fusing slices avoids that pattern.

    See https://github.com/pydata/xarray/issues/9926
    """
    fancy_ind_types = (list, np.ndarray)
    dsk = dsk.copy()
    for _, v in dsk.items():
        if not (isinstance(v, Task) and v.func is _execute_subgraph):
            continue

        inner_graph: dict = v.args[0]  # type: ignore[annotation-unchecked]

        seen = set()

        for inner_key, inner_value in inner_graph.items():
            if inner_key in seen:
                continue
            else:
                seen.add(inner_key)

            if a_task := _is_getter_task(inner_value):
                temp_key = inner_key
                get, a, a_index, a_asarray, a_lock = a_task
                fused = False

                while a.key in inner_graph and (
                    b_task := _is_getter_task(inner_graph[a.key])
                ):
                    seen.add(a.key)
                    f2, b, b_index, b_asarray, b_lock = b_task

                    if isinstance(a_index, DataNode):
                        a_index = a_index.value
                    if isinstance(b_index, DataNode):
                        b_index = b_index.value

                    if a_lock and a_lock is not b_lock:
                        break
                    if (type(a_index) is tuple) != (type(b_index) is tuple):
                        break
                    if type(a_index) is tuple:
                        indices = b_index + a_index
                        if len(a_index) != len(b_index) and any(
                            i is None for i in indices
                        ):
                            break
                        if f2 is getter_nofancy and not any(
                            isinstance(i, fancy_ind_types) for i in indices
                        ):
                            break
                    elif f2 is getter_nofancy and (