code: def Compose(
      op_list: List[
          Callable[..., Union[Sequence[_DataNode], _DataNode]]
      ]
  ) -> _CompoundOp:
      """Returns a meta-operator that chains the operations in op_list.
  
      The return value is a callable object which, when called, performs::
  
          op_list[n-1](op_list([n-2](...  op_list[0](args))))
  
      Operators can be composed only when all outputs of the previous operator can be processed
      directly by the next operator in the list.
  
      The example below chains an image decoder and a Resize operation with random square size.
      The  ``decode_and_resize`` object can be called as if it was an operator::
  
          decode_and_resize = ops.Compose([
              ops.decoders.Image(device="cpu"),
              ops.Resize(size=fn.random.uniform(range=400,500)), device="gpu")
          ])
  
          files, labels = fn.readers.caffe(path=caffe_db_folder, seed=1)
          pipe.set_outputs(decode_and_resize(files), labels)
  
      If there's a transition from CPU to GPU in the middle of the ``op_list``, as is the case in this
      example, ``Compose`` automatically arranges copying the data to GPU memory.
  
  
      .. note::
          This is an experimental feature, subject to change without notice.
      """
      return op_list[0] if len(op_list) == 1 else _CompoundOp(op_list)
  
imports: from typing import List, Sequence, Union, Callable
  from nvidia.dali.data_node import DataNode
label_desc: Use image node_id 1 for calling a global function with example usage: Compose(op_list) and returns: unknown