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:

"""

c1 = to_rgba_array(c1)

c2 = to_rgba_array(c2)

n1 = max(c1.shape[0], 1) # 'none' results in shape (0, 4), but is 1-elem

n2 = max(c2.shape[0], 1) # 'none' results in shape (0, 4), but is 1-elem

if n1 != n2:

raise ValueError('Different number of elements passed.')

# The following shape test is needed to correctly handle comparisons with

# 'none', which results in a shape (0, 4) array and thus cannot be tested

# via value comparison.

"""

# 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}")

# turn 2-D array into 1-D array

if isinstance(c, np.ndarray):

if c.ndim == 2 and c.shape[0] == 1:

c = c.reshape(-1)

# 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 np.iterable(alpha):

alpha = np.asarray(alpha).ravel()

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 np.iterable(alpha):

if c.shape[0] == 1 and alpha.shape[0] > 1:

c = np.tile(c, (alpha.shape[0], 1))

elif c.shape[0] != alpha.shape[0]:

raise ValueError("The number of colors must match the number"

" of alpha values if there are more than one"

" of each.")

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:

if np.iterable(alpha):

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

else:

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

except (ValueError, TypeError):

pass

if isinstance(c, str):

raise ValueError("Using a string of single character colors as "

"a color sequence is not supported. The colors can "

"be passed as an explicit list instead.")

if len(c) == 0:

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

else:

if np.iterable(alpha):

return np.array([to_rgba(cc, aa) for cc, aa in zip(c, alpha)])

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 = copy.copy(mpl.cm.get_cmap("{cmap.name}"))'

"""

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.

rgba = np.empty(shape=xa.shape + (4,), dtype=lut.dtype)

lut.take(xa, axis=0, mode='clip', out=rgba)

if alpha is not None:

if np.iterable(alpha):

alpha = np.asarray(alpha)

if alpha.shape != xa.shape:

raise ValueError("alpha is array-like but its shape"

" %s doesn't match that of X %s" %

(alpha.shape, xa.shape))

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

if bytes:

alpha = (alpha * 255).astype(np.uint8)

rgba[..., -1] = alpha

# If the "bad" color is all zeros, then ignore alpha input.

if (lut[-1] == 0).all() and np.any(mask_bad):

if np.iterable(mask_bad) and mask_bad.shape == xa.shape:

rgba[mask_bad] = (0, 0, 0, 0)

else:

rgba[..., :] = (0, 0, 0, 0)

if not np.iterable(X):

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 get_bad(self):

"""Get the color for masked values."""

if not self._isinit:

self._init()

return np.array(self._lut[self._i_bad])

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 get_under(self):

"""Get the color for low out-of-range values."""

if not self._isinit:

self._init()

return np.array(self._lut[self._i_under])

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

def get_over(self):

"""Get the color for high out-of-range values."""

if not self._isinit:

self._init()

return np.array(self._lut[self._i_over])

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

def set_extremes(self, *, bad=None, under=None, over=None):

"""

if bad is not None:

self.set_bad(bad)

if under is not None:

self.set_under(under)

if over is not None:

self.set_over(over)

def with_extremes(self, *, bad=None, under=None, over=None):

"""

new_cm = copy.copy(self)

new_cm.set_extremes(bad=bad, under=under, over=over)

return new_cm

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

"""Return whether the colormap is grayscale."""

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 colormap with *lutsize* entries."""

raise NotImplementedError()

def reversed(self, name=None):

"""

raise NotImplementedError()

def _repr_png_(self):

"""Generate a PNG representation of the Colormap."""

X = np.tile(np.linspace(0, 1, _REPR_PNG_SIZE[0]),

(_REPR_PNG_SIZE[1], 1))

pixels = self(X, bytes=True)

png_bytes = io.BytesIO()

title = self.name + ' colormap'

author = f'Matplotlib v{mpl.__version__}, https://matplotlib.org'

pnginfo = PngInfo()

pnginfo.add_text('Title', title)

pnginfo.add_text('Description', title)

pnginfo.add_text('Author', author)

pnginfo.add_text('Software', author)

Image.fromarray(pixels).save(png_bytes, format='png', pnginfo=pnginfo)

return png_bytes.getvalue()

def _repr_html_(self):

"""Generate an HTML representation of the Colormap."""

png_bytes = self._repr_png_()

png_base64 = base64.b64encode(png_bytes).decode('ascii')

def color_block(color):

hex_color = to_hex(color, keep_alpha=True)

return (f'<div title="{hex_color}" '

'style="display: inline-block; '

'width: 1em; height: 1em; '

'margin: 0; '

'vertical-align: middle; '

'border: 1px solid #555; '

f'background-color: {hex_color};"></div>')

return ('<div style="vertical-align: middle;">'

f'<strong>{self.name}</strong> '

'</div>'

'<div class="cmap"><img '

f'alt="{self.name} colormap" '

f'title="{self.name}" '

'style="border: 1px solid #555;" '

f'src="data:image/png;base64,{png_base64}"></div>'

'<div style="vertical-align: middle; '

f'max-width: {_REPR_PNG_SIZE[0]+2}px; '

'display: flex; justify-content: space-between;">'

'<div style="float: left;">'

f'{color_block(self.get_under())} under'

'</div>'

'<div style="margin: 0 auto; display: inline-block;">'

f'bad {color_block(self.get_bad())}'

'</div>'

'<div style="float: right;">'

f'over {color_block(self.get_over())}'

"""

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

super().__init__(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 colormap."""

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 colormap 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

"""