Method _construct_graph

dask/layers.py:202–253

Construct graph for a simple overlap operation.

(self, deserializing=False)

        return result

    def _construct_graph(self, deserializing=False):
        """Construct graph for a simple overlap operation."""
        axes = self.axes
        chunks = self.chunks
        name = self.name
        dask_keys = self._dask_keys()

        getitem_name = f"getitem-{self.token}"
        overlap_name = f"overlap-{self.token}"

        if deserializing:
            # Use CallableLazyImport objects to avoid importing dataframe
            # module on the scheduler
            concatenate_shaped = CallableLazyImport(
                "dask.array.core.concatenate_shaped"
            )
        else:
            # Not running on distributed scheduler - Use explicit functions
            from dask.array.core import concatenate_shaped

        dims = list(map(len, chunks))
        expand_key2 = functools.partial(
            _expand_keys_around_center, dims=dims, axes=axes
        )

        # Make keys for each of the surrounding sub-arrays
        interior_keys = toolz.pipe(
            dask_keys,
            flatten,
            map(expand_key2),
            map(lambda a: a[0]),
            map(flatten),
            toolz.concat,
            list,
        )
        interior_slices = {}
        overlap_blocks = {}
        for k in interior_keys:
            frac_slice = fractional_slice((name,) + k, axes)
            if frac_slice is False:
                continue
            if (name,) + k != frac_slice:
                interior_slices[(getitem_name,) + k] = frac_slice
            else:
                interior_slices[(getitem_name,) + k] = (name,) + k
                overlap_blocks[(overlap_name,) + k] = (
                    concatenate_shaped,
                    *(expand_key2((None,) + k, name=getitem_name)),
                )

        dsk = toolz.merge(interior_slices, overlap_blocks)
        return dsk


def _expand_keys_around_center(k, dims, name=None, axes=None):