"""

def __init__(self, axes, loc, label,

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.

):

"""

artist.Artist.__init__(self)

if gridOn is None:

if major and (rcParams['axes.grid.which'] in ('both', 'major')):

gridOn = rcParams['axes.grid']

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

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

gridOn = rcParams['axes.grid']

else:

gridOn = False

self.set_figure(axes.figure)

self.axes = axes

name = self.__name__.lower()

self._name = name

self._loc = loc

if size is None:

if major:

size = rcParams['%s.major.size' % name]

else:

size = rcParams['%s.minor.size' % name]

self._size = size

if width is None:

if major:

width = rcParams['%s.major.width' % name]

else:

width = rcParams['%s.minor.width' % name]

self._width = width

if color is None:

color = rcParams['%s.color' % name]

self._color = color

if pad is None:

if major:

pad = rcParams['%s.major.pad' % name]

else:

pad = rcParams['%s.minor.pad' % name]

self._base_pad = pad

if labelcolor is None:

labelcolor = rcParams['%s.color' % name]

self._labelcolor = labelcolor

if labelsize is None:

labelsize = rcParams['%s.labelsize' % name]

self._labelsize = 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

self._grid_color = (rcParams['grid.color']

if grid_color is None else grid_color)

self._grid_linestyle = (rcParams['grid.linestyle']

if grid_linestyle is None else grid_linestyle)

self._grid_linewidth = (rcParams['grid.linewidth']

if grid_linewidth is None else grid_linewidth)

self._grid_alpha = (rcParams['grid.alpha']

if grid_alpha is None else grid_alpha)

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

self.apply_tickdir(tickdir)

self.tick1line = self._get_tick1line()

self.tick2line = self._get_tick2line()

self.gridline = self._get_gridline()

self.label1 = self._get_text1()

self.label = self.label1 # legacy name

self.label2 = self._get_text2()

self.gridOn = gridOn

self.tick1On = tick1On

self.tick2On = tick2On

self.label1On = label1On

self.label2On = label2On

self.update_position(loc)

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

if mode not in ('auto', 'default'):

raise ValueError("Label rotation mode must be 'default' or "

"'auto', not '{}'.".format(mode))

self._labelrotation = (mode, angle)

def apply_tickdir(self, tickdir):

"""

pass

def get_tickdir(self):

return self._tickdir

def get_tick_padding(self):

"""

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

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

self.gridline.set_clip_path(clippath, transform)

self.stale = True

set_clip_path.__doc__ = artist.Artist.set_clip_path.__doc__

def get_pad_pixels(self):

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

def contains(self, mouseevent):

"""

if callable(self._contains):

return self._contains(self, mouseevent)

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'

pass

def _get_text2(self):

'Get the default Text 2 instance'

pass

def _get_tick1line(self):

'Get the default line2D instance for tick1'

pass

def _get_tick2line(self):

'Get the default line2D instance for tick2'

pass

def _get_gridline(self):

'Get the default grid Line2d instance for this tick'

pass

def get_loc(self):

'Return the tick location (data coords) as a scalar'

return self._loc

@allow_rasterization

def draw(self, renderer):

if not self.get_visible():

self.stale = False

return

renderer.open_group(self.__name__)

if self.gridOn:

self.gridline.draw(renderer)

if self.tick1On:

self.tick1line.draw(renderer)

if self.tick2On:

self.tick2line.draw(renderer)

if self.label1On:

self.label1.draw(renderer)

if self.label2On:

self.label2.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):

'return the view Interval instance for the axis this tick is ticking'

raise NotImplementedError('Derived must override')

def _apply_params(self, **kw):

for name in ['gridOn', 'tick1On', 'tick2On', 'label1On', 'label2On']:

if name in kw:

setattr(self, name, 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']}

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

if tickdir is None:

tickdir = rcParams['%s.direction' % self._name]

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

'Get the default Text instance'

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

# get the affine as an a,b,c,d,tx,ty list

# x in data coords, y in axes coords

trans, vert, horiz = self._get_text1_transform()

t = mtext.Text(

x=0, y=0,

fontproperties=font_manager.FontProperties(size=self._labelsize),

color=self._labelcolor,

verticalalignment=vert,

horizontalalignment=horiz,

)

t.set_transform(trans)

self._set_artist_props(t)

return t

def _get_text2(self):

'Get the default Text 2 instance'

# x in data coords, y in axes coords

trans, vert, horiz = self._get_text2_transform()

t = mtext.Text(

x=0, y=1,

fontproperties=font_manager.FontProperties(size=self._labelsize),

color=self._labelcolor,

verticalalignment=vert,

horizontalalignment=horiz,

)

t.set_transform(trans)

self._set_artist_props(t)

return t

def _get_tick1line(self):

'Get the default line2D instance'

# x in data coords, y in axes coords

l = mlines.Line2D(xdata=(0,), ydata=(0,), color=self._color,

linestyle='None', marker=self._tickmarkers[0],

markersize=self._size,

markeredgewidth=self._width, zorder=self._zorder)

l.set_transform(self.axes.get_xaxis_transform(which='tick1'))

self._set_artist_props(l)

return l

def _get_tick2line(self):

'Get the default line2D instance'

# x in data coords, y in axes coords

l = mlines.Line2D(xdata=(0,), ydata=(1,),

color=self._color,

linestyle='None',

marker=self._tickmarkers[1],

markersize=self._size,

markeredgewidth=self._width,

zorder=self._zorder)

l.set_transform(self.axes.get_xaxis_transform(which='tick2'))

self._set_artist_props(l)

return l

def _get_gridline(self):

'Get the default line2D instance'

# x in data coords, y in axes coords

l = mlines.Line2D(xdata=(0.0, 0.0), ydata=(0, 1.0),

color=self._grid_color,

linestyle=self._grid_linestyle,

linewidth=self._grid_linewidth,

alpha=self._grid_alpha,

markersize=0,

**self._grid_kw)

l.set_transform(self.axes.get_xaxis_transform(which='grid'))

l.get_path()._interpolation_steps = GRIDLINE_INTERPOLATION_STEPS

self._set_artist_props(l)

return l

def update_position(self, loc):

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

if self.tick1On:

self.tick1line.set_xdata((loc,))

if self.tick2On:

self.tick2line.set_xdata((loc,))

if self.gridOn:

self.gridline.set_xdata((loc,))

if self.label1On:

self.label1.set_x(loc)

if self.label2On:

self.label2.set_x(loc)

self._loc = loc

self.stale = True

def get_view_interval(self):

'return the Interval instance for this axis view limits'

"""

__name__ = 'ytick'

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 = rcParams['%s.direction' % self._name]

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

# how far from the y axis line the right of the ticklabel are

def _get_text1(self):

'Get the default Text instance'

# x in axes coords, y in data coords

trans, vert, horiz = self._get_text1_transform()

t = mtext.Text(

x=0, y=0,

fontproperties=font_manager.FontProperties(size=self._labelsize),

color=self._labelcolor,

verticalalignment=vert,

horizontalalignment=horiz,

)

t.set_transform(trans)

self._set_artist_props(t)

return t

def _get_text2(self):

'Get the default Text instance'

# x in axes coords, y in data coords

trans, vert, horiz = self._get_text2_transform()

t = mtext.Text(

x=1, y=0,

fontproperties=font_manager.FontProperties(size=self._labelsize),

color=self._labelcolor,

verticalalignment=vert,

horizontalalignment=horiz,

)

t.set_transform(trans)

self._set_artist_props(t)

return t

def _get_tick1line(self):

'Get the default line2D instance'

# x in axes coords, y in data coords

l = mlines.Line2D((0,), (0,),

color=self._color,

marker=self._tickmarkers[0],

linestyle='None',

markersize=self._size,

markeredgewidth=self._width,

zorder=self._zorder)

l.set_transform(self.axes.get_yaxis_transform(which='tick1'))

self._set_artist_props(l)

return l

def _get_tick2line(self):

'Get the default line2D instance'

# x in axes coords, y in data coords

l = mlines.Line2D((1,), (0,),

color=self._color,

marker=self._tickmarkers[1],

linestyle='None',

markersize=self._size,

markeredgewidth=self._width,

zorder=self._zorder)

l.set_transform(self.axes.get_yaxis_transform(which='tick2'))

self._set_artist_props(l)

return l

def _get_gridline(self):

'Get the default line2D instance'

# x in axes coords, y in data coords

l = mlines.Line2D(xdata=(0, 1), ydata=(0, 0),

color=self._grid_color,

linestyle=self._grid_linestyle,

linewidth=self._grid_linewidth,

alpha=self._grid_alpha,

markersize=0,

**self._grid_kw)

l.set_transform(self.axes.get_yaxis_transform(which='grid'))

l.get_path()._interpolation_steps = GRIDLINE_INTERPOLATION_STEPS

self._set_artist_props(l)

return l

def update_position(self, loc):

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

if self.tick1On:

self.tick1line.set_ydata((loc,))

if self.tick2On:

self.tick2line.set_ydata((loc,))

if self.gridOn:

self.gridline.set_ydata((loc,))

if self.label1On:

self.label1.set_y(loc)

if self.label2On:

self.label2.set_y(loc)

self._loc = loc

self.stale = True

def get_view_interval(self):

'return the Interval instance for this axis view limits'

"""

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 self.__class__.__name__ \

+ "(%f,%f)" % tuple(self.axes.transAxes.transform_point((0, 0)))

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

"""

artist.Artist.__init__(self)

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

self.label = self._get_label()

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

self.offsetText = self._get_offset_text()

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

@property

@cbook.deprecated("2.2.0")

def unit_data(self):

return self.units

@unit_data.setter

@cbook.deprecated("2.2.0")

def unit_data(self, unit_data):

self.set_units(unit_data)

def get_children(self):

children = [self.label, self.offsetText]

majorticks = self.get_major_ticks()

minorticks = self.get_minor_ticks()

children.extend(majorticks)

children.extend(minorticks)

return children

def cla(self):

'clear the current 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 = (rcParams['axes.grid'] and

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

self._gridOnMinor = (rcParams['axes.grid'] and

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

"""

dicts = []

if which == 'major' or which == 'both':

dicts.append(self._major_tick_kw)

if which == 'minor' or which == 'both':

dicts.append(self._minor_tick_kw)

kwtrans = self._translate_tick_kw(kw, to_init_kw=True)

for d in dicts:

if reset:

d.clear()

d.update(kwtrans)

if reset:

self.reset_ticks()

else:

if which == 'major' or which == 'both':

for tick in self.majorTicks:

tick._apply_params(**self._major_tick_kw)

if which == 'minor' or which == 'both':

for tick in self.minorTicks:

tick._apply_params(**self._minor_tick_kw)

if 'labelcolor' in kwtrans:

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

self.stale = True

@staticmethod

def _translate_tick_kw(kw, to_init_kw=True):

# The following lists may be moved to a more

# accessible location.

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

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

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

kwkeys1 = ['length', 'direction', 'left', 'bottom', 'right', 'top',

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

'labelrotation']

kwkeys2 = _gridline_param_names

kwkeys = kwkeys0 + kwkeys1 + kwkeys2

kwtrans = dict()

if to_init_kw:

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'] = _string_to_bool(kw.pop('left'))

if 'bottom' in kw:

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

if 'right' in kw:

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

if 'top' in kw:

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

if 'labelleft' in kw:

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

if 'labelbottom' in kw:

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

if 'labelright' in kw:

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

if 'labeltop' in kw:

kwtrans['label2On'] = _string_to_bool(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)

else:

raise NotImplementedError("Inverse translation is deferred")

return kwtrans

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

artist.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 Interval instance for this axis view limits'

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

'''set the axis data limits'''

raise NotImplementedError('Derived must override')

def set_default_intervals(self):

'''set the default limits for the axis data and view interval if they

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

pass

def _set_artist_props(self, a):

if a is None:

return

a.set_figure(self.figure)

def iter_ticks(self):

"""

majorLocs = self.major.locator()

majorTicks = self.get_major_ticks(len(majorLocs))

self.major.formatter.set_locs(majorLocs)

majorLabels = [self.major.formatter(val, i)

for i, val in enumerate(majorLocs)]

minorLocs = self.minor.locator()

minorTicks = self.get_minor_ticks(len(minorLocs))

self.minor.formatter.set_locs(minorLocs)

minorLabels = [self.minor.formatter(val, i)

for i, val in enumerate(minorLocs)]

major_minor = [

(majorTicks, majorLocs, majorLabels),

(minorTicks, minorLocs, minorLabels)]

for group in major_minor:

yield from zip(*group)

def get_ticklabel_extents(self, renderer):

"""

ticks_to_draw = self._update_ticks(renderer)

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

def set_smart_bounds(self, value):