我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用warnings.filters()。
def catch_warnings(): """Catch warnings in a with block in a list""" # make sure deprecation warnings are active in tests warnings.simplefilter('default', category=DeprecationWarning) filters = warnings.filters warnings.filters = filters[:] old_showwarning = warnings.showwarning log = [] def showwarning(message, category, filename, lineno, file=None, line=None): log.append(locals()) try: warnings.showwarning = showwarning yield log finally: warnings.filters = filters warnings.showwarning = old_showwarning
def runWithWarningsSuppressed(suppressedWarnings, f, *a, **kw): """Run the function C{f}, but with some warnings suppressed. @param suppressedWarnings: A list of arguments to pass to filterwarnings. Must be a sequence of 2-tuples (args, kwargs). @param f: A callable, followed by its arguments and keyword arguments """ for args, kwargs in suppressedWarnings: warnings.filterwarnings(*args, **kwargs) addedFilters = warnings.filters[:len(suppressedWarnings)] try: result = f(*a, **kw) except: exc_info = sys.exc_info() _resetWarningFilters(None, addedFilters) raise exc_info[0], exc_info[1], exc_info[2] else: if isinstance(result, defer.Deferred): result.addBoth(_resetWarningFilters, addedFilters) else: _resetWarningFilters(None, addedFilters) return result
def runsource(self, source): "Extend base class method: Stuff the source in the line cache first" filename = self.stuffsource(source) self.more = 0 self.save_warnings_filters = warnings.filters[:] warnings.filterwarnings(action="error", category=SyntaxWarning) # at the moment, InteractiveInterpreter expects str assert isinstance(source, str) #if isinstance(source, str): # from idlelib import IOBinding # try: # source = source.encode(IOBinding.encoding) # except UnicodeError: # self.tkconsole.resetoutput() # self.write("Unsupported characters in input\n") # return try: # InteractiveInterpreter.runsource() calls its runcode() method, # which is overridden (see below) return InteractiveInterpreter.runsource(self, source, filename) finally: if self.save_warnings_filters is not None: warnings.filters[:] = self.save_warnings_filters self.save_warnings_filters = None
def runsource(self, source): "Extend base class method: Stuff the source in the line cache first" filename = self.stuffsource(source) self.more = 0 self.save_warnings_filters = warnings.filters[:] warnings.filterwarnings(action="error", category=SyntaxWarning) if isinstance(source, unicode) and IOBinding.encoding != 'utf-8': try: source = '# -*- coding: %s -*-\n%s' % ( IOBinding.encoding, source.encode(IOBinding.encoding)) except UnicodeError: self.tkconsole.resetoutput() self.write("Unsupported characters in input\n") return try: # InteractiveInterpreter.runsource() calls its runcode() method, # which is overridden (see below) return InteractiveInterpreter.runsource(self, source, filename) finally: if self.save_warnings_filters is not None: warnings.filters[:] = self.save_warnings_filters self.save_warnings_filters = None
def filter(self, category=Warning, message="", module=None): """ Add a new suppressing filter or apply it if the state is entered. Parameters ---------- category : class, optional Warning class to filter message : string, optional Regular expression matching the warning message. module : module, optional Module to filter for. Note that the module (and its file) must match exactly and cannot be a submodule. This may make it unreliable for external modules. Notes ----- When added within a context, filters are only added inside the context and will be forgotten when the context is exited. """ self._filter(category=category, message=message, module=module, record=False)
def record(self, category=Warning, message="", module=None): """ Append a new recording filter or apply it if the state is entered. All warnings matching will be appended to the ``log`` attribute. Parameters ---------- category : class, optional Warning class to filter message : string, optional Regular expression matching the warning message. module : module, optional Module to filter for. Note that the module (and its file) must match exactly and cannot be a submodule. This may make it unreliable for external modules. Returns ------- log : list A list which will be filled with all matched warnings. Notes ----- When added within a context, filters are only added inside the context and will be forgotten when the context is exited. """ return self._filter(category=category, message=message, module=module, record=True)
def runsource(self, source): "Extend base class method: Stuff the source in the line cache first" filename = self.stuffsource(source) self.more = 0 self.save_warnings_filters = warnings.filters[:] warnings.filterwarnings(action="error", category=SyntaxWarning) if isinstance(source, types.UnicodeType): from idlelib import IOBinding try: source = source.encode(IOBinding.encoding) except UnicodeError: self.tkconsole.resetoutput() self.write("Unsupported characters in input\n") return try: # InteractiveInterpreter.runsource() calls its runcode() method, # which is overridden (see below) return InteractiveInterpreter.runsource(self, source, filename) finally: if self.save_warnings_filters is not None: warnings.filters[:] = self.save_warnings_filters self.save_warnings_filters = None
def test_1(): with pytest.warns(DeprecationWarning) as records: warnings.simplefilter('ignore') print('warnings.warn is ', warnings.warn.__module__) print('filters', warnings.filters) filterwarnings('default', category=DeprecationWarning, emodule='examples.dependency') filterwarnings('ignore', category=DeprecationWarning, emodule='examples.dependency.bar') consumer() for r in records.list: print('Record :', r.message, 'In file', r.filename) assert len(records) == 1
def test_filteredWarning(self): """ L{deprecate.warnAboutFunction} emits a warning that will be filtered if L{warnings.filterwarning} is called with the module name of the deprecated function. """ # Clean up anything *else* that might spuriously filter out the warning, # such as the "always" simplefilter set up by unittest._collectWarnings. # We'll also rely on trial to restore the original filters afterwards. del warnings.filters[:] warnings.filterwarnings( action="ignore", module="twisted_private_helper") from twisted_private_helper import module module.callTestFunction() warningsShown = self.flushWarnings() self.assertEqual(len(warningsShown), 0)
def runWithWarningsSuppressed(suppressedWarnings, f, *a, **kw): """Run the function C{f}, but with some warnings suppressed. @param suppressedWarnings: A list of arguments to pass to filterwarnings. Must be a sequence of 2-tuples (args, kwargs). @param f: A callable, followed by its arguments and keyword arguments """ for args, kwargs in suppressedWarnings: warnings.filterwarnings(*args, **kwargs) addedFilters = warnings.filters[:len(suppressedWarnings)] try: result = f(*a, **kw) except: exc_info = sys.exc_info() _resetWarningFilters(None, addedFilters) reraise(exc_info[1], exc_info[2]) else: if isinstance(result, defer.Deferred): result.addBoth(_resetWarningFilters, addedFilters) else: _resetWarningFilters(None, addedFilters) return result
def test_flushedWarningsConfiguredAsErrors(self): """ If a warnings filter has been installed which turns warnings into exceptions, tests which emit those warnings but flush them do not have an error added to the reporter. """ class CustomWarning(Warning): pass result = TestResult() case = Mask.MockTests('test_flushed') case.category = CustomWarning originalWarnings = warnings.filters[:] try: warnings.simplefilter('error') case.run(result) self.assertEqual(result.errors, []) finally: warnings.filters[:] = originalWarnings
def __enter__(self): if self._entered: raise RuntimeError("Cannot enter %r twice" % self) self._entered = True self._filters = self._module.filters self._module.filters = self._filters[:] self._showwarning = self._module.showwarning if self._record: log = [] def showwarning(*args, **kwargs): log.append(WarningMessage(*args, **kwargs)) self._module.showwarning = showwarning return log else: return None
def test_deprecated(self): import warnings warnings.resetwarnings() # in case we've instantiated one before # set up warning filters to allow all, set up restore when this test is done filters_backup, warnings.filters = warnings.filters, [] self.addCleanup(setattr, warnings, 'filters', filters_backup) with warnings.catch_warnings(record=True) as caught_warnings: WhiteListRoundRobinPolicy([]) self.assertEqual(len(caught_warnings), 1) warning_message = caught_warnings[-1] self.assertEqual(warning_message.category, DeprecationWarning) self.assertIn('4.0', warning_message.message.args[0])
def test_version_10_format_legacy_parser(self): """ """ path_variable = None for env in os.environ: if env.lower() == 'path': path_variable = env if path_variable: old_path = os.environ[path_variable] os.environ[path_variable] = '' #catch_warnings not available until py26 warning_filters = warnings.filters warnings.filters = warning_filters[:] try: warnings.simplefilter("ignore", DeprecationWarning) self._write_entries(ENTRIES_V10) rev = egg_info.egg_info.get_svn_revision() finally: #restore the warning filters warnings.filters = warning_filters #restore the os path if path_variable: os.environ[path_variable] = old_path self.assertEqual(rev, '89000')
