"""

@cbook._delete_parameter("3.3", "label")

def __init__(self, axes, loc, label=None,

size=None, # points

width=None,

color=None,

tickdir=None,

pad=None,

labelsize=None,

labelcolor=None,

zorder=None,

gridOn=None, # defaults to axes.grid depending on

# axes.grid.which

tick1On=True,

tick2On=True,

label1On=True,

label2On=False,

major=True,

labelrotation=0,

grid_color=None,

grid_linestyle=None,

grid_linewidth=None,

grid_alpha=None,

**kw # Other Line2D kwargs applied to gridlines.

):

"""

martist.Artist.__init__(self)

if gridOn is None:

if major and (mpl.rcParams['axes.grid.which']

in ('both', 'major')):

gridOn = mpl.rcParams['axes.grid']

elif (not major) and (mpl.rcParams['axes.grid.which']

in ('both', 'minor')):

gridOn = mpl.rcParams['axes.grid']

else:

gridOn = False

self.set_figure(axes.figure)

self.axes = axes

name = self.__name__.lower()

self._loc = loc

self._major = major

major_minor = "major" if major else "minor"

if size is None:

size = mpl.rcParams[f"{name}.{major_minor}.size"]

self._size = size

if width is None:

width = mpl.rcParams[f"{name}.{major_minor}.width"]

self._width = width

if color is None:

color = mpl.rcParams[f"{name}.color"]

if pad is None:

pad = mpl.rcParams[f"{name}.{major_minor}.pad"]

self._base_pad = pad

if labelcolor is None:

labelcolor = mpl.rcParams[f"{name}.color"]

if labelsize is None:

labelsize = mpl.rcParams[f"{name}.labelsize"]

self._set_labelrotation(labelrotation)

if zorder is None:

if major:

zorder = mlines.Line2D.zorder + 0.01

else:

zorder = mlines.Line2D.zorder

self._zorder = zorder

if grid_color is None:

grid_color = mpl.rcParams["grid.color"]

if grid_linestyle is None:

grid_linestyle = mpl.rcParams["grid.linestyle"]

if grid_linewidth is None:

grid_linewidth = mpl.rcParams["grid.linewidth"]

if grid_alpha is None:

grid_alpha = mpl.rcParams["grid.alpha"]

grid_kw = {k[5:]: v for k, v in kw.items()}

self.apply_tickdir(tickdir)

self.tick1line = mlines.Line2D(

[], [],

color=color, linestyle="none", zorder=zorder, visible=tick1On,

markeredgecolor=color, markersize=size, markeredgewidth=width,

)

self.tick2line = mlines.Line2D(

[], [],

color=color, linestyle="none", zorder=zorder, visible=tick2On,

markeredgecolor=color, markersize=size, markeredgewidth=width,

)

self.gridline = mlines.Line2D(

[], [],

color=grid_color, alpha=grid_alpha, visible=gridOn,

linestyle=grid_linestyle, linewidth=grid_linewidth, marker="",

**grid_kw,

)

self.gridline.get_path()._interpolation_steps = \

GRIDLINE_INTERPOLATION_STEPS

self.label1 = mtext.Text(

np.nan, np.nan,

fontsize=labelsize, color=labelcolor, visible=label1On)

self.label2 = mtext.Text(

np.nan, np.nan,

fontsize=labelsize, color=labelcolor, visible=label2On)

for meth, attr in [("_get_tick1line", "tick1line"),

("_get_tick2line", "tick2line"),

("_get_gridline", "gridline"),

("_get_text1", "label1"),

("_get_text2", "label2")]:

overridden_method = cbook._deprecate_method_override(

getattr(__class__, meth), self, since="3.3", message="Relying "

f"on {meth} to initialize Tick.{attr} is deprecated since "

f"%(since)s and will not work %(removal)s; please directly "

f"set the attribute in the subclass' __init__ instead.")

if overridden_method:

setattr(self, attr, overridden_method())

for artist in [self.tick1line, self.tick2line, self.gridline,

self.label1, self.label2]:

self._set_artist_props(artist)

self.update_position(loc)

@property

@cbook.deprecated("3.1", alternative="Tick.label1", pending=True)

def label(self):

return self.label1

def _set_labelrotation(self, labelrotation):

if isinstance(labelrotation, str):

mode = labelrotation

angle = 0

elif isinstance(labelrotation, (tuple, list)):

mode, angle = labelrotation

else:

mode = 'default'

angle = labelrotation

cbook._check_in_list(['auto', 'default'], labelrotation=mode)

self._labelrotation = (mode, angle)

def apply_tickdir(self, tickdir):

"""Calculate ``self._pad`` and ``self._tickmarkers``."""

def get_tickdir(self):

return self._tickdir

def get_tick_padding(self):

"""Get the length of the tick outside of the axes."""

padding = {

'in': 0.0,

'inout': 0.5,

'out': 1.0

}

return self._size * padding[self._tickdir]

def get_children(self):

children = [self.tick1line, self.tick2line,

self.gridline, self.label1, self.label2]

return children

def set_clip_path(self, clippath, transform=None):

# docstring inherited

martist.Artist.set_clip_path(self, clippath, transform)

self.gridline.set_clip_path(clippath, transform)

self.stale = True

def get_pad_pixels(self):

return self.figure.dpi * self._base_pad / 72

def contains(self, mouseevent):

"""

inside, info = self._default_contains(mouseevent)

if inside is not None:

return inside, info

return False, {}

def set_pad(self, val):

"""

self._apply_params(pad=val)

self.stale = True

def get_pad(self):

"""Get the value of the tick label pad in points."""

return self._base_pad

def _get_text1(self):

"""Get the default Text 1 instance."""

def _get_text2(self):

"""Get the default Text 2 instance."""

def _get_tick1line(self):

"""Get the default line2D instance for tick1."""

def _get_tick2line(self):

"""Get the default line2D instance for tick2."""

def _get_gridline(self):

"""Get the default grid Line2d instance for this tick."""

def get_loc(self):

"""Return the tick location (data coords) as a scalar."""

return self._loc

@martist.allow_rasterization

def draw(self, renderer):

if not self.get_visible():

self.stale = False

return

renderer.open_group(self.__name__, gid=self.get_gid())

for artist in [self.gridline, self.tick1line, self.tick2line,

self.label1, self.label2]:

artist.draw(renderer)

renderer.close_group(self.__name__)

self.stale = False

def set_label1(self, s):

"""

self.label1.set_text(s)

self.stale = True

set_label = set_label1

def set_label2(self, s):

"""

self.label2.set_text(s)

self.stale = True

def _set_artist_props(self, a):

a.set_figure(self.figure)

def get_view_interval(self):

"""

raise NotImplementedError('Derived must override')

def _apply_params(self, **kw):

for name, target in [("gridOn", self.gridline),

("tick1On", self.tick1line),

("tick2On", self.tick2line),

("label1On", self.label1),

("label2On", self.label2)]:

if name in kw:

target.set_visible(kw.pop(name))

if any(k in kw for k in ['size', 'width', 'pad', 'tickdir']):

self._size = kw.pop('size', self._size)

# Width could be handled outside this block, but it is

# convenient to leave it here.

self._width = kw.pop('width', self._width)

self._base_pad = kw.pop('pad', self._base_pad)

# apply_tickdir uses _size and _base_pad to make _pad,

# and also makes _tickmarkers.

self.apply_tickdir(kw.pop('tickdir', self._tickdir))

self.tick1line.set_marker(self._tickmarkers[0])

self.tick2line.set_marker(self._tickmarkers[1])

for line in (self.tick1line, self.tick2line):

line.set_markersize(self._size)

line.set_markeredgewidth(self._width)

# _get_text1_transform uses _pad from apply_tickdir.

trans = self._get_text1_transform()[0]

self.label1.set_transform(trans)

trans = self._get_text2_transform()[0]

self.label2.set_transform(trans)

tick_kw = {k: v for k, v in kw.items() if k in ['color', 'zorder']}

if 'color' in kw:

tick_kw['markeredgecolor'] = kw['color']

self.tick1line.set(**tick_kw)

self.tick2line.set(**tick_kw)

for k, v in tick_kw.items():

setattr(self, '_' + k, v)

if 'labelrotation' in kw:

self._set_labelrotation(kw.pop('labelrotation'))

self.label1.set(rotation=self._labelrotation[1])

self.label2.set(rotation=self._labelrotation[1])

label_kw = {k[5:]: v for k, v in kw.items()

if k in ['labelsize', 'labelcolor']}

self.label1.set(**label_kw)

self.label2.set(**label_kw)

for k, v in label_kw.items():

# for labelsize the text objects covert str ('small')

# -> points. grab the integer from the `Text` object

# instead of saving the string representation

v = getattr(self.label1, 'get_' + k)()

setattr(self, '_label' + k, v)

grid_kw = {k[5:]: v for k, v in kw.items()

if k in _gridline_param_names}

self.gridline.set(**grid_kw)

for k, v in grid_kw.items():

setattr(self, '_grid_' + k, v)

def update_position(self, loc):

"""Set the location of tick in data coords with scalar *loc*."""

raise NotImplementedError('Derived must override')

def _get_text1_transform(self):

raise NotImplementedError('Derived must override')

def _get_text2_transform(self):

"""

__name__ = 'xtick'

def __init__(self, *args, **kwargs):

super().__init__(*args, **kwargs)

# x in data coords, y in axes coords

self.tick1line.set(

xdata=[0], ydata=[0],

transform=self.axes.get_xaxis_transform(which="tick1"),

marker=self._tickmarkers[0],

)

self.tick2line.set(

xdata=[0], ydata=[1],

transform=self.axes.get_xaxis_transform(which="tick2"),

marker=self._tickmarkers[1],

)

self.gridline.set(

xdata=[0, 0], ydata=[0, 1],

transform=self.axes.get_xaxis_transform(which="grid"),

)

# the y loc is 3 points below the min of y axis

trans, va, ha = self._get_text1_transform()

self.label1.set(

x=0, y=0,

verticalalignment=va, horizontalalignment=ha, transform=trans,

)

trans, va, ha = self._get_text2_transform()

self.label2.set(

x=0, y=1,

verticalalignment=va, horizontalalignment=ha, transform=trans,

)

def _get_text1_transform(self):

return self.axes.get_xaxis_text1_transform(self._pad)

def _get_text2_transform(self):

return self.axes.get_xaxis_text2_transform(self._pad)

def apply_tickdir(self, tickdir):

"""Set tick direction. Valid values are 'in', 'out', 'inout'."""

if tickdir is None:

tickdir = mpl.rcParams['%s.direction' % self.__name__.lower()]

cbook._check_in_list(['in', 'out', 'inout'], tickdir=tickdir)

self._tickdir = tickdir

if self._tickdir == 'in':

self._tickmarkers = (mlines.TICKUP, mlines.TICKDOWN)

elif self._tickdir == 'inout':

self._tickmarkers = ('|', '|')

else:

self._tickmarkers = (mlines.TICKDOWN, mlines.TICKUP)

self._pad = self._base_pad + self.get_tick_padding()

self.stale = True

def update_position(self, loc):

"""Set the location of tick in data coords with scalar *loc*."""

self.tick1line.set_xdata((loc,))

self.tick2line.set_xdata((loc,))

self.gridline.set_xdata((loc,))

self.label1.set_x(loc)

self.label2.set_x(loc)

self._loc = loc

self.stale = True

def get_view_interval(self):

# docstring inherited

"""

__name__ = 'ytick'

def __init__(self, *args, **kwargs):

super().__init__(*args, **kwargs)

# x in axes coords, y in data coords

self.tick1line.set(

xdata=[0], ydata=[0],

transform=self.axes.get_yaxis_transform(which="tick1"),

marker=self._tickmarkers[0],

)

self.tick2line.set(

xdata=[1], ydata=[0],

transform=self.axes.get_yaxis_transform(which="tick2"),

marker=self._tickmarkers[1],

)

self.gridline.set(

xdata=[0, 1], ydata=[0, 0],

transform=self.axes.get_yaxis_transform(which="grid"),

)

# the y loc is 3 points below the min of y axis

trans, va, ha = self._get_text1_transform()

self.label1.set(

x=0, y=0,

verticalalignment=va, horizontalalignment=ha, transform=trans,

)

trans, va, ha = self._get_text2_transform()

self.label2.set(

x=1, y=0,

verticalalignment=va, horizontalalignment=ha, transform=trans,

)

def _get_text1_transform(self):

return self.axes.get_yaxis_text1_transform(self._pad)

def _get_text2_transform(self):

return self.axes.get_yaxis_text2_transform(self._pad)

def apply_tickdir(self, tickdir):

if tickdir is None:

tickdir = mpl.rcParams['%s.direction' % self.__name__.lower()]

self._tickdir = tickdir

if self._tickdir == 'in':

self._tickmarkers = (mlines.TICKRIGHT, mlines.TICKLEFT)

elif self._tickdir == 'inout':

self._tickmarkers = ('_', '_')

else:

self._tickmarkers = (mlines.TICKLEFT, mlines.TICKRIGHT)

self._pad = self._base_pad + self.get_tick_padding()

self.stale = True

def update_position(self, loc):

"""Set the location of tick in data coords with scalar *loc*."""

self.tick1line.set_ydata((loc,))

self.tick2line.set_ydata((loc,))

self.gridline.set_ydata((loc,))

self.label1.set_y(loc)

self.label2.set_y(loc)

self._loc = loc

self.stale = True

def get_view_interval(self):

# docstring inherited

"""

def __init__(self):

self._locator = None

self._formatter = None

@property

def locator(self):

return self._locator

@locator.setter

def locator(self, locator):

if not isinstance(locator, mticker.Locator):

cbook.warn_deprecated(

"3.2", message="Support for locators that do not subclass "

"matplotlib.ticker.Locator is deprecated since %(since)s and "

"support for them will be removed %(removal)s.")

self._locator = locator

@property

def formatter(self):

return self._formatter

@formatter.setter

def formatter(self, formatter):

if not isinstance(formatter, mticker.Formatter):

cbook.warn_deprecated(

"3.2", message="Support for formatters that do not subclass "

"matplotlib.ticker.Formatter is deprecated since %(since)s "

"and support for them will be removed %(removal)s.")

"""

def __init__(self, major):

self._major = major

def __get__(self, instance, cls):

if instance is None:

return self

else:

# instance._get_tick() can itself try to access the majorTicks

# attribute (e.g. in certain projection classes which override

# e.g. get_xaxis_text1_transform). In order to avoid infinite

# recursion, first set the majorTicks on the instance to an empty

# list, then create the tick and append it.

if self._major:

instance.majorTicks = []

tick = instance._get_tick(major=True)

instance.majorTicks.append(tick)

return instance.majorTicks

else:

instance.minorTicks = []

tick = instance._get_tick(major=False)

instance.minorTicks.append(tick)

"""

OFFSETTEXTPAD = 3

def __str__(self):

return "{}({},{})".format(

type(self).__name__, *self.axes.transAxes.transform((0, 0)))

def __init__(self, axes, pickradius=15):

"""

martist.Artist.__init__(self)

self._remove_overlapping_locs = True

self.set_figure(axes.figure)

self.isDefault_label = True

self.axes = axes

self.major = Ticker()

self.minor = Ticker()

self.callbacks = cbook.CallbackRegistry()

self._autolabelpos = True

self._smart_bounds = False # Deprecated in 3.2

self.label = mtext.Text(

np.nan, np.nan,

fontsize=mpl.rcParams['axes.labelsize'],

fontweight=mpl.rcParams['axes.labelweight'],

color=mpl.rcParams['axes.labelcolor'],

)

self._set_artist_props(self.label)

self.offsetText = mtext.Text(np.nan, np.nan)

self._set_artist_props(self.offsetText)

self.labelpad = mpl.rcParams['axes.labelpad']

self.pickradius = pickradius

# Initialize here for testing; later add API

self._major_tick_kw = dict()

self._minor_tick_kw = dict()

self.cla()

self._set_scale('linear')

# During initialization, Axis objects often create ticks that are later

# unused; this turns out to be a very slow step. Instead, use a custom

# descriptor to make the tick lists lazy and instantiate them as needed.

majorTicks = _LazyTickList(major=True)

minorTicks = _LazyTickList(major=False)

def get_remove_overlapping_locs(self):

return self._remove_overlapping_locs

def set_remove_overlapping_locs(self, val):

self._remove_overlapping_locs = bool(val)

remove_overlapping_locs = property(

get_remove_overlapping_locs, set_remove_overlapping_locs,

doc=('If minor ticker locations that overlap with major '

'ticker locations should be trimmed.'))

def set_label_coords(self, x, y, transform=None):

"""

self._autolabelpos = False

if transform is None:

transform = self.axes.transAxes

self.label.set_transform(transform)

self.label.set_position((x, y))

self.stale = True

def get_transform(self):

return self._scale.get_transform()

def get_scale(self):

"""Return this Axis' scale (as a str)."""

return self._scale.name

def _set_scale(self, value, **kwargs):

self._scale = mscale.scale_factory(value, self, **kwargs)

self._scale.set_default_locators_and_formatters(self)

self.isDefault_majloc = True

self.isDefault_minloc = True

self.isDefault_majfmt = True

self.isDefault_minfmt = True

def limit_range_for_scale(self, vmin, vmax):

return self._scale.limit_range_for_scale(vmin, vmax, self.get_minpos())

def get_children(self):

return [self.label, self.offsetText,

*self.get_major_ticks(), *self.get_minor_ticks()]

def cla(self):

"""Clear this axis."""

self.label.set_text('') # self.set_label_text would change isDefault_

self._set_scale('linear')

# Clear the callback registry for this axis, or it may "leak"

self.callbacks = cbook.CallbackRegistry()

# whether the grids are on

self._gridOnMajor = (

mpl.rcParams['axes.grid'] and

mpl.rcParams['axes.grid.which'] in ('both', 'major'))

self._gridOnMinor = (

mpl.rcParams['axes.grid'] and

mpl.rcParams['axes.grid.which'] in ('both', 'minor'))

self.reset_ticks()

self.converter = None

self.units = None

self.set_units(None)

self.stale = True

def reset_ticks(self):

"""

# Restore the lazy tick lists.

try:

del self.majorTicks

except AttributeError:

pass

try:

del self.minorTicks

except AttributeError:

pass

try:

self.set_clip_path(self.axes.patch)

except AttributeError:

pass

def set_tick_params(self, which='major', reset=False, **kw):

"""

cbook._check_in_list(['major', 'minor', 'both'], which=which)

kwtrans = self._translate_tick_kw(kw)

# the kwargs are stored in self._major/minor_tick_kw so that any

# future new ticks will automatically get them

if reset:

if which in ['major', 'both']:

self._major_tick_kw.clear()

self._major_tick_kw.update(kwtrans)

if which in ['minor', 'both']:

self._minor_tick_kw.clear()

self._minor_tick_kw.update(kwtrans)

self.reset_ticks()

else:

if which in ['major', 'both']:

self._major_tick_kw.update(kwtrans)

for tick in self.majorTicks:

tick._apply_params(**kwtrans)

if which in ['minor', 'both']:

self._minor_tick_kw.update(kwtrans)

for tick in self.minorTicks:

tick._apply_params(**kwtrans)

# labelOn and labelcolor also apply to the offset text.

if 'label1On' in kwtrans or 'label2On' in kwtrans:

self.offsetText.set_visible(

self._major_tick_kw.get('label1On', False)

or self._major_tick_kw.get('label2On', False))

if 'labelcolor' in kwtrans:

self.offsetText.set_color(kwtrans['labelcolor'])

self.stale = True

@staticmethod

def _translate_tick_kw(kw):

# The following lists may be moved to a more accessible location.

kwkeys = ['size', 'width', 'color', 'tickdir', 'pad',

'labelsize', 'labelcolor', 'zorder', 'gridOn',

'tick1On', 'tick2On', 'label1On', 'label2On',

'length', 'direction', 'left', 'bottom', 'right', 'top',

'labelleft', 'labelbottom', 'labelright', 'labeltop',

'labelrotation'] + _gridline_param_names

kwtrans = {}

if 'length' in kw:

kwtrans['size'] = kw.pop('length')

if 'direction' in kw:

kwtrans['tickdir'] = kw.pop('direction')

if 'rotation' in kw:

kwtrans['labelrotation'] = kw.pop('rotation')

if 'left' in kw:

kwtrans['tick1On'] = kw.pop('left')

if 'bottom' in kw:

kwtrans['tick1On'] = kw.pop('bottom')

if 'right' in kw:

kwtrans['tick2On'] = kw.pop('right')

if 'top' in kw:

kwtrans['tick2On'] = kw.pop('top')

if 'labelleft' in kw:

kwtrans['label1On'] = kw.pop('labelleft')

if 'labelbottom' in kw:

kwtrans['label1On'] = kw.pop('labelbottom')

if 'labelright' in kw:

kwtrans['label2On'] = kw.pop('labelright')

if 'labeltop' in kw:

kwtrans['label2On'] = kw.pop('labeltop')

if 'colors' in kw:

c = kw.pop('colors')

kwtrans['color'] = c

kwtrans['labelcolor'] = c

# Maybe move the checking up to the caller of this method.

for key in kw:

if key not in kwkeys:

raise ValueError(

"keyword %s is not recognized; valid keywords are %s"

% (key, kwkeys))

kwtrans.update(kw)

return kwtrans

def set_clip_path(self, clippath, transform=None):

martist.Artist.set_clip_path(self, clippath, transform)

for child in self.majorTicks + self.minorTicks:

child.set_clip_path(clippath, transform)

self.stale = True

def get_view_interval(self):

"""Return the view limits ``(min, max)`` of this axis."""

raise NotImplementedError('Derived must override')

def set_view_interval(self, vmin, vmax, ignore=False):

"""

raise NotImplementedError('Derived must override')

def get_data_interval(self):

"""Return the Interval instance for this axis data limits."""

raise NotImplementedError('Derived must override')

def set_data_interval(self, vmin, vmax, ignore=False):

"""

raise NotImplementedError('Derived must override')

def get_inverted(self):

"""

low, high = self.get_view_interval()

return high < low

def set_inverted(self, inverted):

"""

# Currently, must be implemented in subclasses using set_xlim/set_ylim

# rather than generically using set_view_interval, so that shared

# axes get updated as well.

raise NotImplementedError('Derived must override')

def set_default_intervals(self):

"""

# this is mainly in support of custom object plotting. For

# example, if someone passes in a datetime object, we do not

# know automagically how to set the default min/max of the

# data and view limits. The unit conversion AxisInfo

# interface provides a hook for custom types to register

# default limits through the AxisInfo.default_limits

# attribute, and the derived code below will check for that

# and use it if is available (else just use 0..1)

def _set_artist_props(self, a):

if a is None:

return

a.set_figure(self.figure)

def get_ticklabel_extents(self, renderer):

"""

ticks_to_draw = self._update_ticks()

ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw,

renderer)

if len(ticklabelBoxes):

bbox = mtransforms.Bbox.union(ticklabelBoxes)

else:

bbox = mtransforms.Bbox.from_extents(0, 0, 0, 0)

if len(ticklabelBoxes2):

bbox2 = mtransforms.Bbox.union(ticklabelBoxes2)

else:

bbox2 = mtransforms.Bbox.from_extents(0, 0, 0, 0)

return bbox, bbox2

@cbook.deprecated("3.2")

def set_smart_bounds(self, value):

"""Set the axis to have smart bounds."""

self._smart_bounds = value

self.stale = True

@cbook.deprecated("3.2")

def get_smart_bounds(self):

"""Return whether the axis has smart bounds."""