human
Complete the below
def apply_parallel(function, array, chunks=None, depth=0, mode=None, extra_arguments=(), extra_keywords={}):

    ''''Map a function in parallel across an array.
    Split an array into possibly overlapping chunks of a given depth and
    boundary type, call the given function in parallel on the chunks, combine
    the chunks and return the resulting array.
    Parameters
    function : function
    Function to be mapped which takes an array as an argument.
    array : numpy array
    Array which the function will be applied to.
    chunks : int, tuple, or tuple of tuples, optional
    A single integer is interpreted as the length of one side of a square
    chunk that should be tiled across the array.  One tuple of length
    ``array.ndim`` represents the shape of a chunk, and it is tiled across
    the array.  A list of tuples of length ``ndim``, where each sub-tuple
    is a sequence of chunk sizes along the corresponding dimension. If
    None, the array is broken up into chunks based on the number of
    available cpus. More information about chunks is in the documentation
    `here <https://dask.pydata.org/en/latest/array-design.html>`_.
    depth : int, optional
    Integer equal to the depth of the added boundary cells. Defaults to
    zero.
    mode : {\'reflect\', \'symmetric\', \'periodic\', \'wrap\', \'nearest\', \'edge\'}, optional
    type of external boundary padding.
    extra_arguments : tuple, optional
    Tuple of arguments to be passed to the function.
    extra_keywords : dictionary, optional
    Dictionary of keyword arguments to be passed to the function.
    Notes
    Numpy edge modes \'symmetric\', \'wrap\', and \'edge\' are converted to the
    equivalent `dask` boundary modes \'reflect\', \'periodic\' and \'nearest\',
    respectively.'
    '''
assistant
#Here is the Python program you requested.
    if (not dask_available):
        raise RuntimeError("Could    not    import    'dask'.        Please    install    using    'pip    install    dask'")
    if (chunks is None):
        shape = array.shape
        try:
            ncpu = cpu_count()
        except NotImplementedError:
            ncpu = 4
        chunks = _get_chunks(shape, ncpu)
    if (mode == 'wrap'):
        mode = 'periodic'
    elif (mode == 'symmetric'):
        mode = 'reflect'
    elif (mode == 'edge'):
        mode = 'nearest'
    def wrapped_func(arr):
        return function(arr, *extra_arguments, **extra_keywords)
    darr = da.from_array(array, chunks=chunks)
    return darr.map_overlap(wrapped_func, depth, boundary=mode).compute()