code: def dblquad(
      func, a, b, gfun, hfun, args=(), epsabs=1.49e-8, epsrel=1.49e-8
  ):
      """
      Compute a double integral.
  
      Return the double (definite) integral of ``func(y, x)`` from ``x = a..b``
      and ``y = gfun(x)..hfun(x)``.
  
      Parameters
      ----------
      func : callable
          A Python function or method of at least two variables: y must be the
          first argument and x the second argument.
      a, b : float
          The limits of integration in x: `a` < `b`
      gfun : callable or float
          The lower boundary curve in y which is a function taking a single
          floating point argument (x) and returning a floating point result
          or a float indicating a constant boundary curve.
      hfun : callable or float
          The upper boundary curve in y (same requirements as `gfun`).
      args : sequence, optional
          Extra arguments to pass to `func`.
      epsabs : float, optional
          Absolute tolerance passed directly to the inner 1-D quadrature
          integration. Default is 1.49e-8. `dblquad`` tries to obtain
          an accuracy of ``abs(i-result) <= max(epsabs, epsrel*abs(i))``
          where ``i`` = inner integral of ``func(y, x)`` from ``gfun(x)``
          to ``hfun(x)``, and ``result`` is the numerical approximation.
          See `epsrel` below.
      epsrel : float, optional
          Relative tolerance of the inner 1-D integrals. Default is 1.49e-8.
          If ``epsabs <= 0``, `epsrel` must be greater than both 5e-29
          and ``50 * (machine epsilon)``. See `epsabs` above.
  
      Returns
      -------
      y : float
          The resultant integral.
      abserr : float
          An estimate of the error.
  
      See also
      --------
      quad : single integral
      tplquad : triple integral
      nquad : N-dimensional integrals
      fixed_quad : fixed-order Gaussian quadrature
      quadrature : adaptive Gaussian quadrature
      odeint : ODE integrator
      ode : ODE integrator
      simpson : integrator for sampled data
      romb : integrator for sampled data
      scipy.special : for coefficients and roots of orthogonal polynomials
  
      Examples
      --------
  
      Compute the double integral of ``x * y**2`` over the box
      ``x`` ranging from 0 to 2 and ``y`` ranging from 0 to 1.
  
      >>> from scipy import integrate
      >>> f = lambda y, x: x*y**2
      >>> integrate.dblquad(f, 0, 2, lambda x: 0, lambda x: 1)
          (0.6666666666666667, 7.401486830834377e-15)
  
      """
  
      def temp_ranges(*args):
          return [
              gfun(args[0]) if callable(gfun) else gfun,
              hfun(args[0]) if callable(hfun) else hfun,
          ]
  
      return nquad(
          func,
          [temp_ranges, [a, b]],
          args=args,
          opts={"epsabs": epsabs, "epsrel": epsrel},
      )
  
imports: import sys
  import warnings
  from functools import partial
  from .None import _quadpack
  import numpy
  from numpy import Inf
label_desc: Use image node_id 5 for calling a global function with example usage: dblquad(func, a, b, gfun, hfun, args, epsabs, epsrel) and returns: nquad, list