code: def vjp(f, params, cotangents, method=None, h=None, argnum=None):
      """A :func:`~.qjit` compatible Vector-Jacobian product of PennyLane programs.
  
      This function allows the Vector-Jacobian Product of a hybrid quantum-classical function to be
      computed within the compiled program.
  
      .. warning::
  
          ``vjp`` is intended to be used with :func:`~.qjit` only.
  
      .. note::
  
          When used with :func:`~.qjit`, this function only supports the Catalyst compiler.
          See :func:`catalyst.vjp` for more details.
  
          Please see the Catalyst :doc:`quickstart guide <catalyst:dev/quick_start>`,
          as well as the :doc:`sharp bits and debugging tips <catalyst:dev/sharp_bits>`
          page for an overview of the differences between Catalyst and PennyLane.
  
      Args:
          f(Callable): Function-like object to calculate VJP for
          params(List[Array]): List (or a tuple) of arguments for `f` specifying the point to calculate
                               VJP at. A subset of these parameters are declared as
                               differentiable by listing their indices in the ``argnum`` parameter.
          cotangents(List[Array]): List (or a tuple) of tangent values to use in VJP. The list size
                                   and shapes must match the size and shape of ``f`` outputs.
          method(str): Differentiation method to use, same as in :func:`~.grad`.
          h (float): the step-size value for the finite-difference (``"fd"``) method
          argnum (Union[int, List[int]]): the params' indices to differentiate.
  
      Returns:
          Tuple[Array]: Return values of ``f`` paired with the VJP values.
  
      Raises:
          TypeError: invalid parameter types
          ValueError: invalid parameter values
  
      .. seealso:: :func:`~.grad`, :func:`~.jvp`, :func:`~.jacobian`
  
      **Example**
  
      .. code-block:: python
  
          @qml.qjit
          def vjp(params, cotangent):
            def f(x):
                y = [jnp.sin(x[0]), x[1] ** 2, x[0] * x[1]]
                return jnp.stack(y)
  
            return qml.vjp(f, [params], [cotangent])
  
      >>> x = jnp.array([0.1, 0.2])
      >>> dy = jnp.array([-0.5, 0.1, 0.3])
      >>> vjp(x, dy)
      [array([0.09983342, 0.04      , 0.02      ]),
      array([-0.43750208,  0.07000001])]
      """
      if active_jit := compiler.active_compiler():
          available_eps = compiler.AvailableCompilers.names_entrypoints
          ops_loader = available_eps[active_jit]["ops"].load()
          return ops_loader.vjp(
              f, params, cotangents, method=method, h=h, argnum=argnum
          )
  
      raise CompileError(
          "Pennylane does not support the VJP function without QJIT."
      )
  
file_path: pennylane/pennylane/_grad.py
imports: import warnings
  from autograd import jacobian
  from autograd.core import make_vjp
  from autograd.numpy.numpy_boxes import ArrayBox
  from autograd.extend import vspace
  from autograd.wrap_util import unary_to_nary
  from pennylane.compiler import compiler
  from pennylane.compiler.compiler import CompileError
label_desc: Use image node_id 2 for calling a global function with example usage: vjp(f, params, cotangents, method, h, argnum) and returns: ops_loader