def __init__(self, mapping):

super().__init__(mapping)

self.cache = {}

def __setitem__(self, key, value):

super().__setitem__(key, value)

self.cache.clear()

def __delitem__(self, key):

super().__delitem__(key)

if ex is None:

return ex

try:

ret = ex.item()

except AttributeError:

ret = float(ex)

"""Return whether *c* can be interpreted as an RGB(A) color."""

# Special-case nth color syntax because it cannot be parsed during setup.

if _is_nth_color(c):

return True

try:

to_rgba(c)

except ValueError:

return False

else:

"""

# Special-case nth color syntax because it should not be cached.

if _is_nth_color(c):

from matplotlib import rcParams

prop_cycler = rcParams['axes.prop_cycle']

colors = prop_cycler.by_key().get('color', ['k'])

c = colors[int(c[1:]) % len(colors)]

try:

rgba = _colors_full_map.cache[c, alpha]

except (KeyError, TypeError): # Not in cache, or unhashable.

rgba = None

if rgba is None: # Suppress exception chaining of cache lookup failure.

rgba = _to_rgba_no_colorcycle(c, alpha)

try:

_colors_full_map.cache[c, alpha] = rgba

except TypeError:

pass

"""

orig_c = c

if c is np.ma.masked:

return (0., 0., 0., 0.)

if isinstance(c, str):

if c.lower() == "none":

return (0., 0., 0., 0.)

# Named color.

try:

# This may turn c into a non-string, so we check again below.

c = _colors_full_map[c]

except KeyError:

if len(orig_c) != 1:

try:

c = _colors_full_map[c.lower()]

except KeyError:

pass

if isinstance(c, str):

# hex color in #rrggbb format.

match = re.match(r"\A#[a-fA-F0-9]{6}\Z", c)

if match:

return (tuple(int(n, 16) / 255

for n in [c[1:3], c[3:5], c[5:7]])

+ (alpha if alpha is not None else 1.,))

# hex color in #rgb format, shorthand for #rrggbb.

match = re.match(r"\A#[a-fA-F0-9]{3}\Z", c)

if match:

return (tuple(int(n, 16) / 255

for n in [c[1]*2, c[2]*2, c[3]*2])

+ (alpha if alpha is not None else 1.,))

# hex color with alpha in #rrggbbaa format.

match = re.match(r"\A#[a-fA-F0-9]{8}\Z", c)

if match:

color = [int(n, 16) / 255

for n in [c[1:3], c[3:5], c[5:7], c[7:9]]]

if alpha is not None:

color[-1] = alpha

return tuple(color)

# hex color with alpha in #rgba format, shorthand for #rrggbbaa.

match = re.match(r"\A#[a-fA-F0-9]{4}\Z", c)

if match:

color = [int(n, 16) / 255

for n in [c[1]*2, c[2]*2, c[3]*2, c[4]*2]]

if alpha is not None:

color[-1] = alpha

return tuple(color)

# string gray.

try:

c = float(c)

except ValueError:

pass

else:

if not (0 <= c <= 1):

raise ValueError(

f"Invalid string grayscale value {orig_c!r}. "

f"Value must be within 0-1 range")

return c, c, c, alpha if alpha is not None else 1.

raise ValueError(f"Invalid RGBA argument: {orig_c!r}")

# tuple color.

if not np.iterable(c):

raise ValueError(f"Invalid RGBA argument: {orig_c!r}")

if len(c) not in [3, 4]:

raise ValueError("RGBA sequence should have length 3 or 4")

if not all(isinstance(x, Number) for x in c):

# Checks that don't work: `map(float, ...)`, `np.array(..., float)` and

# `np.array(...).astype(float)` would all convert "0.5" to 0.5.

raise ValueError(f"Invalid RGBA argument: {orig_c!r}")

# Return a tuple to prevent the cached value from being modified.

c = tuple(map(float, c))

if len(c) == 3 and alpha is None:

alpha = 1

if alpha is not None:

c = c[:3] + (alpha,)

if any(elem < 0 or elem > 1 for elem in c):

raise ValueError("RGBA values should be within 0-1 range")

"""

# Special-case inputs that are already arrays, for performance. (If the

# array has the wrong kind or shape, raise the error during one-at-a-time

# conversion.)

if (isinstance(c, np.ndarray) and c.dtype.kind in "if"

and c.ndim == 2 and c.shape[1] in [3, 4]):

mask = c.mask.any(axis=1) if np.ma.is_masked(c) else None

c = np.ma.getdata(c)

if c.shape[1] == 3:

result = np.column_stack([c, np.zeros(len(c))])

result[:, -1] = alpha if alpha is not None else 1.

elif c.shape[1] == 4:

result = c.copy()

if alpha is not None:

result[:, -1] = alpha

if mask is not None:

result[mask] = 0

if np.any((result < 0) | (result > 1)):

raise ValueError("RGBA values should be within 0-1 range")

return result

# Handle single values.

# Note that this occurs *after* handling inputs that are already arrays, as

# `to_rgba(c, alpha)` (below) is expensive for such inputs, due to the need

# to format the array in the ValueError message(!).

if cbook._str_lower_equal(c, "none"):

return np.zeros((0, 4), float)

try:

return np.array([to_rgba(c, alpha)], float)

except (ValueError, TypeError):

pass

# Convert one at a time.

if isinstance(c, str):

# Single string as color sequence.

# This is deprecated and will be removed in the future.

try:

result = np.array([to_rgba(cc, alpha) for cc in c])

except ValueError as err:

raise ValueError(

"'%s' is neither a valid single color nor a color sequence "

"consisting of single character color specifiers such as "

"'rgb'. Note also that the latter is deprecated." % c) from err

else:

cbook.warn_deprecated(

"3.2", message="Using a string of single character colors as "

"a color sequence is deprecated since %(since)s and will be "

"removed %(removal)s. Use an explicit list instead.")

return result

if len(c) == 0:

return np.zeros((0, 4), float)

else:

"""

c = to_rgba(c)

if not keep_alpha:

c = c[:3]

"""

colors = _colors_full_map

cache = _colors_full_map.cache

to_rgb = staticmethod(to_rgb)

to_rgba = staticmethod(to_rgba)

r"""

if callable(data):

xind = np.linspace(0, 1, N) ** gamma

lut = np.clip(np.array(data(xind), dtype=float), 0, 1)

return lut

try:

adata = np.array(data)

except Exception as err:

raise TypeError("data must be convertible to an array") from err

shape = adata.shape

if len(shape) != 2 or shape[1] != 3:

raise ValueError("data must be nx3 format")

x = adata[:, 0]

y0 = adata[:, 1]

y1 = adata[:, 2]

if x[0] != 0. or x[-1] != 1.0:

raise ValueError(

"data mapping points must start with x=0 and end with x=1")

if (np.diff(x) < 0).any():

raise ValueError("data mapping points must have x in increasing order")

# begin generation of lookup table

if N == 1:

# convention: use the y = f(x=1) value for a 1-element lookup table

lut = np.array(y0[-1])

else:

x = x * (N - 1)

xind = (N - 1) * np.linspace(0, 1, N) ** gamma

ind = np.searchsorted(x, xind)[1:-1]

distance = (xind[1:-1] - x[ind - 1]) / (x[ind] - x[ind - 1])

lut = np.concatenate([

[y1[0]],

distance * (y0[ind] - y1[ind - 1]) + y1[ind - 1],

[y0[-1]],

])

# ensure that the lut is confined to values between 0 and 1 by clipping it

if getattr(cmap, '_global', False):

cbook.warn_deprecated(

"3.3",

message="You are modifying the state of a globally registered "

"colormap. In future versions, 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()"

"""

def __init__(self, name, N=256):

"""

self.name = name

self.N = int(N) # ensure that N is always int

self._rgba_bad = (0.0, 0.0, 0.0, 0.0) # If bad, don't paint anything.

self._rgba_under = None

self._rgba_over = None

self._i_under = self.N

self._i_over = self.N + 1

self._i_bad = self.N + 2

self._isinit = False

#: When this colormap exists on a scalar mappable and colorbar_extend

#: is not False, colorbar creation will pick up ``colorbar_extend`` as

#: the default value for the ``extend`` keyword in the

#: `matplotlib.colorbar.Colorbar` constructor.

self.colorbar_extend = False

def __call__(self, X, alpha=None, bytes=False):

"""

if not self._isinit:

self._init()

mask_bad = X.mask if np.ma.is_masked(X) else np.isnan(X) # Mask nan's.

xa = np.array(X, copy=True)

if not xa.dtype.isnative:

xa = xa.byteswap().newbyteorder() # Native byteorder is faster.

if xa.dtype.kind == "f":

with np.errstate(invalid="ignore"):

xa *= self.N

# Negative values are out of range, but astype(int) would

# truncate them towards zero.

xa[xa < 0] = -1

# xa == 1 (== N after multiplication) is not out of range.

xa[xa == self.N] = self.N - 1

# Avoid converting large positive values to negative integers.

np.clip(xa, -1, self.N, out=xa)

xa = xa.astype(int)

# Set the over-range indices before the under-range;

# otherwise the under-range values get converted to over-range.

xa[xa > self.N - 1] = self._i_over

xa[xa < 0] = self._i_under

xa[mask_bad] = self._i_bad

if bytes:

lut = (self._lut * 255).astype(np.uint8)

else:

lut = self._lut.copy() # Don't let alpha modify original _lut.

if alpha is not None:

alpha = np.clip(alpha, 0, 1)

if bytes:

alpha = int(alpha * 255)

if (lut[-1] == 0).all():

lut[:-1, -1] = alpha

# All zeros is taken as a flag for the default bad

# color, which is no color--fully transparent. We

# don't want to override this.

else:

lut[:, -1] = alpha

# If the bad value is set to have a color, then we

# override its alpha just as for any other value.

rgba = lut[xa]

if not np.iterable(X):

# Return a tuple if the input was a scalar

rgba = tuple(rgba)

return rgba

def __copy__(self):

cls = self.__class__

cmapobject = cls.__new__(cls)

cmapobject.__dict__.update(self.__dict__)

if self._isinit:

cmapobject._lut = np.copy(self._lut)

cmapobject._global = False

return cmapobject

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()

def set_under(self, color='k', alpha=None):

"""

_warn_if_global_cmap_modified(self)

self._rgba_under = to_rgba(color, alpha)

if self._isinit:

self._set_extremes()

def set_over(self, color='k', alpha=None):

"""

_warn_if_global_cmap_modified(self)

self._rgba_over = to_rgba(color, alpha)

if self._isinit:

self._set_extremes()

def _set_extremes(self):

if self._rgba_under:

self._lut[self._i_under] = self._rgba_under

else:

self._lut[self._i_under] = self._lut[0]

if self._rgba_over:

self._lut[self._i_over] = self._rgba_over

else:

self._lut[self._i_over] = self._lut[self.N - 1]

self._lut[self._i_bad] = self._rgba_bad

def _init(self):

"""Generate the lookup table, ``self._lut``."""

raise NotImplementedError("Abstract class only")

def is_gray(self):

if not self._isinit:

self._init()

return (np.all(self._lut[:, 0] == self._lut[:, 1]) and

np.all(self._lut[:, 0] == self._lut[:, 2]))

def _resample(self, lutsize):

"""Return a new color map with *lutsize* entries."""

raise NotImplementedError()

def reversed(self, name=None):

"""

"""

def __init__(self, name, segmentdata, N=256, gamma=1.0):

"""

# True only if all colors in map are identical; needed for contouring.

self.monochrome = False

Colormap.__init__(self, name, N)

self._segmentdata = segmentdata

self._gamma = gamma

def _init(self):

self._lut = np.ones((self.N + 3, 4), float)

self._lut[:-3, 0] = _create_lookup_table(

self.N, self._segmentdata['red'], self._gamma)

self._lut[:-3, 1] = _create_lookup_table(

self.N, self._segmentdata['green'], self._gamma)

self._lut[:-3, 2] = _create_lookup_table(

self.N, self._segmentdata['blue'], self._gamma)

if 'alpha' in self._segmentdata:

self._lut[:-3, 3] = _create_lookup_table(

self.N, self._segmentdata['alpha'], 1)

self._isinit = True

self._set_extremes()

def set_gamma(self, gamma):

"""Set a new gamma value and regenerate color map."""

self._gamma = gamma

self._init()

@staticmethod

def from_list(name, colors, N=256, gamma=1.0):

"""

if not np.iterable(colors):

raise ValueError('colors must be iterable')

if (isinstance(colors[0], Sized) and len(colors[0]) == 2

and not isinstance(colors[0], str)):

# List of value, color pairs

vals, colors = zip(*colors)

else:

vals = np.linspace(0, 1, len(colors))

cdict = dict(red=[], green=[], blue=[], alpha=[])

for val, color in zip(vals, colors):

r, g, b, a = to_rgba(color)

cdict['red'].append((val, r, r))

cdict['green'].append((val, g, g))

cdict['blue'].append((val, b, b))

cdict['alpha'].append((val, a, a))

return LinearSegmentedColormap(name, cdict, N, gamma)

def _resample(self, lutsize):

"""Return a new color map with *lutsize* entries."""

new_cmap = LinearSegmentedColormap(self.name, self._segmentdata,

lutsize)

new_cmap._rgba_over = self._rgba_over

new_cmap._rgba_under = self._rgba_under

new_cmap._rgba_bad = self._rgba_bad

return new_cmap

# Helper ensuring picklability of the reversed cmap.

@staticmethod

def _reverser(func, x):

return func(1 - x)

def reversed(self, name=None):

"""

if name is None:

name = self.name + "_r"

# Using a partial object keeps the cmap picklable.

data_r = {key: (functools.partial(self._reverser, data)

if callable(data) else

[(1.0 - x, y1, y0) for x, y0, y1 in reversed(data)])

for key, data in self._segmentdata.items()}

new_cmap = LinearSegmentedColormap(name, data_r, self.N, self._gamma)

# Reverse the over/under values too

new_cmap._rgba_over = self._rgba_under

new_cmap._rgba_under = self._rgba_over

new_cmap._rgba_bad = self._rgba_bad

"""

def __init__(self, colors, name='from_list', N=None):

self.monochrome = False # Are all colors identical? (for contour.py)

if N is None:

self.colors = colors

N = len(colors)

else:

if isinstance(colors, str):

self.colors = [colors] * N

self.monochrome = True

elif np.iterable(colors):

if len(colors) == 1:

self.monochrome = True

self.colors = list(

itertools.islice(itertools.cycle(colors), N))

else:

try:

gray = float(colors)

except TypeError:

pass

else:

self.colors = [gray] * N

self.monochrome = True

Colormap.__init__(self, name, N)

def _init(self):

self._lut = np.zeros((self.N + 3, 4), float)

self._lut[:-3] = to_rgba_array(self.colors)

self._isinit = True

self._set_extremes()

def _resample(self, lutsize):

"""Return a new color map with *lutsize* entries."""

colors = self(np.linspace(0, 1, lutsize))

new_cmap = ListedColormap(colors, name=self.name)

# Keep the over/under values too

new_cmap._rgba_over = self._rgba_over

new_cmap._rgba_under = self._rgba_under

new_cmap._rgba_bad = self._rgba_bad

return new_cmap

def reversed(self, name=None):

"""

if name is None:

name = self.name + "_r"

colors_r = list(reversed(self.colors))

new_cmap = ListedColormap(colors_r, name=name, N=self.N)

# Reverse the over/under values too

new_cmap._rgba_over = self._rgba_under

new_cmap._rgba_under = self._rgba_over

new_cmap._rgba_bad = self._rgba_bad

"""

def __init__(self, vmin=None, vmax=None, clip=False):

"""

self.vmin = _sanitize_extrema(vmin)

self.vmax = _sanitize_extrema(vmax)

self.clip = clip

@staticmethod

def process_value(value):

"""

is_scalar = not np.iterable(value)

if is_scalar:

value = [value]

dtype = np.min_scalar_type(value)

if np.issubdtype(dtype, np.integer) or dtype.type is np.bool_:

# bool_/int8/int16 -> float32; int32/int64 -> float64

dtype = np.promote_types(dtype, np.float32)

# ensure data passed in as an ndarray subclass are interpreted as