'CutoffScale',

'ExpScale',

'FuncScale',

'InverseScale',

'LinearScale',

'LogitScale',

'LogScale',

'MercatorLatitudeScale',

'PowerScale',

'SineLatitudeScale',

'SymmetricalLogScale',

"""

# NOTE: Scale classes ignore unused arguments with warnings, but matplotlib 3.3

# version changes the keyword args. Since we can't do a try except clause, only

# way to avoid warnings with 3.3 upgrade is to test version string.

kwsuffix = '' if _version_mpl >= '3.3' else 'x'

for key in keys:

# Remove duplicates

opts = {

key: kwargs.pop(key, None),

key + 'x': kwargs.pop(key + 'x', None),

key + 'y': kwargs.pop(key + 'y', None),

}

value = _not_none(**opts) # issues warning if multiple values passed

# Apply defaults and adjust

# NOTE: If linthresh is *exactly* on a power of the base, can end

# up with additional log-locator step inside the threshold, e.g. major

# ticks on -10, -1, -0.1, 0.1, 1, 10 for linthresh of 1. Adding slight

# offset to *desired* linthresh prevents this.

if key == 'subs':

if value is None:

value = np.arange(1, 10)

if key == 'linthresh':

if value is None:

value = 1

power = np.log10(value)

if power % 1 == 0: # exact power of 10

value = value + 10 ** (power - 10)

if value is not None: # dummy axis_name is 'x'

kwargs[key + kwsuffix] = value

"""

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

# Pass a dummy axis to the superclass

axis = type('Axis', (object,), {'axis_name': 'x'})()

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

self._default_major_locator = mticker.AutoLocator()

self._default_minor_locator = mticker.AutoMinorLocator()

self._default_major_formatter = pticker.AutoFormatter()

self._default_minor_formatter = mticker.NullFormatter()

def set_default_locators_and_formatters(self, axis, only_if_default=False):

"""

# TODO: Always use only_if_default=True? Used only for dual axes right now

# NOTE: We set isDefault_minloc to True when simply toggling minor ticks

# on and off with CartesianAxes format command.

from .config import rc

if not only_if_default or axis.isDefault_majloc:

locator = copy.copy(self._default_major_locator)

axis.set_major_locator(locator)

axis.isDefault_majloc = True

if not only_if_default or axis.isDefault_minloc:

x = axis.axis_name if axis.axis_name in 'xy' else 'x'

if rc[x + 'tick.minor.visible']:

locator = copy.copy(self._default_minor_locator)

else:

locator = mticker.NullLocator()

axis.set_minor_locator(locator)

axis.isDefault_minloc = True

if not only_if_default or axis.isDefault_majfmt:

formatter = copy.copy(self._default_major_formatter)

axis.set_major_formatter(formatter)

axis.isDefault_majfmt = True

if not only_if_default or axis.isDefault_minfmt:

formatter = copy.copy(self._default_minor_formatter)

axis.set_minor_formatter(formatter)

axis.isDefault_minfmt = True

def get_transform(self):

"""

"""

#: The registered scale name

name = 'linear'

def __init__(self, **kwargs):

"""

super().__init__(**kwargs)

"""

#: The registered scale name

name = 'logit'

def __init__(self, **kwargs):

"""

super().__init__(**kwargs)

# self._default_major_formatter = mticker.LogitFormatter()

self._default_major_locator = mticker.LogitLocator()

"""

#: The registered scale name

name = 'log'

def __init__(self, **kwargs):

"""

keys = ('base', 'nonpos', 'subs')

super().__init__(**_parse_logscale_args(*keys, **kwargs))

self._default_major_locator = mticker.LogLocator(self.base)

"""

#: The registered scale name

name = 'symlog'

def __init__(self, **kwargs):

"""

keys = ('base', 'linthresh', 'linscale', 'subs')

super().__init__(**_parse_logscale_args(*keys, **kwargs))

transform = self.get_transform()

self._default_major_locator = mticker.SymmetricalLogLocator(transform)

"""

#: The registered scale name

name = 'function'

def __init__(self, transform=None, invert=False, parent_scale=None, **kwargs):

"""

# Parse input args

# NOTE: Permit *arbitrary* parent axis scales and infer default locators and

# formatters from the input scale (if it was passed) or the parent scale. Use

# case for latter is e.g. logarithmic scale with linear transformation.

if 'functions' in kwargs: # matplotlib compatibility (critical for >= 3.5)

functions = kwargs.pop('functions', None)

if transform is None:

transform = functions

else:

warnings._warn_proplot("Ignoring keyword argument 'functions'.")

from .constructor import Formatter, Locator, Scale

super().__init__()

if callable(transform):

forward, inverse, inherit_scale = transform, transform, None

elif np.iterable(transform) and len(transform) == 2 and all(map(callable, transform)): # noqa: E501

forward, inverse, inherit_scale = *transform, None

else:

try:

inherit_scale = Scale(transform)

except ValueError:

raise ValueError(

'Expected a function, 2-tuple of forward and inverse functions, '

f'or an axis scale specification. Got {transform!r}.'

)

transform = inherit_scale.get_transform()

forward, inverse = transform.transform, transform.inverted().transform

# Create the transform

# NOTE: Linear scale is always identity transform (no-op).

# NOTE: Must transform parent scale cutoff arguments as well. Use inverse

# function because we are converting from some *other* axis to this one.

if invert: # used for dualx and dualy

forward, inverse = inverse, forward

parent_scale = _not_none(parent_scale, LinearScale())

if not isinstance(parent_scale, mscale.ScaleBase):

raise ValueError(f'Parent scale must be ScaleBase. Got {parent_scale!r}.')

if isinstance(parent_scale, CutoffScale):

args = list(parent_scale.args) # mutable copy

args[::2] = (inverse(arg) for arg in args[::2]) # transform cutoffs

parent_scale = CutoffScale(*args)

if isinstance(parent_scale, mscale.SymmetricalLogScale):

keys = ('base', 'linthresh', 'linscale', 'subs')

kwsym = {key: getattr(parent_scale, key) for key in keys}

kwsym['linthresh'] = inverse(kwsym['linthresh'])

parent_scale = SymmetricalLogScale(**kwsym)

self.functions = (forward, inverse)

self._transform = parent_scale.get_transform() + FuncTransform(forward, inverse)

# Apply default locators and formatters

# NOTE: We pass these through contructor functions

scale = inherit_scale or parent_scale

for which in ('major', 'minor'):

for type_, parser in (('locator', Locator), ('formatter', Formatter)):

key = which + '_' + type_

attr = '_default_' + key

ticker = kwargs.pop(key, None)

if ticker is None:

ticker = getattr(scale, attr, None)

if ticker is None: # e.g. someone used a matplotlib scale

continue # revert to defaults

ticker = parser(ticker)

setattr(self, attr, copy.copy(ticker))

if kwargs:

input_dims = 1

output_dims = 1

is_separable = True

has_inverse = True

def __init__(self, forward, inverse):

super().__init__()

if callable(forward) and callable(inverse):

self._forward = forward

self._inverse = inverse

else:

raise ValueError('arguments to FuncTransform must be functions')

def inverted(self):

return FuncTransform(self._inverse, self._forward)

def transform_non_affine(self, values):

with np.errstate(divide='ignore', invalid='ignore'):

r"""

#: The registered scale name

name = 'power'

def __init__(self, power=1, inverse=False):

"""

super().__init__()

if not inverse:

self._transform = PowerTransform(power)

else:

self._transform = InvertedPowerTransform(power)

def limit_range_for_scale(self, vmin, vmax, minpos):

"""

if not np.isfinite(minpos):

minpos = 1e-300

return (

minpos if vmin <= 0 else vmin,

minpos if vmax <= 0 else vmax,

input_dims = 1

output_dims = 1

has_inverse = True

is_separable = True

def __init__(self, power):

super().__init__()

self._power = power

def inverted(self):

return InvertedPowerTransform(self._power)

def transform_non_affine(self, a):

with np.errstate(divide='ignore', invalid='ignore'):

input_dims = 1

output_dims = 1

has_inverse = True

is_separable = True

def __init__(self, power):

super().__init__()

self._power = power

def inverted(self):

return PowerTransform(self._power)

def transform_non_affine(self, a):

with np.errstate(divide='ignore', invalid='ignore'):

r"""

#: The registered scale name

name = 'exp'

def __init__(self, a=np.e, b=1, c=1, inverse=False):

"""

super().__init__()

if not inverse:

self._transform = ExpTransform(a, b, c)

else:

self._transform = InvertedExpTransform(a, b, c)

def limit_range_for_scale(self, vmin, vmax, minpos):

"""

if not np.isfinite(minpos):

minpos = 1e-300

return (

minpos if vmin <= 0 else vmin,

minpos if vmax <= 0 else vmax,

input_dims = 1

output_dims = 1

has_inverse = True

is_separable = True

def __init__(self, a, b, c):

super().__init__()

self._a = a

self._b = b

self._c = c

def inverted(self):

return InvertedExpTransform(self._a, self._b, self._c)

def transform_non_affine(self, a):

with np.errstate(divide='ignore', invalid='ignore'):

input_dims = 1

output_dims = 1

has_inverse = True

is_separable = True

def __init__(self, a, b, c):

super().__init__()

self._a = a

self._b = b

self._c = c

def inverted(self):

return ExpTransform(self._a, self._b, self._c)

def transform_non_affine(self, a):

with np.errstate(divide='ignore', invalid='ignore'):

"""

#: The registered scale name

name = 'mercator'

def __init__(self, thresh=85.0):

"""

super().__init__()

if thresh >= 90:

raise ValueError("Mercator scale 'thresh' must be <= 90.")

self._thresh = thresh

self._transform = MercatorLatitudeTransform(thresh)

self._default_major_formatter = pticker.AutoFormatter(suffix='\N{DEGREE SIGN}')

def limit_range_for_scale(self, vmin, vmax, minpos): # noqa: U100

"""

input_dims = 1

output_dims = 1

is_separable = True

has_inverse = True

def __init__(self, thresh):

super().__init__()

self._thresh = thresh

def inverted(self):

return InvertedMercatorLatitudeTransform(self._thresh)

def transform_non_affine(self, a):

# NOTE: Critical to truncate valid range inside transform *and*

# in limit_range_for_scale or get weird duplicate tick labels. This

# is not necessary for positive-only scales because it is harder to

# run up right against the scale boundaries.

with np.errstate(divide='ignore', invalid='ignore'):

m = ma.masked_where((a <= -90) | (a >= 90), a)

if m.mask.any():

m = np.deg2rad(m)

return ma.log(ma.abs(ma.tan(m) + 1 / ma.cos(m)))

else:

a = np.deg2rad(a)

input_dims = 1

output_dims = 1

is_separable = True

has_inverse = True

def __init__(self, thresh):

super().__init__()

self._thresh = thresh

def inverted(self):

return MercatorLatitudeTransform(self._thresh)

def transform_non_affine(self, a):

with np.errstate(divide='ignore', invalid='ignore'):

r"""

#: The registered scale name

name = 'sine'

def __init__(self):

"""

super().__init__()

self._transform = SineLatitudeTransform()

self._default_major_formatter = pticker.AutoFormatter(suffix='\N{DEGREE SIGN}')

def limit_range_for_scale(self, vmin, vmax, minpos): # noqa: U100

"""

input_dims = 1

output_dims = 1

is_separable = True

has_inverse = True

def __init__(self):

super().__init__()

def inverted(self):

return InvertedSineLatitudeTransform()

def transform_non_affine(self, a):

# NOTE: Critical to truncate valid range inside transform *and*

# in limit_range_for_scale or get weird duplicate tick labels. This

# is not necessary for positive-only scales because it is harder to

# run up right against the scale boundaries.

with np.errstate(divide='ignore', invalid='ignore'):

m = ma.masked_where((a < -90) | (a > 90), a)

if m.mask.any():

return ma.sin(np.deg2rad(m))

else:

input_dims = 1

output_dims = 1

is_separable = True

has_inverse = True

def __init__(self):

super().__init__()

def inverted(self):

return SineLatitudeTransform()

def transform_non_affine(self, a):

with np.errstate(divide='ignore', invalid='ignore'):

"""

#: The registered scale name

name = 'cutoff'

def __init__(self, *args):

"""

# NOTE: See https://stackoverflow.com/a/5669301/4970632

super().__init__()

args = list(args)

if len(args) % 2 == 1:

args.append(1)

self.args = args

self.threshs = args[::2]

self.scales = args[1::2]

input_dims = 1

output_dims = 1

has_inverse = True

is_separable = True

def __init__(self, threshs, scales, zero_dists=None):

# The zero_dists array is used to fill in distances where scales and

# threshold steps are zero. Used for inverting discrete transorms.

super().__init__()

dists = np.diff(threshs)

scales = np.asarray(scales)

threshs = np.asarray(threshs)

if len(scales) != len(threshs):

raise ValueError(f'Got {len(threshs)} but {len(scales)} scales.')

if any(scales < 0):

raise ValueError('Scales must be non negative.')

if scales[-1] in (0, np.inf):

raise ValueError('Final scale must be finite.')

if any(dists < 0):

raise ValueError('Thresholds must be monotonically increasing.')

if any((dists == 0) | (scales == 0)):

if zero_dists is None:

raise ValueError('Keyword zero_dists is required for discrete steps.')

if any((dists == 0) != (scales == 0)):

raise ValueError('Input scales disagree with discrete step locations.')

self._scales = scales

self._threshs = threshs

with np.errstate(divide='ignore', invalid='ignore'):

dists = np.concatenate((threshs[:1], dists / scales[:-1]))

if zero_dists is not None:

dists[scales[:-1] == 0] = zero_dists

self._dists = dists

def inverted(self):

# Use same algorithm for inversion!

threshs = np.cumsum(self._dists) # thresholds in transformed space

with np.errstate(divide='ignore', invalid='ignore'):

scales = 1.0 / self._scales # new scales are inverse

zero_dists = np.diff(self._threshs)[scales[:-1] == 0]

return CutoffTransform(threshs, scales, zero_dists=zero_dists)

def transform_non_affine(self, a):

# Cannot do list comprehension because this method sometimes

# received non-1D arrays

dists = self._dists

scales = self._scales

threshs = self._threshs

aa = np.array(a) # copy

with np.errstate(divide='ignore', invalid='ignore'):

for i, ai in np.ndenumerate(a):

j = np.searchsorted(threshs, ai)

if j > 0:

aa[i] = dists[:j].sum() + (ai - threshs[j - 1]) / scales[j - 1]

r"""

#: The registered scale name

name = 'inverse'

def __init__(self):

"""

super().__init__()

self._transform = InverseTransform()

self._default_major_locator = mticker.LogLocator(10)

self._default_minor_locator = mticker.LogLocator(10, np.arange(1, 10))

def limit_range_for_scale(self, vmin, vmax, minpos):

"""

# Unlike log-scale, we can't just warp the space between

# the axis limits -- have to actually change axis limits. Also this

# scale will invert and swap the limits you provide.

if not np.isfinite(minpos):

minpos = 1e-300

return (

minpos if vmin <= 0 else vmin,

minpos if vmax <= 0 else vmax,

# Create transform object

input_dims = 1

output_dims = 1

is_separable = True

has_inverse = True

def __init__(self):

super().__init__()

def inverted(self):

return InverseTransform()

def transform_non_affine(self, a):

with np.errstate(divide='ignore', invalid='ignore'):

"""

mapping = mscale._scale_mapping

if isinstance(scale, mscale.ScaleBase):

if args or kwargs:

warnings._warn_proplot(f'Ignoring args {args} and keyword args {kwargs}.')

return scale # do nothing

else:

scale = scale.lower()

if scale not in mapping:

raise ValueError(

f'Unknown axis scale {scale!r}. Options are '

+ ', '.join(map(repr, mapping)) + '.'

)