def _as_units_container(arg, **fmt_kwargs):
"""
Convert a unit type to a UnitsContainer after checking if it is a reference.
"""
# NOTE: This relies on `pint.util.to_units_container` behavior of passing ``None``
# through, permitting e.g.
# NOTE: This parses units when defining quantify decorators, standardizing return
# value units, and standardizing dependent input argument units.
category = 0 # unit spec (0), dimensionality string (1), or reference string (2)
if isinstance(arg, str):
arg = arg.format(**fmt_kwargs) # permit extra keyword arguments
if '=' in arg:
category = 2
elif '[' in arg and ']' in arg:
category = 1
else:
arg = _to_pint_string(arg) # support conventions, possible error later
elif arg is None or isinstance(arg, pint.Unit):
pass
else: # should be impossible since _group_args checks type
raise ValueError(f'Unrecognized pint unit argument {arg}.')
if category == 2:
container = to_units_container(arg.split('=', 1)[1]) # skips validation
elif category == 1:
container = ureg.get_dimensionality(arg) # validates dimensions
else:
container = to_units_container(arg, ureg) # validates string units
return container, category
def _to_units_container(arg):
"""
Convert a unit compatible type to a UnitsContainer, checking if it is string
field prefixed with an equal (which is considered a reference). Return the
unit container and a boolean indicating whether this is an equal string.
"""
if isinstance(arg, str) and '=' in arg:
return putil.to_units_container(arg.split('=', 1)[1]), True
return putil.to_units_container(arg, ureg), False
def format_mass(obj, info, spec=None):
"""Format the units of *obj* with *info* inserted after its mass unit.
Parameters
----------
obj : pint.Quantity or pint.Unit
info : str
Any information, e.g. the symbol of a GHG species.
spec : str, optional
Pint formatting specifier such as ':H' (HTML format), ':~' (compact
format with symbols), etc.
"""
spec = spec or obj.default_format
try:
# Use only the units of a Quantity object
obj = obj.units
except AttributeError:
pass # Already a Unit object
# Use the symbol for a ':~' spec
method = registry._get_symbol if '~' in spec else lambda k: k
# Collect the pieces of the unit expression
units = [[method(key), value] for key, value in obj._units.items()]
# Index of the mass component
mass_index = list(obj.dimensionality.keys()).index('[mass]')
# Append the information to the mass component
units[mass_index][0] += f' {info}'
# Hand off to pint's formatting
return format_unit(to_units_container(dict(units), registry=registry),
spec)
def test_quantity_conversion(self):
from pint.registry import UnitRegistry
ureg = UnitRegistry()
self.assertEqual(
to_units_container(ureg.Quantity(1, UnitsContainer(m=1))),
UnitsContainer(m=1),
)
def test_uc_conversion(self):
a = UnitsContainer(m=1)
self.assertIs(to_units_container(a), a)
def test_str_conversion(self):
self.assertEqual(to_units_container("m"), UnitsContainer(m=1))
def test_dict_conversion(self):
self.assertEqual(to_units_container(dict(m=1)), UnitsContainer(m=1))
def test_unit_conversion(self):
from pint.unit import _Unit
self.assertEqual(to_units_container(_Unit(UnitsContainer(m=1))),
UnitsContainer(m=1))
def test_uc_conversion(self):
a = UnitsContainer(m=1)
self.assertIs(to_units_container(a), a)
def test_str_conversion(self):
self.assertEqual(to_units_container('m'), UnitsContainer(m=1))
def test_dict_conversion(self):
assert to_units_container(dict(m=1)) == UnitsContainer(m=1)
def test_unit_conversion(self):
from pint import Unit
assert to_units_container(Unit(
UnitsContainer(m=1))) == UnitsContainer(m=1)
def test_uc_conversion(self):
a = UnitsContainer(m=1)
assert to_units_container(a) is a
def test_str_conversion(self):
assert to_units_container("m") == UnitsContainer(m=1)
def test_unit_conversion(self):
from pint import Unit
self.assertEqual(to_units_container(Unit(UnitsContainer(m=1))),
UnitsContainer(m=1))
def test_dict_conversion(self):
self.assertEqual(to_units_container(dict(m=1)), UnitsContainer(m=1))
def test_quantity_conversion(self):
from pint.unit import UnitRegistry
ureg = UnitRegistry()
self.assertEqual(to_units_container(ureg.Quantity(1, UnitsContainer(m=1))),
UnitsContainer(m=1))
