/usr/lib/python3/dist-packages/pint/registry_helpers.py is in python3-pint 0.8.1-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 | # -*- coding: utf-8 -*-
"""
pint.registry_helpers
~~~~~~~~~~~~~~~~~~~~~
Miscellaneous methods of the registry writen as separate functions.
:copyright: 2016 by Pint Authors, see AUTHORS for more details..
:license: BSD, see LICENSE for more details.
"""
import functools
from .compat import string_types, zip_longest
from .errors import DimensionalityError
from .util import to_units_container, UnitsContainer
def _replace_units(original_units, values_by_name):
"""Convert a unit compatible type to a UnitsContainer.
:param original_units: a UnitsContainer instance.
:param values_by_name: a map between original names and the new values.
"""
q = 1
for arg_name, exponent in original_units.items():
q = q * values_by_name[arg_name] ** exponent
return getattr(q, "_units", UnitsContainer({}))
def _to_units_container(a, registry=None):
"""Convert a unit compatible type to a UnitsContainer,
checking if it is string field prefixed with an equal
(which is considered a reference)
Return a tuple with the unit container and a boolean indicating if it was a reference.
"""
if isinstance(a, string_types) and '=' in a:
return to_units_container(a.split('=', 1)[1]), True
return to_units_container(a, registry), False
def _parse_wrap_args(args, registry=None):
# Arguments which contain definitions
# (i.e. names that appear alone and for the first time)
defs_args = set()
defs_args_ndx = set()
# Arguments which depend on others
dependent_args_ndx = set()
# Arguments which have units.
unit_args_ndx = set()
# _to_units_container
args_as_uc = [_to_units_container(arg, registry) for arg in args]
# Check for references in args, remove None values
for ndx, (arg, is_ref) in enumerate(args_as_uc):
if arg is None:
continue
elif is_ref:
if len(arg) == 1:
[(key, value)] = arg.items()
if value == 1 and key not in defs_args:
# This is the first time that
# a variable is used => it is a definition.
defs_args.add(key)
defs_args_ndx.add(ndx)
args_as_uc[ndx] = (key, True)
else:
# The variable was already found elsewhere,
# we consider it a dependent variable.
dependent_args_ndx.add(ndx)
else:
dependent_args_ndx.add(ndx)
else:
unit_args_ndx.add(ndx)
# Check that all valid dependent variables
for ndx in dependent_args_ndx:
arg, is_ref = args_as_uc[ndx]
if not isinstance(arg, dict):
continue
if not set(arg.keys()) <= defs_args:
raise ValueError('Found a missing token while wrapping a function: '
'Not all variable referenced in %s are defined using !' % args[ndx])
def _converter(ureg, values, strict):
new_values = list(value for value in values)
values_by_name = {}
# first pass: Grab named values
for ndx in defs_args_ndx:
value = values[ndx]
values_by_name[args_as_uc[ndx][0]] = value
new_values[ndx] = getattr(value, "_magnitude", value)
# second pass: calculate derived values based on named values
for ndx in dependent_args_ndx:
value = values[ndx]
assert _replace_units(args_as_uc[ndx][0], values_by_name) is not None
new_values[ndx] = ureg._convert(getattr(value, "_magnitude", value),
getattr(value, "_units", UnitsContainer({})),
_replace_units(args_as_uc[ndx][0], values_by_name))
# third pass: convert other arguments
for ndx in unit_args_ndx:
if isinstance(values[ndx], ureg.Quantity):
new_values[ndx] = ureg._convert(values[ndx]._magnitude,
values[ndx]._units,
args_as_uc[ndx][0])
else:
if strict:
raise ValueError('A wrapped function using strict=True requires '
'quantity for all arguments with not None units. '
'(error found for {0}, {1})'.format(args_as_uc[ndx][0], new_values[ndx]))
return new_values, values_by_name
return _converter
def wraps(ureg, ret, args, strict=True):
"""Wraps a function to become pint-aware.
Use it when a function requires a numerical value but in some specific
units. The wrapper function will take a pint quantity, convert to the units
specified in `args` and then call the wrapped function with the resulting
magnitude.
The value returned by the wrapped function will be converted to the units
specified in `ret`.
Use None to skip argument conversion.
Set strict to False, to accept also numerical values.
:param ureg: a UnitRegistry instance.
:param ret: output units.
:param args: iterable of input units.
:param strict: boolean to indicate that only quantities are accepted.
:return: the wrapped function.
:raises:
:class:`ValueError` if strict and one of the arguments is not a Quantity.
"""
if not isinstance(args, (list, tuple)):
args = (args, )
converter = _parse_wrap_args(args)
if isinstance(ret, (list, tuple)):
container, ret = True, ret.__class__([_to_units_container(arg, ureg) for arg in ret])
else:
container, ret = False, _to_units_container(ret, ureg)
def decorator(func):
assigned = tuple(attr for attr in functools.WRAPPER_ASSIGNMENTS if hasattr(func, attr))
updated = tuple(attr for attr in functools.WRAPPER_UPDATES if hasattr(func, attr))
@functools.wraps(func, assigned=assigned, updated=updated)
def wrapper(*values, **kw):
# In principle, the values are used as is
# When then extract the magnitudes when needed.
new_values, values_by_name = converter(ureg, values, strict)
result = func(*new_values, **kw)
if container:
out_units = (_replace_units(r, values_by_name) if is_ref else r
for (r, is_ref) in ret)
return ret.__class__(res if unit is None else ureg.Quantity(res, unit)
for unit, res in zip_longest(out_units, result))
if ret[0] is None:
return result
return ureg.Quantity(result,
_replace_units(ret[0], values_by_name) if ret[1] else ret[0])
return wrapper
return decorator
def check(ureg, *args):
"""Decorator to for quantity type checking for function inputs.
Use it to ensure that the decorated function input parameters match
the expected type of pint quantity.
Use None to skip argument checking.
:param ureg: a UnitRegistry instance.
:param args: iterable of input units.
:return: the wrapped function.
:raises:
:class:`DimensionalityError` if the parameters don't match dimensions
"""
dimensions = [ureg.get_dimensionality(dim) for dim in args]
def decorator(func):
assigned = tuple(attr for attr in functools.WRAPPER_ASSIGNMENTS if hasattr(func, attr))
updated = tuple(attr for attr in functools.WRAPPER_UPDATES if hasattr(func, attr))
@functools.wraps(func, assigned=assigned, updated=updated)
def wrapper(*values, **kwargs):
for dim, value in zip_longest(dimensions, values):
if dim and value.dimensionality != dim:
raise DimensionalityError(value, 'a quantity of',
value.dimensionality, dim)
return func(*values, **kwargs)
return wrapper
return decorator
|