code: def call_function(
      func, func_token, args, kwargs, pure=None, nout=None
  ):
      dask_key_name = kwargs.pop("dask_key_name", None)
      pure = kwargs.pop("pure", pure)
  
      if dask_key_name is None:
          name = "{}-{}".format(
              funcname(func),
              tokenize(func_token, *args, pure=pure, **kwargs),
          )
      else:
          name = dask_key_name
  
      args2, collections = unzip(map(unpack_collections, args), 2)
      collections = list(concat(collections))
  
      if kwargs:
          dask_kwargs, collections2 = unpack_collections(kwargs)
          collections.extend(collections2)
          task = (apply, func, list(args2), dask_kwargs)
      else:
          task = (func,) + args2
  
      graph = HighLevelGraph.from_collections(
          name, {name: task}, dependencies=collections
      )
      nout = nout if nout is not None else None
      return Delayed(name, graph, length=nout)
  
imports: from __future__ import annotations
  import operator
  import types
  import uuid
  import warnings
  from collections.abc import Sequence
  from dataclasses import fields, is_dataclass, replace
  from functools import partial
  from tlz import concat, curry, merge, unique
  from dask import config
  from dask.base import DaskMethodsMixin, dont_optimize, is_dask_collection, named_schedulers, replace_name_in_key
  from dask.base import tokenize
  from dask.context import globalmethod
  from dask.core import flatten, quote
  from dask.highlevelgraph import HighLevelGraph
  from dask.typing import Graph, NestedKeys
  from dask.utils import OperatorMethodMixin, apply, funcname, is_namedtuple_instance, methodcaller
label_desc: Use image node_id 10 for calling a global function with example usage: call_function(func, func_token, args, kwargs, pure, nout) and returns: Delayed