"""

.. _basic_units:

===========

Basic units

===========

This file implements a units library that supports registering arbitrary units,

conversions between units, and math with unitized data. This library also implements a

Matplotlib unit converter and registers its units with Matplotlib. This library is used

in the examples to demonstrate Matplotlib's unit support. It is only maintained for the

purposes of building documentation and should never be used outside of the Matplotlib

documentation.

"""

import itertools

import math

from packaging.version import parse as parse_version

import numpy as np

import matplotlib.ticker as ticker

import matplotlib.units as units

class ProxyDelegate:

def __init__(self, fn_name, proxy_type):

self.proxy_type = proxy_type

self.fn_name = fn_name

def __get__(self, obj, objtype=None):

return self.proxy_type(self.fn_name, obj)

class TaggedValueMeta(type):

def __init__(self, name, bases, dict):

for fn_name in self._proxies:

if not hasattr(self, fn_name):

setattr(self, fn_name,

ProxyDelegate(fn_name, self._proxies[fn_name]))

class PassThroughProxy:

def __init__(self, fn_name, obj):

self.fn_name = fn_name

self.target = obj.proxy_target

def __call__(self, *args):

fn = getattr(self.target, self.fn_name)

ret = fn(*args)

return ret

class ConvertArgsProxy(PassThroughProxy):

def __init__(self, fn_name, obj):

super().__init__(fn_name, obj)

self.unit = obj.unit

def __call__(self, *args):

converted_args = []

for a in args:

try:

converted_args.append(a.convert_to(self.unit))

except AttributeError:

converted_args.append(TaggedValue(a, self.unit))

converted_args = tuple([c.get_value() for c in converted_args])

return super().__call__(*converted_args)

class ConvertReturnProxy(PassThroughProxy):

def __init__(self, fn_name, obj):

super().__init__(fn_name, obj)

self.unit = obj.unit

def __call__(self, *args):

ret = super().__call__(*args)

return (NotImplemented if ret is NotImplemented

else TaggedValue(ret, self.unit))

class ConvertAllProxy(PassThroughProxy):

def __init__(self, fn_name, obj):

super().__init__(fn_name, obj)

self.unit = obj.unit

def __call__(self, *args):

converted_args = []

arg_units = [self.unit]

for a in args:

if hasattr(a, 'get_unit') and not hasattr(a, 'convert_to'):

# If this argument has a unit type but no conversion ability,

# this operation is prohibited.

return NotImplemented

if hasattr(a, 'convert_to'):

try:

a = a.convert_to(self.unit)

except Exception:

pass

arg_units.append(a.get_unit())

converted_args.append(a.get_value())

else:

converted_args.append(a)

if hasattr(a, 'get_unit'):

arg_units.append(a.get_unit())

else:

arg_units.append(None)

converted_args = tuple(converted_args)

ret = super().__call__(*converted_args)

if ret is NotImplemented:

return NotImplemented

ret_unit = unit_resolver(self.fn_name, arg_units)

if ret_unit is NotImplemented:

return NotImplemented

return TaggedValue(ret, ret_unit)

class TaggedValue(metaclass=TaggedValueMeta):

_proxies = {'__add__': ConvertAllProxy,

'__sub__': ConvertAllProxy,

'__mul__': ConvertAllProxy,

'__rmul__': ConvertAllProxy,

'__cmp__': ConvertAllProxy,

'__lt__': ConvertAllProxy,

'__gt__': ConvertAllProxy,

'__len__': PassThroughProxy}

def __new__(cls, value, unit):

# generate a new subclass for value

value_class = type(value)

try:

subcls = type(f'TaggedValue_of_{value_class.__name__}',

(cls, value_class), {})

return object.__new__(subcls)

except TypeError:

return object.__new__(cls)

def __init__(self, value, unit):

self.value = value

self.unit = unit

self.proxy_target = self.value

def __copy__(self):

return TaggedValue(self.value, self.unit)

def __getattribute__(self, name):

if name.startswith('__'):

return object.__getattribute__(self, name)

variable = object.__getattribute__(self, 'value')

if hasattr(variable, name) and name not in self.__class__.__dict__:

return getattr(variable, name)

return object.__getattribute__(self, name)

def __array__(self, dtype=object, copy=False):

return np.asarray(self.value, dtype)

def __array_wrap__(self, array, context=None, return_scalar=False):

return TaggedValue(array, self.unit)

def __repr__(self):

return f'TaggedValue({self.value!r}, {self.unit!r})'

def __str__(self):

return f"{self.value} in {self.unit}"

def __len__(self):

return len(self.value)

if parse_version(np.__version__) >= parse_version('1.20'):

def __getitem__(self, key):

return TaggedValue(self.value[key], self.unit)

def __iter__(self):

# Return a generator expression rather than use `yield`, so that

# TypeError is raised by iter(self) if appropriate when checking for

# iterability.

return (TaggedValue(inner, self.unit) for inner in self.value)

def get_compressed_copy(self, mask):

new_value = np.ma.masked_array(self.value, mask=mask).compressed()

return TaggedValue(new_value, self.unit)

def convert_to(self, unit):

if unit == self.unit or not unit:

return self

try:

new_value = self.unit.convert_value_to(self.value, unit)

except AttributeError:

new_value = self

return TaggedValue(new_value, unit)

def get_value(self):

return self.value

def get_unit(self):

return self.unit

class BasicUnit:

# numpy scalars convert eager and np.float64(2) * BasicUnit('cm')

# would thus return a numpy scalar. To avoid this, we increase the

# priority of the BasicUnit.

__array_priority__ = np.float64(0).__array_priority__ + 1

def __init__(self, name, fullname=None):

self.name = name

if fullname is None:

fullname = name

self.fullname = fullname

self.conversions = dict()

def __repr__(self):

return f'BasicUnit({self.name})'

def __str__(self):

return self.fullname

def __call__(self, value):

return TaggedValue(value, self)

def __mul__(self, rhs):

value = rhs

unit = self

if hasattr(rhs, 'get_unit'):

value = rhs.get_value()

unit = rhs.get_unit()

unit = unit_resolver('__mul__', (self, unit))

if unit is NotImplemented:

return NotImplemented

return TaggedValue(value, unit)

def __rmul__(self, lhs):

return self*lhs

def __array_wrap__(self, array, context=None, return_scalar=False):

return TaggedValue(array, self)

def __array__(self, t=None, context=None, copy=False):

ret = np.array(1)

if t is not None:

return ret.astype(t)

else:

return ret

def add_conversion_factor(self, unit, factor):

def convert(x):

return x*factor

self.conversions[unit] = convert

def add_conversion_fn(self, unit, fn):

self.conversions[unit] = fn

def get_conversion_fn(self, unit):

return self.conversions[unit]

def convert_value_to(self, value, unit):

conversion_fn = self.conversions[unit]

ret = conversion_fn(value)

return ret

def get_unit(self):

return self

class UnitResolver:

def addition_rule(self, units):

for unit_1, unit_2 in itertools.pairwise(units):

if unit_1 != unit_2:

return NotImplemented

return units[0]

def multiplication_rule(self, units):

non_null = [u for u in units if u]

if len(non_null) > 1:

return NotImplemented

return non_null[0]

op_dict = {

'__mul__': multiplication_rule,

'__rmul__': multiplication_rule,

'__add__': addition_rule,

'__radd__': addition_rule,

'__sub__': addition_rule,

'__rsub__': addition_rule}

def __call__(self, operation, units):

if operation not in self.op_dict:

return NotImplemented

return self.op_dict[operation](self, units)

unit_resolver = UnitResolver()

cm = BasicUnit('cm', 'centimeters')

inch = BasicUnit('inch', 'inches')

inch.add_conversion_factor(cm, 2.54)

cm.add_conversion_factor(inch, 1/2.54)

radians = BasicUnit('rad', 'radians')

degrees = BasicUnit('deg', 'degrees')

radians.add_conversion_factor(degrees, 180.0/np.pi)

degrees.add_conversion_factor(radians, np.pi/180.0)

secs = BasicUnit('s', 'seconds')

hertz = BasicUnit('Hz', 'Hertz')

minutes = BasicUnit('min', 'minutes')

secs.add_conversion_fn(hertz, lambda x: 1./x)

secs.add_conversion_factor(minutes, 1/60.0)

# radians formatting

def rad_fn(x, pos=None):

if x >= 0:

n = int((x / np.pi) * 2.0 + 0.25)

else:

n = int((x / np.pi) * 2.0 - 0.25)

if n == 0:

return '0'

elif n == 1:

return r'$\pi/2$'

elif n == 2:

return r'$\pi$'

elif n == -1:

return r'$-\pi/2$'

elif n == -2:

return r'$-\pi$'

elif n % 2 == 0:

return fr'${n//2}\pi$'

else:

return fr'${n}\pi/2$'

class BasicUnitConverter(units.ConversionInterface):

@staticmethod

def axisinfo(unit, axis):

"""Return AxisInfo instance for x and unit."""

if unit == radians:

return units.AxisInfo(

majloc=ticker.MultipleLocator(base=np.pi/2),

majfmt=ticker.FuncFormatter(rad_fn),

label=unit.fullname,

)

elif unit == degrees:

return units.AxisInfo(

majloc=ticker.AutoLocator(),

majfmt=ticker.FormatStrFormatter(r'$%i^\circ$'),

label=unit.fullname,

)

elif unit is not None:

if hasattr(unit, 'fullname'):

return units.AxisInfo(label=unit.fullname)

elif hasattr(unit, 'unit'):

return units.AxisInfo(label=unit.unit.fullname)

return None

@staticmethod

def convert(val, unit, axis):

if np.iterable(val):

if isinstance(val, np.ma.MaskedArray):

val = val.astype(float).filled(np.nan)

out = np.empty(len(val))

for i, thisval in enumerate(val):

if np.ma.is_masked(thisval):

out[i] = np.nan

else:

try:

out[i] = thisval.convert_to(unit).get_value()

except AttributeError:

out[i] = thisval

return out

if np.ma.is_masked(val):

return np.nan

else:

return val.convert_to(unit).get_value()

@staticmethod

def default_units(x, axis):

"""Return the default unit for x or None."""

if np.iterable(x):

for thisx in x:

return thisx.unit

return x.unit

def cos(x):

if np.iterable(x):

return [math.cos(val.convert_to(radians).get_value()) for val in x]

else:

return math.cos(x.convert_to(radians).get_value())

units.registry[BasicUnit] = units.registry[TaggedValue] = BasicUnitConverter()