Skip to main content
`Ctrl`+`K`

# numpy.testing.suppress_warnings

class numpy.testing.suppress_warnings(forwarding_rule='always', _warn=True)

  Context manager and decorator doing much the same as `warnings.catch_warnings`.

  However, it also provides a filter mechanism to work around https://bugs.python.org/issue4180.

  This bug causes Python before 3.4 to not reliably show warnings again after they have been ignored once (even within catch_warnings). It means that no “ignore” filter can be used easily, since following tests might need to see the warning. Additionally it allows easier specificity for testing warnings and can be nested.

  Deprecated since version 2.4: This is deprecated. Use `warnings.filterwarnings` or `pytest.filterwarnings` instead.

  Parameters:
    forwarding_rule str, optional

      One of “always”, “once”, “module”, or “location”. Analogous to the usual warnings module filter mode, it is useful to reduce noise mostly on the outmost level. Unsuppressed and unrecorded warnings will be forwarded based on this rule. Defaults to “always”. “location” is equivalent to the warnings “default”, match by exact location the warning warning originated from.

  Notes

  Filters added inside the context manager will be discarded again when leaving it. Upon entering all filters defined outside a context will be applied automatically.

  When a recording filter is added, matching warnings are stored in the `log` attribute as well as in the list returned by `record`.

  If filters are added and the `module` keyword is given, the warning registry of this module will additionally be cleared when applying it, entering the context, or exiting it. This could cause warnings to appear a second time after leaving the context if they were configured to be printed once (default) and were already printed before the context was entered.

  Nesting this context manager will work as expected when the forwarding rule is “always” (default). Unfiltered and unrecorded warnings will be passed out and be matched by the outer level. On the outmost level they will be printed (or caught by another warnings context). The forwarding rule argument can modify this behaviour.

  Like `catch_warnings` this context manager is not threadsafe.

  Examples

  With a context manager:

      with np.testing.suppress_warnings() as sup:
          sup.filter(DeprecationWarning, "Some text")
          sup.filter(module=np.ma.core)
          log = sup.record(FutureWarning, "Does this occur?")
          command_giving_warnings()
          # The FutureWarning was given once, the filtered warnings were
          # ignored. All other warnings abide outside settings (may be
          # printed/error)
          assert_(len(log) == 1)
          assert_(len(sup.log) == 1)  # also stored in log attribute

  Or as a decorator:

      sup = np.testing.suppress_warnings()
      sup.filter(module=np.ma.core)  # module must match exactly
      @sup
      def some_function():
          # do something which causes a warning in np.ma.core
          pass

  Methods

  `__call__`(func) | Function decorator to apply certain suppressions to a whole function.
  `filter`([category, message, module]) | Add a new suppressing filter or apply it if the state is entered.
  `record`([category, message, module]) | Append a new recording filter or apply it if the state is entered.