class_docstr: Class that contains a transform program and the methods to interact with it.
  
  The order of execution is the order in the list containing the containers.
  
  The main case where one would have to interact directly with a transform program is when developing a
  :class:`Device <pennylane.devices.Device>`. In this case, the pre-processing method of a device
  returns a transform program. You should directly refer to the device API documentation for more details.
  
  .. warning::
  
      This class is developer-facing and should not be used directly. Instead, use
      :func:`qml.transform <pennylane.transform>` if you would like to make a custom
      transform.
  
  .. seealso:: :func:`~.pennylane.transform`
class_docstr_tok: ["Class","that","contains","a","transform","program","and","the","methods","to","interact","with","it",".","The","order","of","execution","is","the","order","in","the","list","containing","the","containers",".","The","main","case","where","one","would","have","to","interact","directly","with","a","transform","program","is","when","developing","a",":","class",":","`","Device","<","pennylane.devices.Device",">","`",".","In","this","case",",","the","pre-processing","method","of","a","device","returns","a","transform","program",".","You","should","directly","refer","to","the","device","API","documentation","for","more","details",".","..","warning",":",":","This","class","is","developer-facing","and","should","not","be","used","directly",".","Instead",",","use",":","func",":","`","qml.transform","<","pennylane.transform",">","`","if","you","would","like","to","make","a","custom","transform",".","..","seealso",":",":",":","func",":","`","~.pennylane.transform","`"]
code: def __call__(
      self, tapes: Tuple[QuantumTape]
  ) -> Tuple[ResultBatch, BatchPostProcessingFn]:
      if not self:
          return tapes, null_postprocessing
  
      processing_fns_stack = []
  
      for i, transform_container in enumerate(self):
          (
              transform,
              targs,
              tkwargs,
              cotransform,
              _,
              _,
          ) = transform_container
  
          execution_tapes = []
          fns = []
          slices = []
  
          classical_fns = []
          slices_classical = []
  
          start = 0
          start_classical = 0
          for j, tape in enumerate(tapes):
              if (
                  self._argnums is not None
                  and self._argnums[i] is not None
              ):
                  tape.trainable_params = self._argnums[i][j]
              new_tapes, fn = transform(tape, *targs, **tkwargs)
              execution_tapes.extend(new_tapes)
  
              fns.append(fn)
              end = start + len(new_tapes)
              slices.append(slice(start, end))
              start = end
  
              if cotransform and self._classical_jacobians:
                  classical_fns.append(
                      partial(
                          cotransform,
                          cjac=self._classical_jacobians[i][j],
                          tape=tape,
                      )
                  )
                  slices_classical.append(
                      slice(start_classical, start_classical + 1)
                  )
                  start_classical += 1
  
          if cotransform and self._classical_jacobians:
              batch_postprocessing_classical = partial(
                  _batch_postprocessing,
                  individual_fns=classical_fns,
                  slices=slices_classical,
              )
              batch_postprocessing_classical.__doc__ = (
                  _batch_postprocessing.__doc__
              )
              processing_fns_stack.append(
                  batch_postprocessing_classical
              )
  
          batch_postprocessing = partial(
              _batch_postprocessing, individual_fns=fns, slices=slices
          )
          batch_postprocessing.__doc__ = _batch_postprocessing.__doc__
          processing_fns_stack.append(batch_postprocessing)
  
          # set input tapes for next iteration.
          tapes = execution_tapes
  
      postprocessing_fn = partial(
          _apply_postprocessing_stack,
          postprocessing_stack=processing_fns_stack,
      )
  
      postprocessing_fn.__doc__ = _apply_postprocessing_stack.__doc__
  
      # Reset classical jacobians
      self._classical_jacobians = []
      return tuple(tapes), postprocessing_fn
  
imports: from functools import partial
  from typing import Callable, List, Tuple, Optional, Sequence
  import pennylane
  from pennylane.typing import Result, ResultBatch
  from pennylane.tape import QuantumTape
  from .transform_dispatcher import TransformContainer, TransformError, TransformDispatcher
label_desc: Use image node_id 21 for calling the TransformProgram obj's underlying member method code with example usage: obj.__call__(tapes) and returns: tuple,  postprocessing_fn, tapes,  null_postprocessing