Modification of the ignore_warning function and _IgnoreWarning class.

tguillemot · tguillemot · commit aeabdee7c82c · 2016-04-21T17:38:51.000+02:00
diff --git a/doc/whats_new.rst b/doc/whats_new.rst
@@ -131,6 +131,9 @@ Enhancements
    - Add option to show ``indicator features`` in the output of Imputer.
      By `Mani Teja`_.
 
+   - The :func: `ignore_warnings` now accept a category argument to ignore only
+     the warnings of a specified type. By `Thierry Guillemot`_.
+
 Bug fixes
 .........
 
@@ -198,6 +201,12 @@ API changes summary
    - Access to public attributes ``.X_`` and ``.y_`` has been deprecated in
      :class:`isotonic.IsotonicRegression`. By `Jonathan Arfa`_.
 
+   - The old :class:`GMM` is deprecated in favor of the new
+     :class:`GaussianMixture`. The new class compute the Gaussian mixture
+     faster than before and some of computationnal problems have been solved.
+     By `Thierry Guillemot`_.
+
+
 
 .. _changes_0_17_1:
 
@@ -4148,3 +4157,5 @@ David Huard, Dave Morrill, Ed Schofield, Travis Oliphant, Pearu Peterson.
 .. _JPFrancoia: https://github.com/JPFrancoia
 
 .. _Mani Teja: https://github.com/maniteja123
+
+.. _Thierry Guillemot: https://github.com/tguillemot
diff --git a/sklearn/utils/testing.py b/sklearn/utils/testing.py
@@ -8,6 +8,7 @@
 #          Arnaud Joly
 #          Denis Engemann
 #          Giorgio Patrini
+#          Thierry Guillemot
 # License: BSD 3 clause
 import os
 import inspect
@@ -93,8 +94,7 @@ def assert_not_in(x, container):
     # for Python 2
     def assert_raises_regex(expected_exception, expected_regexp,
                             callable_obj=None, *args, **kwargs):
-        """Helper function to check for message patterns in exceptions"""
-
+        """Helper function to check for message patterns in exceptions."""
         not_raised = False
         try:
             callable_obj(*args, **kwargs)
@@ -165,7 +165,6 @@ def assert_warns(warning_class, func, *args, **kw):
     result : the return value of `func`
 
     """
-
     # very important to avoid uncontrolled state propagation
     clean_warning_registry()
     with warnings.catch_warnings(record=True) as w:
@@ -282,17 +281,17 @@ def assert_no_warnings(func, *args, **kw):
     return result
 
 
-def ignore_warnings(obj=None, category=None):
-    """ Context manager and decorator to ignore warnings
+def ignore_warnings(obj=None, category=Warning):
+    """Context manager and decorator to ignore warnings.
 
     Note. Using this (in both variants) will clear all warnings
     from all python modules loaded. In case you need to test
     cross-module-warning-logging this is not your tool of choice.
 
     Parameters
     ----------
-    category : warning class, defaults to None.
-        The category to filter. If None, all categories will be muted.
+    category : warning class, defaults to Warning.
+        The category to filter. If Warning, all categories will be muted.
 
     Examples
     --------
@@ -305,47 +304,44 @@ def ignore_warnings(obj=None, category=None):
 
     >>> ignore_warnings(nasty_warn)()
     42
-
     """
-
-    def _ignore_warnings(fn):
-        """Decorator to catch and hide warnings without visual nesting"""
-        @wraps(fn)
-        def wrapper(*args, **kwargs):
-            # very important to avoid uncontrolled state propagation
-            clean_warning_registry()
-            with warnings.catch_warnings():
-                if category is None:
-                    warnings.simplefilter("ignore")
-                else:
-                    warnings.simplefilter("ignore", category)
-                return fn(*args, **kwargs)
-
-        return wrapper
-
     if callable(obj):
-        return _ignore_warnings(obj)
-    elif category is None:
-        return _IgnoreWarnings()
+        return _IgnoreWarnings(category=category)(obj)
     else:
-        return _ignore_warnings
+        return _IgnoreWarnings(category=category)
 
 
 class _IgnoreWarnings(object):
+    """Improved and simplified Python warnings context manager and decorator.
 
-    """Improved and simplified Python warnings context manager
-
+    This class allows to ignore the warnings raise by a function.
     Copied from Python 2.7.5 and modified as required.
-    """
 
-    def __init__(self):
-        """
+    Parameters
+    ----------
+    category : tuple of warning class, defaut to Warning
+        The category to filter. By default, all the categories will be muted.
 
-        """
+    """
+
+    def __init__(self, category):
         self._record = True
         self._module = sys.modules['warnings']
         self._entered = False
         self.log = []
+        self.category = category
+
+    def __call__(self, fn):
+        """Decorator to catch and hide warnings without visual nesting."""
+        @wraps(fn)
+        def wrapper(*args, **kwargs):
+            # very important to avoid uncontrolled state propagation
+            clean_warning_registry()
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", self.category)
+                return fn(*args, **kwargs)
+
+        return wrapper
 
     def __repr__(self):
         args = []
@@ -358,22 +354,13 @@ def __repr__(self):
 
     def __enter__(self):
         clean_warning_registry()  # be safe and not propagate state + chaos
-        warnings.simplefilter('always')
+        warnings.simplefilter("ignore", self.category)
         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:
-            self.log = []
-
-            def showwarning(*args, **kwargs):
-                self.log.append(warnings.WarningMessage(*args, **kwargs))
-            self._module.showwarning = showwarning
-            return self.log
-        else:
-            return None
 
     def __exit__(self, *exc_info):
         if not self._entered:
@@ -412,7 +399,7 @@ def _assert_allclose(actual, desired, rtol=1e-7, atol=0,
 
 
 def assert_raise_message(exceptions, message, function, *args, **kwargs):
-    """Helper function to test error messages in exceptions
+    """Helper function to test error messages in exceptions.
 
     Parameters
     ----------
@@ -621,8 +608,8 @@ def is_abstract(c):
     all_classes = set(all_classes)
 
     estimators = [c for c in all_classes
-                  if (issubclass(c[1], BaseEstimator)
-                      and c[0] != 'BaseEstimator')]
+                  if (issubclass(c[1], BaseEstimator) and
+                      c[0] != 'BaseEstimator')]
     # get rid of abstract base classes
     estimators = [c for c in estimators if not is_abstract(c[1])]
 
@@ -652,7 +639,8 @@ def is_abstract(c):
         estimators = filtered_estimators
         if type_filter:
             raise ValueError("Parameter type_filter must be 'classifier', "
-                             "'regressor', 'transformer', 'cluster' or None, got"
+                             "'regressor', 'transformer', 'cluster' or "
+                             "None, got"
                              " %s." % repr(type_filter))
 
     # drop duplicates, sort for reproducibility
@@ -667,7 +655,6 @@ def set_random_state(estimator, random_state=0):
     Classes for whom random_state is deprecated are ignored. Currently DBSCAN
     is one such class.
     """
-
     if isinstance(estimator, DBSCAN):
         return
 
@@ -676,8 +663,7 @@ def set_random_state(estimator, random_state=0):
 
 
 def if_matplotlib(func):
-    """Test decorator that skips test if matplotlib not installed. """
-
+    """Test decorator that skips test if matplotlib not installed."""
     @wraps(func)
     def run_test(*args, **kwargs):
         try:
@@ -728,7 +714,7 @@ def func(*args, **kwargs):
 
 
 def if_safe_multiprocessing_with_blas(func):
-    """Decorator for tests involving both BLAS calls and multiprocessing
+    """Decorator for tests involving both BLAS calls and multiprocessing.
 
     Under POSIX (e.g. Linux or OSX), using multiprocessing in conjunction with
     some implementation of BLAS (or other libraries that manage an internal
@@ -745,7 +731,6 @@ def if_safe_multiprocessing_with_blas(func):
     for multiprocessing to avoid this issue. However it can cause pickling
     errors on interactively defined functions. It therefore not enabled by
     default.
-
     """
     @wraps(func)
     def run_test(*args, **kwargs):
@@ -757,7 +742,7 @@ def run_test(*args, **kwargs):
 
 
 def clean_warning_registry():
-    """Safe way to reset warnings """
+    """Safe way to reset warnings."""
     warnings.resetwarnings()
     reg = "__warningregistry__"
     for mod_name, mod in list(sys.modules.items()):
@@ -780,7 +765,9 @@ def check_skip_travis():
 
 def _delete_folder(folder_path, warn=False):
     """Utility function to cleanup a temporary folder if still existing.
-    Copy from joblib.pool (for independence)"""
+
+    Copy from joblib.pool (for independence).
+    """
     try:
         if os.path.exists(folder_path):
             # This can fail under windows,
diff --git a/sklearn/utils/tests/test_testing.py b/sklearn/utils/tests/test_testing.py
@@ -13,7 +13,8 @@
     assert_no_warnings,
     assert_equal,
     set_random_state,
-    assert_raise_message)
+    assert_raise_message,
+    ignore_warnings)
 
 from sklearn.tree import DecisionTreeClassifier
 from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
@@ -96,6 +97,98 @@ def _no_raise():
                   "test", _no_raise)
 
 
+def test_ignore_warning():
+    # This check that ignore_warning decorateur and context manager are working
+    # as expected
+    def _warning_function():
+        warnings.warn("deprecation warning", DeprecationWarning)
+
+    def _multiple_warning_function():
+        warnings.warn("deprecation warning", DeprecationWarning)
+        warnings.warn("deprecation warning")
+
+    # Check the function directly
+    assert_no_warnings(ignore_warnings(_warning_function))
+    assert_no_warnings(ignore_warnings(_warning_function,
+                                       category=DeprecationWarning))
+    assert_warns(DeprecationWarning, ignore_warnings(_warning_function,
+                                                     category=UserWarning))
+    assert_warns(UserWarning,
+                 ignore_warnings(_multiple_warning_function,
+                                 category=DeprecationWarning))
+    assert_warns(DeprecationWarning,
+                 ignore_warnings(_multiple_warning_function,
+                                 category=UserWarning))
+    assert_no_warnings(ignore_warnings(_warning_function,
+                                       category=(DeprecationWarning,
+                                                 UserWarning)))
+
+    # Check the decorator
+    @ignore_warnings
+    def decorator_no_warning():
+        _warning_function()
+        _multiple_warning_function()
+
+    @ignore_warnings(category=(DeprecationWarning, UserWarning))
+    def decorator_no_warning_multiple():
+        _multiple_warning_function()
+
+    @ignore_warnings(category=DeprecationWarning)
+    def decorator_no_deprecation_warning():
+        _warning_function()
+
+    @ignore_warnings(category=UserWarning)
+    def decorator_no_user_warning():
+        _warning_function()
+
+    @ignore_warnings(category=DeprecationWarning)
+    def decorator_no_deprecation_multiple_warning():
+        _multiple_warning_function()
+
+    @ignore_warnings(category=UserWarning)
+    def decorator_no_user_multiple_warning():
+        _multiple_warning_function()
+
+    assert_no_warnings(decorator_no_warning)
+    assert_no_warnings(decorator_no_warning_multiple)
+    assert_no_warnings(decorator_no_deprecation_warning)
+    assert_warns(DeprecationWarning, decorator_no_user_warning)
+    assert_warns(UserWarning, decorator_no_deprecation_multiple_warning)
+    assert_warns(DeprecationWarning, decorator_no_user_multiple_warning)
+
+    # Check the context manager
+    def context_manager_no_warning():
+        with ignore_warnings():
+            _warning_function()
+
+    def context_manager_no_warning_multiple():
+        with ignore_warnings(category=(DeprecationWarning, UserWarning)):
+            _multiple_warning_function()
+
+    def context_manager_no_deprecation_warning():
+        with ignore_warnings(category=DeprecationWarning):
+            _warning_function()
+
+    def context_manager_no_user_warning():
+        with ignore_warnings(category=UserWarning):
+            _warning_function()
+
+    def context_manager_no_deprecation_multiple_warning():
+        with ignore_warnings(category=DeprecationWarning):
+            _multiple_warning_function()
+
+    def context_manager_no_user_multiple_warning():
+        with ignore_warnings(category=UserWarning):
+            _multiple_warning_function()
+
+    assert_no_warnings(context_manager_no_warning)
+    assert_no_warnings(context_manager_no_warning_multiple)
+    assert_no_warnings(context_manager_no_deprecation_warning)
+    assert_warns(DeprecationWarning, context_manager_no_user_warning)
+    assert_warns(UserWarning, context_manager_no_deprecation_multiple_warning)
+    assert_warns(DeprecationWarning, context_manager_no_user_multiple_warning)
+
+
 # This class is inspired from numpy 1.7 with an alteration to check
 # the reset warning filters after calls to assert_warns.
 # This assert_warns behavior is specific to scikit-learn because
