code: def seterrcall(func):
      """
      Set the floating-point error callback function or log object.
  
      There are two ways to capture floating-point error messages.  The first
      is to set the error-handler to 'call', using `seterr`.  Then, set
      the function to call using this function.
  
      The second is to set the error-handler to 'log', using `seterr`.
      Floating-point errors then trigger a call to the 'write' method of
      the provided object.
  
      Parameters
      ----------
      func : callable f(err, flag) or object with write method
          Function to call upon floating-point errors ('call'-mode) or
          object whose 'write' method is used to log such message ('log'-mode).
  
          The call function takes two arguments. The first is a string describing
          the type of error (such as "divide by zero", "overflow", "underflow",
          or "invalid value"), and the second is the status flag.  The flag is a
          byte, whose four least-significant bits indicate the type of error, one
          of "divide", "over", "under", "invalid"::
  
            [0 0 0 0 divide over under invalid]
  
          In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
  
          If an object is provided, its write method should take one argument,
          a string.
  
      Returns
      -------
      h : callable, log instance or None
          The old error handler.
  
      See Also
      --------
      seterr, geterr, geterrcall
  
      Examples
      --------
      Callback upon error:
  
      >>> def err_handler(type, flag):
      ...     print("Floating point error (%s), with flag %s" % (type, flag))
      ...
  
      >>> saved_handler = np.seterrcall(err_handler)
      >>> save_err = np.seterr(all='call')
  
      >>> np.array([1, 2, 3]) / 0.0
      Floating point error (divide by zero), with flag 1
      array([inf, inf, inf])
  
      >>> np.seterrcall(saved_handler)
      <function err_handler at 0x...>
      >>> np.seterr(**save_err)
      {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'}
  
      Log error message:
  
      >>> class Log:
      ...     def write(self, msg):
      ...         print("LOG: %s" % msg)
      ...
  
      >>> log = Log()
      >>> saved_handler = np.seterrcall(log)
      >>> save_err = np.seterr(all='log')
  
      >>> np.array([1, 2, 3]) / 0.0
      LOG: Warning: divide by zero encountered in divide
      array([inf, inf, inf])
  
      >>> np.seterrcall(saved_handler)
      <numpy.core.numeric.Log object at 0x...>
      >>> np.seterr(**save_err)
      {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'}
  
      """
      if func is not None and not isinstance(
          func, collections.abc.Callable
      ):
          if not hasattr(func, "write") or not isinstance(
              func.write, collections.abc.Callable
          ):
              raise ValueError("Only callable can be used as callback")
      pyvals = umath.geterrobj()
      old = geterrcall()
      pyvals[2] = func
      umath.seterrobj(pyvals)
      return old
  
file_path: catboost/contrib/python/numpy/py3/numpy/core/_ufunc_config.py
imports: import collections.abc
  import contextlib
  import contextvars
  from .._utils import set_module
  from .umath import UFUNC_BUFSIZE_DEFAULT, ERR_IGNORE, ERR_WARN, ERR_RAISE, ERR_CALL, ERR_PRINT, ERR_LOG, ERR_DEFAULT, SHIFT_DIVIDEBYZERO, SHIFT_OVERFLOW, SHIFT_UNDERFLOW, SHIFT_INVALID
  from .None import umath
label_desc: Use image node_id 5 for calling a global function with example usage: seterrcall(func) and returns: old