def parse(self, s, dpi=72, prop=None, *, _force_standard_ps_fonts=False):
"""
Parse the given math expression *s* at the given *dpi*. If *prop* is
provided, it is a `.FontProperties` object specifying the "default"
font to use in the math expression, used for all non-math text.
The results are cached, so multiple calls to `parse`
with the same expression should be fast.
"""
if _force_standard_ps_fonts:
_api.warn_deprecated(
"3.4",
removal="3.5",
message=(
"Mathtext using only standard PostScript fonts has "
"been likely to produce wrong output for a while, "
"has been deprecated in %(since)s and will be removed "
"in %(removal)s, after which ps.useafm will have no "
"effect on mathtext."
)
)
# lru_cache can't decorate parse() directly because the ps.useafm and
# mathtext.fontset rcParams also affect the parse (e.g. by affecting
# the glyph metrics).
return self._parse_cached(s, dpi, prop, _force_standard_ps_fonts)
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.")
def fix_style(s):
if isinstance(s, str):
s = style_alias.get(s, s)
if s in [
"seaborn",
"seaborn-bright",
"seaborn-colorblind",
"seaborn-dark",
"seaborn-darkgrid",
"seaborn-dark-palette",
"seaborn-deep",
"seaborn-muted",
"seaborn-notebook",
"seaborn-paper",
"seaborn-pastel",
"seaborn-poster",
"seaborn-talk",
"seaborn-ticks",
"seaborn-white",
"seaborn-whitegrid",
]:
_api.warn_deprecated(
"3.6",
message="The seaborn styles shipped by Matplotlib "
"are deprecated since %(since)s, as they no longer "
"correspond to the styles shipped by seaborn. However, "
"they will remain available as 'seaborn0.8-<style>'. "
"Alternatively, directly use the seaborn API instead.")
s = s.replace("seaborn", "seaborn0.8")
return s
def update_keymap(self, name, key, *args):
"""
Set the keymap to associate with the specified tool.
Parameters
----------
name : str
Name of the Tool.
key : str or list of str
Keys to associate with the tool.
"""
if name not in self._tools:
raise KeyError('%s not in Tools' % name)
self._remove_keys(name)
for key in [key, *args]:
if isinstance(key, str) and validate_stringlist(key) != [key]:
_api.warn_deprecated(
"3.3",
message="Passing a list of keys as a single "
"comma-separated string is deprecated since %(since)s and "
"support will be removed %(removal)s; pass keys as a list "
"of strings instead.")
key = validate_stringlist(key)
if isinstance(key, str):
key = [key]
for k in key:
if k in self._keys:
_api.warn_external(
f'Key {k} changed from {self._keys[k]} to {name}')
self._keys[k] = name
def __init__(self, axes_divider, nx, ny, nx1=None, ny1=None):
"""
Parameters
----------
axes_divider : AxesDivider
nx, nx1 : int
Integers specifying the column-position of the
cell. When *nx1* is None, a single *nx*-th column is
specified. Otherwise location of columns spanning between *nx*
to *nx1* (but excluding *nx1*-th column) is specified.
ny, ny1 : int
Same as *nx* and *nx1*, but for row positions.
"""
self._axes_divider = axes_divider
_xrefindex = axes_divider._xrefindex
_yrefindex = axes_divider._yrefindex
self._nx, self._ny = nx - _xrefindex, ny - _yrefindex
if nx1 is None:
_api.warn_deprecated(
"3.5", message="Support for passing nx1=None to mean nx+1 is "
"deprecated since %(since)s; in a future version, nx1=None "
"will mean 'up to the last cell'.")
nx1 = nx + 1
if ny1 is None:
_api.warn_deprecated(
"3.5", message="Support for passing ny1=None to mean ny+1 is "
"deprecated since %(since)s; in a future version, ny1=None "
"will mean 'up to the last cell'.")
ny1 = ny + 1
self._nx1 = nx1 - _xrefindex
self._ny1 = ny1 - _yrefindex
def subplot_class_factory(axes_class=None):
"""
Make a new class that inherits from `.SubplotBase` and the
given axes_class (which is assumed to be a subclass of `.axes.Axes`).
This is perhaps a little bit roundabout to make a new class on
the fly like this, but it means that a new Subplot class does
not have to be created for every type of Axes.
"""
if axes_class is None:
_api.warn_deprecated(
"3.3",
message="Support for passing None to subplot_class_factory "
"is deprecated since %(since)s; explicitly pass the default Axes "
"class instead. This will become an error %(removal)s.")
axes_class = Axes
try:
# Avoid creating two different instances of GeoAxesSubplot...
# Only a temporary backcompat fix. This should be removed in
# 3.4
return next(cls for cls in SubplotBase.__subclasses__()
if cls.__bases__ == (SubplotBase, axes_class))
except StopIteration:
# if we have already wrapped this class, declare victory!
if issubclass(axes_class, SubplotBase):
return axes_class
return type("%sSubplot" % axes_class.__name__,
(SubplotBase, axes_class), {'_axes_class': axes_class})
def get_text_width_height_descent(self, s, prop, ismath):
# docstring inherited
if ismath in ["TeX", "TeX!"]:
if ismath == "TeX!":
_api.warn_deprecated(
"3.3",
message="Support for ismath='TeX!' is deprecated "
"since %(since)s and will be removed %(removal)s; use "
"ismath='TeX' instead.")
# todo: handle props
texmanager = self.get_texmanager()
fontsize = prop.get_size_in_points()
w, h, d = texmanager.get_text_width_height_descent(s,
fontsize,
renderer=self)
return w, h, d
if ismath:
ox, oy, width, height, descent, fonts, used_characters = \
self.mathtext_parser.parse(s, self.dpi, prop)
return width, height, descent
flags = get_hinting_flag()
font = self._get_agg_font(prop)
font.set_text(s, 0.0, flags=flags)
w, h = font.get_width_height() # width and height of unrotated string
d = font.get_descent()
w /= 64.0 # convert from subpixels
h /= 64.0
d /= 64.0
return w, h, d
def locate(self, nx, ny, nx1=None, ny1=None, axes=None, renderer=None):
"""
Parameters
----------
nx, nx1 : int
Integers specifying the column-position of the
cell. When *nx1* is None, a single *nx*-th column is
specified. Otherwise location of columns spanning between *nx*
to *nx1* (but excluding *nx1*-th column) is specified.
ny, ny1 : int
Same as *nx* and *nx1*, but for row positions.
axes
renderer
"""
fig_w, fig_h = self._fig.bbox.size / self._fig.dpi
x, y, w, h = self.get_position_runtime(axes, renderer)
hsizes = self.get_horizontal_sizes(renderer)
vsizes = self.get_vertical_sizes(renderer)
k_h = self._calc_k(hsizes, fig_w * w)
k_v = self._calc_k(vsizes, fig_h * h)
if self.get_aspect():
k = min(k_h, k_v)
ox = self._calc_offsets(hsizes, k)
oy = self._calc_offsets(vsizes, k)
ww = (ox[-1] - ox[0]) / fig_w
hh = (oy[-1] - oy[0]) / fig_h
pb = mtransforms.Bbox.from_bounds(x, y, w, h)
pb1 = mtransforms.Bbox.from_bounds(x, y, ww, hh)
x0, y0 = pb1.anchored(self.get_anchor(), pb).p0
else:
ox = self._calc_offsets(hsizes, k_h)
oy = self._calc_offsets(vsizes, k_v)
x0, y0 = x, y
if nx1 is None:
_api.warn_deprecated(
"3.5",
message="Support for passing nx1=None to mean nx+1 is "
"deprecated since %(since)s; in a future version, nx1=None "
"will mean 'up to the last cell'.")
nx1 = nx + 1
if ny1 is None:
_api.warn_deprecated(
"3.5",
message="Support for passing ny1=None to mean ny+1 is "
"deprecated since %(since)s; in a future version, ny1=None "
"will mean 'up to the last cell'.")
ny1 = ny + 1
x1, w1 = x0 + ox[nx] / fig_w, (ox[nx1] - ox[nx]) / fig_w
y1, h1 = y0 + oy[ny] / fig_h, (oy[ny1] - oy[ny]) / fig_h
return mtransforms.Bbox.from_bounds(x1, y1, w1, h1)
def print_jpg(self, filename_or_obj, *args, pil_kwargs=None, **kwargs):
"""
Write the figure to a JPEG file.
Parameters
----------
filename_or_obj : str or path-like or file-like
The file to write to.
Other Parameters
----------------
quality : int, default: :rc:`savefig.jpeg_quality`
The image quality, on a scale from 1 (worst) to 95 (best).
Values above 95 should be avoided; 100 disables portions of
the JPEG compression algorithm, and results in large files
with hardly any gain in image quality. This parameter is
deprecated.
optimize : bool, default: False
Whether the encoder should make an extra pass over the image
in order to select optimal encoder settings. This parameter is
deprecated.
progressive : bool, default: False
Whether the image should be stored as a progressive JPEG file.
This parameter is deprecated.
pil_kwargs : dict, optional
Additional keyword arguments that are passed to
`PIL.Image.Image.save` when saving the figure. These take
precedence over *quality*, *optimize* and *progressive*.
"""
# Remove transparency by alpha-blending on an assumed white background.
r, g, b, a = mcolors.to_rgba(self.figure.get_facecolor())
try:
self.figure.set_facecolor(a * np.array([r, g, b]) + 1 - a)
FigureCanvasAgg.draw(self)
finally:
self.figure.set_facecolor((r, g, b, a))
if pil_kwargs is None:
pil_kwargs = {}
for k in ["quality", "optimize", "progressive"]:
if k in kwargs:
pil_kwargs.setdefault(k, kwargs.pop(k))
if "quality" not in pil_kwargs:
quality = pil_kwargs["quality"] = \
dict.__getitem__(mpl.rcParams, "savefig.jpeg_quality")
if quality not in [0, 75, 95]: # default qualities.
_api.warn_deprecated(
"3.3",
name="savefig.jpeg_quality",
obj_type="rcParam",
addendum="Set the quality using "
"`pil_kwargs={'quality': ...}`; the future default "
"quality will be 75, matching the default of Pillow and "
"libjpeg.")
pil_kwargs.setdefault("dpi", (self.figure.dpi, self.figure.dpi))
# Drop alpha channel now.
return (Image.fromarray(np.asarray(self.buffer_rgba())[..., :3]).save(
filename_or_obj, format='jpeg', **pil_kwargs))
def __init__(self, lines, arrows, **kwargs):
if kwargs:
_api.warn_deprecated(
"3.3",
message="Passing arbitrary keyword arguments to StreamplotSet "
"is deprecated since %(since) and will become an "
"error %(removal)s.")
self.lines = lines
self.arrows = arrows
def __getitem__(self, index):
if index != 0:
# Make HandlerLine2D return [self._legline] directly after
# deprecation elapses.
_api.warn_deprecated(
"3.5", message="Access to the second element returned by "
"HandlerLine2D is deprecated since %(since)s; it will be "
"removed %(removal)s.")
return [self._legline, self._legline][index]
def find_tex_file(filename, format=None):
try:
return (_find_tex_file(filename, format)
if format is not None else _find_tex_file(filename))
except FileNotFoundError as exc:
_api.warn_deprecated(
"3.6",
message=f"{exc.args[0]}; in the future, this will raise a "
f"FileNotFoundError.")
return ""
def mpl_test_settings(request):
from matplotlib.testing.decorators import _cleanup_cm
with _cleanup_cm():
backend = None
backend_marker = request.node.get_closest_marker('backend')
if backend_marker is not None:
assert len(backend_marker.args) == 1, \
"Marker 'backend' must specify 1 backend."
backend, = backend_marker.args
skip_on_importerror = backend_marker.kwargs.get(
'skip_on_importerror', False)
prev_backend = matplotlib.get_backend()
# special case Qt backend importing to avoid conflicts
if backend.lower().startswith('qt5'):
if any(sys.modules.get(k) for k in ('PyQt4', 'PySide')):
pytest.skip('Qt4 binding already imported')
# Default of cleanup and image_comparison too.
style = ["classic", "_classic_test_patch"]
style_marker = request.node.get_closest_marker('style')
if style_marker is not None:
assert len(style_marker.args) == 1, \
"Marker 'style' must specify 1 style."
_api.warn_deprecated("3.5",
name="style",
obj_type="pytest marker",
alternative="@mpl.style.context(...)")
style, = style_marker.args
matplotlib.testing.setup()
with _api.suppress_matplotlib_deprecation_warning():
if backend is not None:
# This import must come after setup() so it doesn't load the
# default backend prematurely.
import matplotlib.pyplot as plt
try:
plt.switch_backend(backend)
except ImportError as exc:
# Should only occur for the cairo backend tests, if neither
# pycairo nor cairocffi are installed.
if 'cairo' in backend.lower() or skip_on_importerror:
pytest.skip(
"Failed to switch to backend {} ({}).".format(
backend, exc))
else:
raise
matplotlib.style.use(style)
try:
yield
finally:
if backend is not None:
plt.switch_backend(prev_backend)
def __init__(self, size=None, weight='normal'):
self._version = self.__version__
self.__default_weight = weight
self.default_size = size
paths = [
cbook._get_data_path('fonts', subdir)
for subdir in ['ttf', 'afm', 'pdfcorefonts']
]
# Create list of font paths
for pathname in ['TTFPATH', 'AFMPATH']:
if pathname in os.environ:
ttfpath = os.environ[pathname]
if ttfpath.find(';') >= 0: # win32 style
paths.extend(ttfpath.split(';'))
elif ttfpath.find(':') >= 0: # unix style
paths.extend(ttfpath.split(':'))
else:
paths.append(ttfpath)
_api.warn_deprecated("3.3",
name=pathname,
obj_type="environment variable",
alternative="FontManager.addfont()")
_log.debug('font search path %s', str(paths))
# Load TrueType fonts and create font dictionary.
self.defaultFamily = {'ttf': 'DejaVu Sans', 'afm': 'Helvetica'}
self.afmlist = []
self.ttflist = []
# Delay the warning by 5s.
timer = Timer(
5, lambda: _log.warning(
'Matplotlib is building the font cache; this may take a moment.'
))
timer.start()
try:
for fontext in ["afm", "ttf"]:
for path in [
*findSystemFonts(paths, fontext=fontext),
*findSystemFonts(fontext=fontext)
]:
try:
self.addfont(path)
except OSError as exc:
_log.info("Failed to open font file %s: %s", path, exc)
except Exception as exc:
_log.info(
"Failed to extract font properties from %s: "
"%s", path, exc)
finally:
timer.cancel()
def parasite_axes_class_factory(axes_class=None):
if axes_class is None:
_api.warn_deprecated(
"3.3", message="Support for passing None to "
"parasite_axes_class_factory is deprecated since %(since)s and "
"will be removed %(removal)s; explicitly pass the default Axes "
"class instead.")
axes_class = Axes
return type("%sParasite" % axes_class.__name__,
(ParasiteAxesBase, axes_class), {})
def draw_path_collection(self, gc, master_transform, paths, all_transforms,
offsets, offsetTrans, facecolors, edgecolors,
linewidths, linestyles, antialiaseds, urls,
offset_position):
if offset_position == "data":
_api.warn_deprecated(
"3.3", message="Support for offset_position='data' is "
"deprecated since %(since)s and will be removed %(removal)s.")
return self._renderer.draw_path_collection(
gc, master_transform, paths, all_transforms, offsets, offsetTrans,
facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls,
offset_position)
def _validate_hatch_pattern(hatch):
valid_hatch_patterns = set(r'-+|/\xXoO.*')
if hatch is not None:
invalids = set(hatch).difference(valid_hatch_patterns)
if invalids:
valid = ''.join(sorted(valid_hatch_patterns))
invalids = ''.join(sorted(invalids))
_api.warn_deprecated(
'3.4',
message=f'hatch must consist of a string of "{valid}" or '
'None, but found the following invalid values '
f'"{invalids}". Passing invalid values is deprecated '
'since %(since)s and will become an error %(removal)s.'
)
def host_axes_class_factory(axes_class=None):
if axes_class is None:
_api.warn_deprecated(
"3.3", message="Support for passing None to host_axes_class is "
"deprecated since %(since)s and will be removed %(removed)s; "
"explicitly pass the default Axes class instead.")
axes_class = Axes
def _get_base_axes(self):
return axes_class
return type("%sHostAxes" % axes_class.__name__,
(HostAxesBase, axes_class),
{'_get_base_axes': _get_base_axes})
def __init__(self, bitmap, dpi):
"""Initialise a wxWindows renderer instance."""
_api.warn_deprecated(
"2.0", name="wx", obj_type="backend", removal="the future",
alternative="wxagg", addendum="See the Matplotlib usage FAQ for "
"more info on backends.")
super().__init__()
_log.debug("%s - __init__()", type(self))
self.width = bitmap.GetWidth()
self.height = bitmap.GetHeight()
self.bitmap = bitmap
self.fontd = {}
self.dpi = dpi
self.gc = None
def validator(s):
if (allow_none and
(s is None or isinstance(s, str) and s.lower() == "none")):
return None
if cls is str and not isinstance(s, str):
_api.warn_deprecated(
"3.5", message="Support for setting an rcParam that expects a "
"str value to a non-str value is deprecated since %(since)s "
"and support will be removed %(removal)s.")
try:
return cls(s)
except (TypeError, ValueError) as e:
raise ValueError(
f'Could not convert {s!r} to {cls.__name__}') from e
def new_vertical(self, size, pad=None, pack_start=False, **kwargs):
"""
Add a new axes on the top (or bottom) side of the main axes.
Parameters
----------
size : :mod:`~mpl_toolkits.axes_grid1.axes_size` or float or str
A height of the axes. If float or string is given, *from_any*
function is used to create the size, with *ref_size* set to AxesX
instance of the current axes.
pad : :mod:`~mpl_toolkits.axes_grid1.axes_size` or float or str
Pad between the axes. It takes same argument as *size*.
pack_start : bool
If False, the new axes is appended at the end
of the list, i.e., it became the right-most axes. If True, it is
inserted at the start of the list, and becomes the left-most axes.
**kwargs
All extra keywords arguments are passed to the created axes.
If *axes_class* is given, the new axes will be created as an
instance of the given class. Otherwise, the same class of the
main axes will be used.
"""
if pad is None:
_api.warn_deprecated(
"3.2",
message="In a future version, 'pad' will default to "
"rcParams['figure.subplot.hspace']. Set pad=0 to keep the "
"old behavior.")
if pad:
if not isinstance(pad, Size._Base):
pad = Size.from_any(pad, fraction_ref=self._yref)
if pack_start:
self._vertical.insert(0, pad)
self._yrefindex += 1
else:
self._vertical.append(pad)
if not isinstance(size, Size._Base):
size = Size.from_any(size, fraction_ref=self._yref)
if pack_start:
self._vertical.insert(0, size)
self._yrefindex += 1
locator = self.new_locator(nx=self._xrefindex, ny=0)
else:
self._vertical.append(size)
locator = self.new_locator(nx=self._xrefindex,
ny=len(self._vertical) - 1)
ax = self._get_new_axes(**kwargs)
ax.set_axes_locator(locator)
return ax
def parasite_axes_auxtrans_class_factory(axes_class=None):
if axes_class is None:
_api.warn_deprecated(
"3.3", message="Support for passing None to "
"parasite_axes_auxtrans_class_factory is deprecated since "
"%(since)s and will be removed %(removal)s; explicitly pass the "
"default ParasiteAxes class instead.")
parasite_axes_class = ParasiteAxes
elif not issubclass(axes_class, ParasiteAxesBase):
parasite_axes_class = parasite_axes_class_factory(axes_class)
else:
parasite_axes_class = axes_class
return type("%sParasiteAuxTrans" % parasite_axes_class.__name__,
(ParasiteAxesAuxTransBase, parasite_axes_class),
{'name': 'parasite_axes'})
def __init__(self, filename, *, keep_empty=True, metadata=None):
"""
Create a new PdfPages object.
Parameters
----------
filename : str or path-like
Plots using `PdfPages.savefig` will be written to a file at this
location. Any older file with the same name is overwritten.
keep_empty : bool, default: True
If set to False, then empty pdf files will be deleted automatically
when closed.
metadata : dict, optional
Information dictionary object (see PDF reference section 10.2.1
'Document Information Dictionary'), e.g.:
``{'Creator': 'My software', 'Author': 'Me', 'Title': 'Awesome'}``.
The standard keys are 'Title', 'Author', 'Subject', 'Keywords',
'Creator', 'Producer', 'CreationDate', 'ModDate', and
'Trapped'. Values have been predefined for 'Creator', 'Producer'
and 'CreationDate'. They can be removed by setting them to `None`.
Note that some versions of LaTeX engines may ignore the 'Producer'
key and set it to themselves.
"""
self._output_name = filename
self._n_figures = 0
self.keep_empty = keep_empty
self._metadata = (metadata or {}).copy()
if metadata:
for key in metadata:
canonical = {
'creationdate': 'CreationDate',
'moddate': 'ModDate',
}.get(key.lower(),
key.lower().title())
if canonical != key:
_api.warn_deprecated(
'3.3',
message='Support for setting PDF metadata keys '
'case-insensitively is deprecated since %(since)s and '
'will be removed %(removal)s; '
f'set {canonical} instead of {key}.')
self._metadata[canonical] = self._metadata.pop(key)
self._info_dict = _create_pdf_info_dict('pgf', self._metadata)
self._file = BytesIO()
def __call__(self, s):
if self._deprecated_since:
name, = (k for k, v in globals().items() if v is self)
_api.warn_deprecated(self._deprecated_since,
name=name,
obj_type="function")
if self.ignorecase:
s = s.lower()
if s in self.valid:
return self.valid[s]
msg = (f"{s!r} is not a valid value for {self.key}; supported values "
f"are {[*self.valid.values()]}")
if (isinstance(s, str) and (s.startswith('"') and s.endswith('"')
or s.startswith("'") and s.endswith("'"))
and s[1:-1] in self.valid):
msg += "; remove quotes surrounding your string"
raise ValueError(msg)
def scale_factory(scale, axis, **kwargs):
"""
Return a scale class by name.
Parameters
----------
scale : {%(names)s}
axis : `matplotlib.axis.Axis`
"""
if scale != scale.lower():
_api.warn_deprecated(
"3.5",
message="Support for case-insensitive scales is deprecated "
"since %(since)s and support will be removed %(removal)s.")
scale = scale.lower()
scale_cls = _api.check_getitem(_scale_mapping, scale=scale)
return scale_cls(axis, **kwargs)
def locate(self, nx, ny, nx1=None, ny1=None, axes=None, renderer=None):
# docstring inherited
fig_w, fig_h = self._fig.bbox.size / self._fig.dpi
x, y, w, h = self.get_position_runtime(axes, renderer)
summed_hs = self.get_vertical_sizes(renderer)
equal_ws = self.get_horizontal_sizes(renderer)
y0, x0, oy, ww = _locate(
y, x, h, w, summed_hs, equal_ws, fig_h, fig_w, self.get_anchor())
if ny1 is None:
_api.warn_deprecated(
"3.5", message="Support for passing ny1=None to mean ny+1 is "
"deprecated since %(since)s; in a future version, ny1=None "
"will mean 'up to the last cell'.")
ny1 = ny + 1
x1, w1 = x0, ww
y1, h1 = y0 + oy[ny] / fig_h, (oy[ny1] - oy[ny]) / fig_h
return mtransforms.Bbox.from_bounds(x1, y1, w1, h1)
def _from_subplot_args(figure, args):
"""
Construct a `.SubplotSpec` from a parent `.Figure` and either
- a `.SubplotSpec` -- returned as is;
- one or three numbers -- a MATLAB-style subplot specifier.
"""
message = ("Passing non-integers as three-element position "
"specification is deprecated since %(since)s and will be "
"removed %(removal)s.")
if len(args) == 1:
arg, = args
if isinstance(arg, SubplotSpec):
return arg
else:
if not isinstance(arg, Integral):
_api.warn_deprecated("3.3", message=message)
arg = str(arg)
try:
rows, cols, num = map(int, str(arg))
except ValueError:
raise ValueError(
f"Single argument to subplot must be a three-digit "
f"integer, not {arg}") from None
i = j = num
elif len(args) == 3:
rows, cols, num = args
if not (isinstance(rows, Integral) and isinstance(cols, Integral)):
_api.warn_deprecated("3.3", message=message)
rows, cols = map(int, [rows, cols])
gs = GridSpec(rows, cols, figure=figure)
if isinstance(num, tuple) and len(num) == 2:
if not all(isinstance(n, Integral) for n in num):
_api.warn_deprecated("3.3", message=message)
i, j = map(int, num)
else:
i, j = num
else:
if not isinstance(num, Integral):
_api.warn_deprecated("3.3", message=message)
num = int(num)
if num < 1 or num > rows * cols:
raise ValueError(
f"num must be 1 <= num <= {rows*cols}, not {num}")
i = j = num
else:
raise TypeError(f"subplot() takes 1 or 3 positional arguments but "
f"{len(args)} were given")
gs = GridSpec._check_gridspec_exists(figure, rows, cols)
if gs is None:
gs = GridSpec(rows, cols, figure=figure)
return gs[i - 1:j]
def convert(value, unit, axis):
"""
Convert strings in *value* to floats using mapping information stored
in the *unit* object.
Parameters
----------
value : str or iterable
Value or list of values to be converted.
unit : `.UnitData`
An object mapping strings to integers.
axis : `~matplotlib.axis.Axis`
The axis on which the converted value is plotted.
.. note:: *axis* is unused.
Returns
-------
float or ndarray[float]
"""
if unit is None:
raise ValueError(
'Missing category information for StrCategoryConverter; '
'this might be caused by unintendedly mixing categorical and '
'numeric data')
StrCategoryConverter._validate_unit(unit)
# dtype = object preserves numerical pass throughs
values = np.atleast_1d(np.array(value, dtype=object))
# pass through sequence of non binary numbers
with _api.suppress_matplotlib_deprecation_warning():
is_numlike = all(
units.ConversionInterface.is_numlike(v)
and not isinstance(v, (str, bytes)) for v in values)
if is_numlike:
_api.warn_deprecated(
"3.5",
message="Support for passing numbers through unit "
"converters is deprecated since %(since)s and support will be "
"removed %(removal)s; use Axis.convert_units instead.")
return np.asarray(values, dtype=float)
# force an update so it also does type checking
unit.update(values)
return np.vectorize(unit._mapping.__getitem__, otypes=[float])(values)
def __init__(self, num, fig, *, canvas_class=None):
# On non-Windows platform, explicitly set the position - fix
# positioning bug on some Linux platforms
if wx.Platform == '__WXMSW__':
pos = wx.DefaultPosition
else:
pos = wx.Point(20, 20)
super().__init__(parent=None, id=-1, pos=pos)
# Frame will be sized later by the Fit method
_log.debug("%s - __init__()", type(self))
_set_frame_icon(self)
# The parameter will become required after the deprecation elapses.
if canvas_class is not None:
self.canvas = canvas_class(self, -1, fig)
else:
_api.warn_deprecated(
"3.6",
message="The canvas_class parameter will become "
"required after the deprecation period starting in Matplotlib "
"%(since)s elapses.")
self.canvas = self.get_canvas(fig)
# Auto-attaches itself to self.canvas.manager
manager = FigureManagerWx(self.canvas, num, self)
toolbar = self.canvas.manager.toolbar
if toolbar is not None:
self.SetToolBar(toolbar)
# On Windows, canvas sizing must occur after toolbar addition;
# otherwise the toolbar further resizes the canvas.
w, h = map(math.ceil, fig.bbox.size)
self.canvas.SetInitialSize(wx.Size(w, h))
self.canvas.SetMinSize((2, 2))
self.canvas.SetFocus()
self.Fit()
self.Bind(wx.EVT_CLOSE, self._on_close)
def _scale_norm(self, norm, vmin, vmax):
"""
Helper for initial scaling.
Used by public functions that create a ScalarMappable and support
parameters *vmin*, *vmax* and *norm*. This makes sure that a *norm*
will take precedence over *vmin*, *vmax*.
Note that this method does not set the norm.
"""
if vmin is not None or vmax is not None:
self.set_clim(vmin, vmax)
if norm is not None:
_api.warn_deprecated(
"3.3",
message="Passing parameters norm and vmin/vmax "
"simultaneously is deprecated since %(since)s and "
"will become an error %(removal)s. Please pass "
"vmin/vmax directly to the norm when creating it.")
# always resolve the autoscaling so we have concrete limits
# rather than deferring to draw time.
self.autoscale_None()
