code: def _build_callables(operation, op_wires=None, op_gen=None):
      r"""Instantiates objects for whichever of the ``operation`` or ``op_gen`` args are callables. For the former,
      it is done using an arbitrary choice of variational arguments to be 1.0 and the specified wires. Whereas for the latter, it
      is done only with the specified wires.
  
      Args:
          operation (Operation or Callable): qubit operation to be tapered, or a function that applies that operation
          op_wires (Sequence[Any]): wires for the operation in case any of the provided `operation` or `op_gen` are callables
          op_gen (Hamiltonian or Callable): generator of the operation, or a function that returns it in case it cannot be computed internally.
  
      Returns:
          Tuple(Operation, Hamiltonian)
  
      Raises:
          ValueError: optional argument `op_wires` is not provided when the provided ``operation`` or ``gen_op`` is a callable
          TypeError: optional argument `op_gen` is a callable but does not have 'wires' as its only keyword argument
  
      **Example**
  
      >>> gen_fn = lambda wires: qml.Hamiltonian(
      ...        [0.25, -0.25],
      ...        [qml.PauliX(wires=wires[0]) @ qml.PauliY(wires=wires[1]),
      ...         qml.PauliY(wires=wires[0]) @ qml.PauliX(wires=wires[1])])
      >>> _build_callables(qml.SingleExcitation, op_wires=[0, 2], op_gen=gen_fn)
      (SingleExcitation(1.0, wires=[0, 2]),
      <Hamiltonian: terms=2, wires=[0, 2]>)
      """
  
      if callable(operation) or callable(op_gen):
          if op_wires is None:
              raise ValueError(
                  f"Wires for the operation must be provided with 'op_wires' args if either of 'operation' or 'op_gen' is a callable, got {op_wires}."
              )
  
      if callable(operation):
          operation = operation(
              *([1.0] * operation.num_params), wires=op_wires
          )
  
      if callable(op_gen):
          try:
              op_gen = op_gen(wires=op_wires)
          except TypeError as exc:
              raise TypeError(
                  "Generator function provided with 'op_gen' should have 'wires' as its only required keyword argument."
              ) from exc
  
      return operation, op_gen
  
imports: import functools
  import itertools
  import numpy
  import scipy
  import pennylane
  from pennylane.operation import active_new_opmath
  from pennylane.pauli import PauliSentence, PauliWord, pauli_sentence, simplify
  from pennylane.pauli.utils import _binary_matrix_from_pws
  from pennylane.wires import Wires
label_desc: Use image node_id 11 for calling a global function with example usage: _build_callables(operation, op_wires, op_gen) and returns: operation,  op_gen