fixed gr[ea]y colormap alias

Author: madeira-dev

lib/matplotlib/cm.py

@@ -26,7 +26,7 @@
 from matplotlib._cm_listed import cmaps as cmaps_listed
 
 
-_LUTSIZE = mpl.rcParams["image.lut"]
+_LUTSIZE = mpl.rcParams['image.lut']
 
 
 def _gen_cmap_registry():
@@ -38,22 +38,20 @@ def _gen_cmap_registry():
     for name, spec in datad.items():
         cmap_d[name] = (  # Precache the cmaps at a fixed lutsize..
             colors.LinearSegmentedColormap(name, spec, _LUTSIZE)
-            if "red" in spec
-            else colors.ListedColormap(spec["listed"], name)
-            if "listed" in spec
-            else colors.LinearSegmentedColormap.from_list(name, spec, _LUTSIZE)
-        )
+            if 'red' in spec else
+            colors.ListedColormap(spec['listed'], name)
+            if 'listed' in spec else
+            colors.LinearSegmentedColormap.from_list(name, spec, _LUTSIZE))
 
-        # Register colormap aliases for gray and grey.
+    # Register colormap aliases for gray and grey.
     cmap_d["grey"] = cmap_d["gray"]
-    cmap_d["Greys"] = cmap_d["Grays"]
     cmap_d["gist_grey"] = cmap_d["gist_gray"]
+    cmap_d["Grays"] = cmap_d["Greys"]
 
     # Generate reversed cmaps.
     for cmap in list(cmap_d.values()):
         rmap = cmap.reversed()
         cmap_d[rmap.name] = rmap
-
     return cmap_d
 
 
@@ -76,7 +74,6 @@ class ColormapRegistry(Mapping):
 
         mpl.colormaps.register(my_colormap)
     """
-
     def __init__(self, cmaps):
         self._cmaps = cmaps
         self._builtin_cmaps = tuple(cmaps)
@@ -96,9 +93,8 @@ def __len__(self):
         return len(self._cmaps)
 
     def __str__(self):
-        return "ColormapRegistry; available colormaps:\n" + ", ".join(
-            f"'{name}'" for name in self
-        )
+        return ('ColormapRegistry; available colormaps:\n' +
+                ', '.join(f"'{name}'" for name in self))
 
     def __call__(self):
         """
@@ -142,20 +138,25 @@ def register(self, cmap, *, name=None, force=False):
             if not force:
                 # don't allow registering an already existing cmap
                 # unless explicitly asked to
-                raise ValueError(f'A colormap named "{name}" is already registered.')
-            elif name in self._builtin_cmaps and not self._allow_override_builtin:
+                raise ValueError(
+                    f'A colormap named "{name}" is already registered.')
+            elif (name in self._builtin_cmaps
+                    and not self._allow_override_builtin):
                 # We don't allow overriding a builtin unless privately
                 # coming from register_cmap()
-                raise ValueError(
-                    "Re-registering the builtin cmap " f"{name!r} is not allowed."
-                )
+                raise ValueError("Re-registering the builtin cmap "
+                                 f"{name!r} is not allowed.")
 
             # Warn that we are updating an already existing colormap
-            _api.warn_external(
-                f"Overwriting the cmap {name!r} " "that was already in the registry."
-            )
+            _api.warn_external(f"Overwriting the cmap {name!r} "
+                               "that was already in the registry.")
 
         self._cmaps[name] = cmap.copy()
+        # Someone may set the extremes of a builtin colormap and want to register it
+        # with a different name for future lookups. The object would still have the
+        # builtin name, so we should update it to the registered name
+        if self._cmaps[name].name != name:
+            self._cmaps[name].name = name
 
     def unregister(self, name):
         """
@@ -185,9 +186,8 @@ def unregister(self, name):
             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."
-            )
+            raise ValueError(f"cannot unregister {name!r} which is a builtin "
+                             "colormap.")
         self._cmaps.pop(name, None)
 
     def get_cmap(self, cmap):
@@ -218,8 +218,8 @@ def get_cmap(self, cmap):
             # otherwise, it must be a string so look it up
             return self[cmap]
         raise TypeError(
-            "get_cmap expects None or an instance of a str or Colormap . "
-            + f"you passed {cmap!r} of type {type(cmap)}"
+            'get_cmap expects None or an instance of a str or Colormap . ' +
+            f'you passed {cmap!r} of type {type(cmap)}'
         )
 
 
@@ -264,7 +264,8 @@ def register_cmap(name=None, cmap=None, *, override_builtin=False):
         try:
             name = cmap.name
         except AttributeError as err:
-            raise ValueError("Arguments must include a name or a " "Colormap") from err
+            raise ValueError("Arguments must include a name or a "
+                             "Colormap") from err
     # override_builtin is allowed here for backward compatibility
     # this is just a shim to enable that to work privately in
     # the global ColormapRegistry
@@ -292,7 +293,7 @@ def _get_cmap(name=None, lut=None):
     Colormap
     """
     if name is None:
-        name = mpl.rcParams["image.cmap"]
+        name = mpl.rcParams['image.cmap']
     if isinstance(name, colors.Colormap):
         return name
     _api.check_in_list(sorted(_colormaps), name=name)
@@ -301,19 +302,20 @@ def _get_cmap(name=None, lut=None):
     else:
         return _colormaps[name].resampled(lut)
 
-
 # do it in two steps like this so we can have an un-deprecated version in
 # pyplot.
 get_cmap = _api.deprecated(
-    "3.7",
-    name="get_cmap",
+    '3.7',
+    name='get_cmap',
     alternative=(
-        "``matplotlib.colormaps[name]`` " + "or ``matplotlib.colormaps.get_cmap(obj)``"
-    ),
+        "``matplotlib.colormaps[name]`` " +
+        "or ``matplotlib.colormaps.get_cmap(obj)``"
+    )
 )(_get_cmap)
 
 
-@_api.deprecated("3.7", alternative="``matplotlib.colormaps.unregister(name)``")
+@_api.deprecated("3.7",
+                 alternative="``matplotlib.colormaps.unregister(name)``")
 def unregister_cmap(name):
     """
     Remove a colormap recognized by :func:`get_cmap`.
@@ -371,10 +373,11 @@ def _auto_norm_from_scale(scale_cls):
     # ``nonpositive="mask"`` is supported.
     try:
         norm = colors.make_norm_from_scale(
-            functools.partial(scale_cls, nonpositive="mask")
-        )(colors.Normalize)()
+            functools.partial(scale_cls, nonpositive="mask"))(
+            colors.Normalize)()
     except TypeError:
-        norm = colors.make_norm_from_scale(scale_cls)(colors.Normalize)()
+        norm = colors.make_norm_from_scale(scale_cls)(
+            colors.Normalize)()
     return type(norm)
 
 
@@ -425,8 +428,7 @@ def _scale_norm(self, norm, vmin, vmax):
                 raise ValueError(
                     "Passing a Normalize instance simultaneously with "
                     "vmin/vmax is not supported.  Please pass vmin/vmax "
-                    "directly to the norm when creating it."
-                )
+                    "directly to the norm when creating it.")
 
         # always resolve the autoscaling so we have concrete limits
         # rather than deferring to draw time.
@@ -478,22 +480,18 @@ def to_rgba(self, x, alpha=None, bytes=False, norm=True):
                     xx = x
                 else:
                     raise ValueError("Third dimension must be 3 or 4")
-                if xx.dtype.kind == "f":
+                if xx.dtype.kind == 'f':
                     if norm and (xx.max() > 1 or xx.min() < 0):
-                        raise ValueError(
-                            "Floating point image RGB values "
-                            "must be in the 0..1 range."
-                        )
+                        raise ValueError("Floating point image RGB values "
+                                         "must be in the 0..1 range.")
                     if bytes:
                         xx = (xx * 255).astype(np.uint8)
                 elif xx.dtype == np.uint8:
                     if not bytes:
                         xx = xx.astype(np.float32) / 255
                 else:
-                    raise ValueError(
-                        "Image RGB array must be uint8 or "
-                        "floating point; found %s" % xx.dtype
-                    )
+                    raise ValueError("Image RGB array must be uint8 or "
+                                     "floating point; found %s" % xx.dtype)
                 return xx
         except AttributeError:
             # e.g., x is not an ndarray; so try mapping it
@@ -524,9 +522,8 @@ def set_array(self, A):
 
         A = cbook.safe_masked_invalid(A, copy=True)
         if not np.can_cast(A.dtype, float, "same_kind"):
-            raise TypeError(
-                f"Image data of dtype {A.dtype} cannot be " "converted to float"
-            )
+            raise TypeError(f"Image data of dtype {A.dtype} cannot be "
+                            "converted to float")
 
         self._A = A
 
@@ -583,7 +580,7 @@ def get_alpha(self):
             Always returns 1.
         """
         # This method is intended to be overridden by Artist sub-classes
-        return 1.0
+        return 1.
 
     def set_cmap(self, cmap):
         """
@@ -627,7 +624,8 @@ def norm(self, norm):
         if not in_init:
             self.norm.callbacks.disconnect(self._id_norm)
         self._norm = norm
-        self._id_norm = self.norm.callbacks.connect("changed", self.changed)
+        self._id_norm = self.norm.callbacks.connect('changed',
+                                                    self.changed)
         if not in_init:
             self.changed()
 
@@ -653,7 +651,7 @@ def autoscale(self):
         current array
         """
         if self._A is None:
-            raise TypeError("You must first set_array for mappable")
+            raise TypeError('You must first set_array for mappable')
         # If the norm's limits are updated self.changed() will be called
         # through the callbacks attached to the norm
         self.norm.autoscale(self._A)
@@ -664,7 +662,7 @@ def autoscale_None(self):
         current array, changing only limits that are None
         """
         if self._A is None:
-            raise TypeError("You must first set_array for mappable")
+            raise TypeError('You must first set_array for mappable')
         # If the norm's limits are updated self.changed() will be called
         # through the callbacks attached to the norm
         self.norm.autoscale_None(self._A)
@@ -674,7 +672,7 @@ def changed(self):
         Call this whenever the mappable is changed to notify all the
         callbackSM listeners to the 'changed' signal.
         """
-        self.callbacks.process("changed", self)
+        self.callbacks.process('changed', self)
         self.stale = True