code: def clone(
      *collections,
      omit=None,
      seed: Hashable = None,
      assume_layers: bool = True,
  ):
      """Clone dask collections, returning equivalent collections that are generated from
      independent calculations.
  
      Examples
      --------
      (tokens have been simplified for the sake of brevity)
  
      >>> import dask.array as da
      >>> x_i = da.asarray([1, 1, 1, 1], chunks=2)
      >>> y_i = x_i + 1
      >>> z_i = y_i + 2
      >>> dict(z_i.dask)  # doctest: +SKIP
      {('array-1', 0): array([1, 1]),
       ('array-1', 1): array([1, 1]),
       ('add-2', 0): (<function operator.add>, ('array-1', 0), 1),
       ('add-2', 1): (<function operator.add>, ('array-1', 1), 1),
       ('add-3', 0): (<function operator.add>, ('add-2', 0), 1),
       ('add-3', 1): (<function operator.add>, ('add-2', 1), 1)}
      >>> w_i = clone(z_i, omit=x_i)
      >>> w_i.compute()
      array([4, 4, 4, 4])
      >>> dict(w_i.dask)  # doctest: +SKIP
      {('array-1', 0): array([1, 1]),
       ('array-1', 1): array([1, 1]),
       ('add-4', 0): (<function operator.add>, ('array-1', 0), 1),
       ('add-4', 1): (<function operator.add>, ('array-1', 1), 1),
       ('add-5', 0): (<function operator.add>, ('add-4', 0), 1),
       ('add-5', 1): (<function operator.add>, ('add-4', 1), 1)}
  
      The typical usage pattern for clone() is the following:
  
      >>> x = cheap_computation_with_large_output()  # doctest: +SKIP
      >>> y = expensive_and_long_computation(x)  # doctest: +SKIP
      >>> z = wrap_up(clone(x), y)  # doctest: +SKIP
  
      In the above code, the chunks of x will be forgotten as soon as they are consumed by
      the chunks of y, and then they'll be regenerated from scratch at the very end of the
      computation. Without clone(), x would only be computed once and then kept in memory
      throughout the whole computation of y, needlessly consuming memory.
  
      Parameters
      ----------
      collections
          Zero or more Dask collections or nested structures of Dask collections
      omit
          Dask collection or nested structure of Dask collections which will not be cloned
      seed
          See :func:`bind`
      assume_layers
          See :func:`bind`
  
      Returns
      -------
      Same as ``collections``
          Dask collections of the same type as the inputs, which compute to the same
          value, or nested structures equivalent to the inputs, where the original
          collections have been replaced.
          The keys of the regenerated nodes in the new collections will be different from
          the original ones, so that they can be used within the same graph.
      """
      out = bind(
          collections,
          parents=None,
          omit=omit,
          seed=seed,
          assume_layers=assume_layers,
      )
      return out[0] if len(collections) == 1 else out
  
imports: from __future__ import annotations
  import uuid
  from collections.abc import Callable, Hashable
  from typing import Literal, TypeVar
  from dask.base import clone_key, get_collection_names, get_name_from_key, replace_name_in_key, tokenize, unpack_collections
  from dask.blockwise import blockwise
  from dask.core import flatten
  from dask.delayed import Delayed, delayed
  from dask.highlevelgraph import HighLevelGraph, Layer, MaterializedLayer
  from dask.typing import Graph, Key
label_desc: Use image node_id 7 for calling a global function with example usage: clone() and returns: unknown