MNT: Remove cmap_d colormap access

greglucas · greglucas · commit fce605e7d064 · 2022-01-24T08:07:26.000-07:00
diff --git a/doc/api/next_api_changes/deprecations/22298-GL.rst b/doc/api/next_api_changes/deprecations/22298-GL.rst
@@ -0,0 +1,5 @@
+``cmap_d`` removal
+~~~~~~~~~~~~~~~~~~
+
+The deprecated ``matplotlib.cm.cmap_d`` access to global colormaps
+has been removed.
diff --git a/lib/matplotlib/cm.py b/lib/matplotlib/cm.py
@@ -15,7 +15,7 @@
   normalization.
 """
 
-from collections.abc import Mapping, MutableMapping
+from collections.abc import Mapping
 
 import numpy as np
 from numpy import ma
@@ -52,52 +52,10 @@ def _gen_cmap_registry():
     # Generate reversed cmaps.
     for cmap in list(cmap_d.values()):
         rmap = cmap.reversed()
-        cmap._global = True
-        rmap._global = True
         cmap_d[rmap.name] = rmap
     return cmap_d
 
 
-class _DeprecatedCmapDictWrapper(MutableMapping):
-    """Dictionary mapping for deprecated _cmap_d access."""
-
-    def __init__(self, cmap_registry):
-        self._cmap_registry = cmap_registry
-
-    def __delitem__(self, key):
-        self._warn_deprecated()
-        self._cmap_registry.__delitem__(key)
-
-    def __getitem__(self, key):
-        self._warn_deprecated()
-        return self._cmap_registry.__getitem__(key)
-
-    def __iter__(self):
-        self._warn_deprecated()
-        return self._cmap_registry.__iter__()
-
-    def __len__(self):
-        self._warn_deprecated()
-        return self._cmap_registry.__len__()
-
-    def __setitem__(self, key, val):
-        self._warn_deprecated()
-        self._cmap_registry.__setitem__(key, val)
-
-    def get(self, key, default=None):
-        self._warn_deprecated()
-        return self._cmap_registry.get(key, default)
-
-    def _warn_deprecated(self):
-        _api.warn_deprecated(
-            "3.3",
-            message="The global colormaps dictionary is no longer "
-                    "considered public API.",
-            alternative="Please use register_cmap() and get_cmap() to "
-                        "access the contents of the dictionary."
-        )
-
-
 class ColormapRegistry(Mapping):
     r"""
     Container for colormaps that are known to Matplotlib by name.
@@ -125,6 +83,7 @@ class ColormapRegistry(Mapping):
     """
     def __init__(self, cmaps):
         self._cmaps = cmaps
+        self._builtin_cmaps = tuple(cmaps)
 
     def __getitem__(self, item):
         try:
@@ -177,23 +136,67 @@ def register(self, cmap, *, name=None, force=False):
             registered name. True supports overwriting registered colormaps
             other than the builtin colormaps.
         """
+        if not isinstance(cmap, colors.Colormap):
+            raise ValueError("You must pass a Colormap instance. "
+                             f"You passed {cmap} a {type(cmap)} object.")
+
         name = name or cmap.name
-        if name in self and not force:
-            raise ValueError(
-                f'A colormap named "{name}" is already registered.')
-        register_cmap(name, cmap.copy())
+        if name in self:
+            if not force and name in self._builtin_cmaps:
+                msg = f"Trying to re-register the builtin cmap {name!r}."
+                raise ValueError(msg)
+            elif not force:
+                raise ValueError(
+                    f'A colormap named "{name}" is already registered.')
+            else:
+                _api.warn_external(f"Trying to register the cmap {name!r} "
+                                   "which already exists.")
 
+        self._cmaps[name] = cmap.copy()
+
+    def unregister(self, name):
+        """
+        Remove a colormap from the registry.
+
+        You may not remove built-in colormaps.
+
+        If the named colormap is not registered, returns with no error, raises
+        if you try to de-register a default colormap.
+
+        .. warning::
+
+            The ColormapRegistry is a shared namespace that may be used
+            by multiple packages. Use `unregister` only if you know you
+            have registered that name before. In particular, do not
+            unregister just in case to clean the name before registering a
+            new colormap.
+
+        Parameters
+        ----------
+        name : str
+            The name of the colormap to be removed
+
+        Returns
+        -------
+        Colormap or None
+            If the colormap was registered, return it if not return `None`
+
+        Raises
+        ------
+        ValueError
+            If you try to remove a default built-in colormap.
+        """
+        if name in self._builtin_cmaps:
+            raise ValueError(f"cannot unregister {name!r} which is a builtin "
+                             "colormap.")
+        return self._cmaps.pop(name, None)
 
-_cmap_registry = _gen_cmap_registry()
-globals().update(_cmap_registry)
-# This is no longer considered public API
-cmap_d = _DeprecatedCmapDictWrapper(_cmap_registry)
-__builtin_cmaps = tuple(_cmap_registry)
 
 # public access to the colormaps should be via `matplotlib.colormaps`. For now,
 # we still create the registry here, but that should stay an implementation
 # detail.
-_colormaps = ColormapRegistry(_cmap_registry)
+_colormaps = _cmap_registry = ColormapRegistry(_gen_cmap_registry())
+globals().update(_cmap_registry)
 
 
 def register_cmap(name=None, cmap=None, *, override_builtin=False):
@@ -223,14 +226,6 @@ def register_cmap(name=None, cmap=None, *, override_builtin=False):
         colormap.
 
         Please do not use this unless you are sure you need it.
-
-    Notes
-    -----
-    Registering a colormap stores a reference to the colormap object
-    which can currently be modified and inadvertently change the global
-    colormap state. This behavior is deprecated and in Matplotlib 3.5
-    the registered colormap will be immutable.
-
     """
     _api.check_isinstance((str, None), name=name)
     if name is None:
@@ -239,21 +234,7 @@ def register_cmap(name=None, cmap=None, *, override_builtin=False):
         except AttributeError as err:
             raise ValueError("Arguments must include a name or a "
                              "Colormap") from err
-    if name in _cmap_registry:
-        if not override_builtin and name in __builtin_cmaps:
-            msg = f"Trying to re-register the builtin cmap {name!r}."
-            raise ValueError(msg)
-        else:
-            msg = f"Trying to register the cmap {name!r} which already exists."
-            _api.warn_external(msg)
-
-    if not isinstance(cmap, colors.Colormap):
-        raise ValueError("You must pass a Colormap instance. "
-                         f"You passed {cmap} a {type(cmap)} object.")
-
-    cmap._global = True
-    _cmap_registry[name] = cmap
-    return
+    _cmap_registry.register(cmap, name=name, force=override_builtin)
 
 
 def get_cmap(name=None, lut=None):
@@ -263,12 +244,6 @@ def get_cmap(name=None, lut=None):
     Colormaps added with :func:`register_cmap` take precedence over
     built-in colormaps.
 
-    Notes
-    -----
-    Currently, this returns the global colormap object, which is deprecated.
-    In Matplotlib 3.5, you will no longer be able to modify the global
-    colormaps in-place.
-
     Parameters
     ----------
     name : `matplotlib.colors.Colormap` or str or None, default: None
@@ -323,12 +298,7 @@ def unregister_cmap(name):
        If you try to de-register a default built-in colormap.
 
     """
-    if name not in _cmap_registry:
-        return
-    if name in __builtin_cmaps:
-        raise ValueError(f"cannot unregister {name!r} which is a builtin "
-                         "colormap.")
-    return _cmap_registry.pop(name)
+    return _cmap_registry.unregister(name)
 
 
 class ScalarMappable:
diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py
@@ -41,7 +41,6 @@
 
 import base64
 from collections.abc import Sized, Sequence
-import copy
 import functools
 import inspect
 import io
@@ -534,20 +533,6 @@ def _create_lookup_table(N, data, gamma=1.0):
     return np.clip(lut, 0.0, 1.0)
 
 
-def _warn_if_global_cmap_modified(cmap):
-    if getattr(cmap, '_global', False):
-        _api.warn_deprecated(
-            "3.3",
-            removal="3.6",
-            message="You are modifying the state of a globally registered "
-                    "colormap. This has been deprecated since %(since)s and "
-                    "%(removal)s, you will not be able to modify a "
-                    "registered colormap in-place. To remove this warning, "
-                    "you can make a copy of the colormap first. "
-                    f'cmap = mpl.cm.get_cmap("{cmap.name}").copy()'
-        )
-
-
 class Colormap:
     """
     Baseclass for all scalar to RGBA mappings.
@@ -664,7 +649,6 @@ def __copy__(self):
         cmapobject.__dict__.update(self.__dict__)
         if self._isinit:
             cmapobject._lut = np.copy(self._lut)
-        cmapobject._global = False
         return cmapobject
 
     def __eq__(self, other):
@@ -686,7 +670,6 @@ def get_bad(self):
 
     def set_bad(self, color='k', alpha=None):
         """Set the color for masked values."""
-        _warn_if_global_cmap_modified(self)
         self._rgba_bad = to_rgba(color, alpha)
         if self._isinit:
             self._set_extremes()
@@ -699,7 +682,6 @@ def get_under(self):
 
     def set_under(self, color='k', alpha=None):
         """Set the color for low out-of-range values."""
-        _warn_if_global_cmap_modified(self)
         self._rgba_under = to_rgba(color, alpha)
         if self._isinit:
             self._set_extremes()
@@ -712,7 +694,6 @@ def get_over(self):
 
     def set_over(self, color='k', alpha=None):
         """Set the color for high out-of-range values."""
-        _warn_if_global_cmap_modified(self)
         self._rgba_over = to_rgba(color, alpha)
         if self._isinit:
             self._set_extremes()
@@ -735,7 +716,7 @@ def with_extremes(self, *, bad=None, under=None, over=None):
         values and, when ``norm.clip = False``, low (*under*) and high (*over*)
         out-of-range values, have been set accordingly.
         """
-        new_cm = copy.copy(self)
+        new_cm = self.copy()
         new_cm.set_extremes(bad=bad, under=under, over=over)
         return new_cm
 
diff --git a/lib/matplotlib/tests/test_colors.py b/lib/matplotlib/tests/test_colors.py
@@ -66,7 +66,7 @@ def test_resample():
 
 
 def test_register_cmap():
-    new_cm = copy.copy(cm.get_cmap("viridis"))
+    new_cm = cm.get_cmap("viridis")
     target = "viridis2"
     cm.register_cmap(target, new_cm)
     assert plt.get_cmap(target) == new_cm
@@ -75,9 +75,6 @@ def test_register_cmap():
                        match="Arguments must include a name or a Colormap"):
         cm.register_cmap()
 
-    with pytest.warns(UserWarning):
-        cm.register_cmap(target, new_cm)
-
     cm.unregister_cmap(target)
     with pytest.raises(ValueError,
                        match=f'{target!r} is not a valid value for name;'):
@@ -105,42 +102,6 @@ def test_unregister_builtin_cmap():
         cm.unregister_cmap(name)
 
 
-def test_colormap_global_set_warn():
-    new_cm = plt.get_cmap('viridis')
-    # Store the old value so we don't override the state later on.
-    orig_cmap = copy.copy(new_cm)
-    with pytest.warns(cbook.MatplotlibDeprecationWarning,
-                      match="You are modifying the state of a globally"):
-        # This should warn now because we've modified the global state
-        new_cm.set_under('k')
-
-    # This shouldn't warn because it is a copy
-    copy.copy(new_cm).set_under('b')
-
-    # Test that registering and then modifying warns
-    plt.register_cmap(name='test_cm', cmap=copy.copy(orig_cmap))
-    new_cm = plt.get_cmap('test_cm')
-    with pytest.warns(cbook.MatplotlibDeprecationWarning,
-                      match="You are modifying the state of a globally"):
-        # This should warn now because we've modified the global state
-        new_cm.set_under('k')
-
-    # Re-register the original
-    with pytest.warns(UserWarning):
-        plt.register_cmap(cmap=orig_cmap, override_builtin=True)
-
-
-def test_colormap_dict_deprecate():
-    # Make sure we warn on get and set access into cmap_d
-    with pytest.warns(cbook.MatplotlibDeprecationWarning,
-                      match="The global colormaps dictionary is no longer"):
-        cmap = plt.cm.cmap_d['viridis']
-
-    with pytest.warns(cbook.MatplotlibDeprecationWarning,
-                      match="The global colormaps dictionary is no longer"):
-        plt.cm.cmap_d['test'] = cmap
-
-
 def test_colormap_copy():
     cmap = plt.cm.Reds
     copied_cmap = copy.copy(cmap)
