def test_invalid(self):
with pytest.raises(TypeError):
UnitsContainer({1: 2})
with pytest.raises(TypeError):
UnitsContainer({"1": "2"})
d = UnitsContainer()
with pytest.raises(TypeError):
d.__mul__(list())
with pytest.raises(TypeError):
d.__pow__(list())
with pytest.raises(TypeError):
d.__truediv__(list())
with pytest.raises(TypeError):
d.__rtruediv__(list())
def test_defined(self):
ureg = self.ureg
with ureg.context('sp'):
pass
a = Context.__keytransform__(UnitsContainer({'[time]': -1.}),
UnitsContainer({'[length]': 1.}))
b = Context.__keytransform__(UnitsContainer({'[length]': 1.}),
UnitsContainer({'[time]': -1.}))
self.assertIn(a, ureg._contexts['sp'].funcs)
self.assertIn(b, ureg._contexts['sp'].funcs)
with ureg.context('sp'):
self.assertIn(a, ureg._active_ctx)
self.assertIn(b, ureg._active_ctx)
def test_defined(self):
ureg = self.ureg
with ureg.context("sp"):
pass
a = Context.__keytransform__(UnitsContainer({"[time]": -1.0}),
UnitsContainer({"[length]": 1.0}))
b = Context.__keytransform__(UnitsContainer({"[length]": 1.0}),
UnitsContainer({"[time]": -1.0}))
assert a in ureg._contexts["sp"].funcs
assert b in ureg._contexts["sp"].funcs
with ureg.context("sp"):
assert a in ureg._active_ctx
assert b in ureg._active_ctx
def test_parse_unit_with_preprocessor(self):
# Add parsing of UDUNITS-style power
self.ureg.preprocessors.append(
functools.partial(
re.sub,
r"(?<=[A-Za-z])(?![A-Za-z])(?<![0-9\-][eE])(?<![0-9\-])(?=[0-9\-])",
"**",
)
)
# Test equality
self.assertEqual(self.ureg.parse_units("m2"), UnitsContainer(meter=2.0))
self.assertEqual(self.ureg.parse_units("m-2"), UnitsContainer(meter=-2.0))
# Clean up
self.ureg.preprocessors.pop()
def add_arg_ctxs(ureg):
a, b = UnitsContainer({"[length]": 1}), UnitsContainer({"[time]": -1})
d = Context("lc")
d.add_transformation(a, b, lambda ureg, x, n: ureg.speed_of_light / x / n)
d.add_transformation(b, a, lambda ureg, x, n: ureg.speed_of_light / x / n)
ureg.add_context(d)
a, b = UnitsContainer({"[length]": 1}), UnitsContainer({"[current]": 1})
d = Context("ab")
d.add_transformation(a, b, lambda ureg, x: ureg.ampere * ureg.meter / x)
d.add_transformation(b, a, lambda ureg, x: ureg.ampere * ureg.meter / x)
ureg.add_context(d)
def test_defined(self):
ureg = self.ureg
with ureg.context("sp"):
pass
a = Context.__keytransform__(UnitsContainer({"[time]": -1.0}),
UnitsContainer({"[length]": 1.0}))
b = Context.__keytransform__(UnitsContainer({"[length]": 1.0}),
UnitsContainer({"[time]": -1.0}))
self.assertIn(a, ureg._contexts["sp"].funcs)
self.assertIn(b, ureg._contexts["sp"].funcs)
with ureg.context("sp"):
self.assertIn(a, ureg._active_ctx)
self.assertIn(b, ureg._active_ctx)
def add_arg_ctxs(ureg):
a, b = UnitsContainer({'[length]': 1}), UnitsContainer({'[time]': -1})
d = Context('lc')
d.add_transformation(a, b, lambda ureg, x, n: ureg.speed_of_light / x / n)
d.add_transformation(b, a, lambda ureg, x, n: ureg.speed_of_light / x / n)
ureg.add_context(d)
a, b = UnitsContainer({'[length]': 1}), UnitsContainer({'[current]': -1})
d = Context('ab')
d.add_transformation(a, b, lambda ureg, x: 1 / x)
d.add_transformation(b, a, lambda ureg, x: 1 / x)
ureg.add_context(d)
def test_graph_enable(self):
ureg = UnitRegistry()
add_ctxs(ureg)
l = UnitsContainer({'[length]': 1.})
t = UnitsContainer({'[time]': -1.})
c = UnitsContainer({'[current]': -1.})
g_sp = defaultdict(set)
g_sp.update({l: set((t,)),
t: set((l,))})
g_ab = defaultdict(set)
g_ab.update({l: set((c,)),
c: set((l,))})
g = defaultdict(set)
g.update({l: set((t, c)),
t: set((l,)),
c: set((l,))})
ureg.enable_contexts('lc')
self.assertEqual(ureg._active_ctx.graph, g_sp)
ureg.disable_contexts(1)
ureg.enable_contexts('lc', n=1)
self.assertEqual(ureg._active_ctx.graph, g_sp)
ureg.disable_contexts(1)
ureg.enable_contexts('ab')
self.assertEqual(ureg._active_ctx.graph, g_ab)
ureg.disable_contexts(1)
ureg.enable_contexts('lc')
ureg.enable_contexts('ab')
self.assertEqual(ureg._active_ctx.graph, g)
ureg.disable_contexts(2)
ureg.enable_contexts('ab')
ureg.enable_contexts('lc')
self.assertEqual(ureg._active_ctx.graph, g)
ureg.disable_contexts(2)
ureg.enable_contexts('lc', 'ab')
self.assertEqual(ureg._active_ctx.graph, g)
ureg.disable_contexts(2)
ureg.enable_contexts('ab', 'lc')
self.assertEqual(ureg._active_ctx.graph, g)
ureg.disable_contexts(2)
def test_to_and_from_offset_units(self, input_tuple, expected):
src, dst = input_tuple
src, dst = UnitsContainer(src), UnitsContainer(dst)
value = 10.
convert = self.ureg.convert
if isinstance(expected, string_types):
self.assertRaises(DimensionalityError, convert, value, src, dst)
if src != dst:
self.assertRaises(DimensionalityError, convert, value, dst, src)
else:
self.assertQuantityAlmostEqual(convert(value, src, dst),
expected, atol=0.001)
if src != dst:
self.assertQuantityAlmostEqual(convert(expected, dst, src),
value, atol=0.001)
def test_case_sensitivity(self):
ureg = self.ureg
# Default
assert ureg.parse_units("Meter") == UnitsContainer(meter=1)
assert ureg.parse_units("j") == UnitsContainer(joule=1)
# Force True
with pytest.raises(UndefinedUnitError):
ureg.parse_units("Meter", case_sensitive=True)
with pytest.raises(UndefinedUnitError):
ureg.parse_units("j", case_sensitive=True)
# Force False
assert ureg.parse_units("Meter", case_sensitive=False) == UnitsContainer(
meter=1
)
assert ureg.parse_units("j", case_sensitive=False) == UnitsContainer(joule=1)
def test_ipython(self):
alltext = []
class Pretty:
@staticmethod
def text(text):
alltext.append(text)
ureg = UnitRegistry()
x = ureg.Unit(UnitsContainer(meter=2, kilogram=1, second=-1))
self.assertEqual(x._repr_html_(), r"\[kilogram\ meter^2/second\]")
self.assertEqual(
x._repr_latex_(),
r"$\frac{\mathrm{kilogram} \cdot "
r"\mathrm{meter}^{2}}{\mathrm{second}}$",
)
x._repr_pretty_(Pretty, False)
self.assertEqual("".join(alltext), "kilogram·meter²/second")
ureg.default_format = "~"
self.assertEqual(x._repr_html_(), r"\[kg\ m^2/s\]")
self.assertEqual(
x._repr_latex_(),
r"$\frac{\mathrm{kg} \cdot \mathrm{m}^{2}}{\mathrm{s}}$")
alltext = []
x._repr_pretty_(Pretty, False)
self.assertEqual("".join(alltext), "kg·m²/s")
def test_parse_mul_div(self):
assert self.ureg.parse_expression("meter*meter") == self.Q_(
1, UnitsContainer(meter=2.0)
)
assert self.ureg.parse_expression("meter**2") == self.Q_(
1, UnitsContainer(meter=2.0)
)
assert self.ureg.parse_expression("meter*second") == self.Q_(
1, UnitsContainer(meter=1.0, second=1)
)
assert self.ureg.parse_expression("meter/second") == self.Q_(
1, UnitsContainer(meter=1.0, second=-1)
)
assert self.ureg.parse_expression("meter/second**2") == self.Q_(
1, UnitsContainer(meter=1.0, second=-2)
)
def test_ipython(self):
alltext = []
class Pretty:
@staticmethod
def text(text):
alltext.append(text)
ureg = UnitRegistry()
x = ureg.Unit(UnitsContainer(meter=2, kilogram=1, second=-1))
assert x._repr_html_() == "kilogram meter<sup>2</sup>/second"
assert (
x._repr_latex_() == r"$\frac{\mathrm{kilogram} \cdot "
r"\mathrm{meter}^{2}}{\mathrm{second}}$"
)
x._repr_pretty_(Pretty, False)
assert "".join(alltext) == "kilogram·meter²/second"
ureg.default_format = "~"
assert x._repr_html_() == "kg m<sup>2</sup>/s"
assert (
x._repr_latex_() == r"$\frac{\mathrm{kg} \cdot \mathrm{m}^{2}}{\mathrm{s}}$"
)
alltext = []
x._repr_pretty_(Pretty, False)
assert "".join(alltext) == "kg·m²/s"
def test_parse_pretty(self):
assert self.ureg.parse_expression("meter/second²") == self.Q_(
1, UnitsContainer(meter=1.0, second=-2)
)
assert self.ureg.parse_expression("m³/s³") == self.Q_(
1, UnitsContainer(meter=3.0, second=-3)
)
assert self.ureg.parse_expression("meter² · second") == self.Q_(
1, UnitsContainer(meter=2.0, second=1)
)
assert self.ureg.parse_expression("meter⁰.⁵·second") == self.Q_(
1, UnitsContainer(meter=0.5, second=1)
)
assert self.ureg.parse_expression("meter³⁷/second⁴.³²¹") == self.Q_(
1, UnitsContainer(meter=37, second=-4.321)
)
def add_argdef_ctxs(ureg):
a, b = UnitsContainer({'[length]': 1}), UnitsContainer({'[time]': -1})
d = Context('lc', defaults=dict(n=1))
assert d.defaults == dict(n=1)
d.add_transformation(a, b, lambda ureg, x, n: ureg.speed_of_light / x / n)
d.add_transformation(b, a, lambda ureg, x, n: ureg.speed_of_light / x / n)
ureg.add_context(d)
a, b = UnitsContainer({'[length]': 1}), UnitsContainer({'[current]': 1})
d = Context('ab')
d.add_transformation(a, b, lambda ureg, x: ureg.ampere * ureg.meter / x)
d.add_transformation(b, a, lambda ureg, x: ureg.ampere * ureg.meter / x)
ureg.add_context(d)
def __init__(self, name, symbol, aliases, ): self.reference = reference self.is_base = is_base if isinstance(converter, string_types): converter = ParserHelper.from_string(converter) self.reference = UnitsContainer(converter) converter = ScaleConverter(converter.scale) super(UnitDefinition, self).__init__(name, symbol, aliases, converter)
def test_invalid(self):
self.assertRaises(TypeError, UnitsContainer, {1: 2})
self.assertRaises(TypeError, UnitsContainer, {"1": "2"})
d = UnitsContainer()
self.assertRaises(TypeError, d.__mul__, list())
self.assertRaises(TypeError, d.__pow__, list())
self.assertRaises(TypeError, d.__truediv__, list())
self.assertRaises(TypeError, d.__rtruediv__, list())
def test_dimension_definition(self):
x = DimensionDefinition("[time]", "", (), None, is_base=True)
assert x.is_base
assert x.name == "[time]"
x = Definition.from_string("[speed] = [length]/[time]")
assert isinstance(x, DimensionDefinition)
assert x.reference == UnitsContainer({"[length]": 1, "[time]": -1})
def test_as_delta(self):
parse = self.ureg.parse_units
self.assertEqual(parse('kelvin', as_delta=True), UnitsContainer(kelvin=1))
self.assertEqual(parse('kelvin', as_delta=False), UnitsContainer(kelvin=1))
self.assertEqual(parse('kelvin**(-1)', as_delta=True), UnitsContainer(kelvin=-1))
self.assertEqual(parse('kelvin**(-1)', as_delta=False), UnitsContainer(kelvin=-1))
self.assertEqual(parse('kelvin**2', as_delta=True), UnitsContainer(kelvin=2))
self.assertEqual(parse('kelvin**2', as_delta=False), UnitsContainer(kelvin=2))
self.assertEqual(parse('kelvin*meter', as_delta=True), UnitsContainer(kelvin=1, meter=1))
self.assertEqual(parse('kelvin*meter', as_delta=False), UnitsContainer(kelvin=1, meter=1))
def test_parse_simple(self):
a = Context.__keytransform__(UnitsContainer({'[time]': -1}),
UnitsContainer({'[length]': 1}))
b = Context.__keytransform__(UnitsContainer({'[length]': 1}),
UnitsContainer({'[time]': -1}))
s = [
'@context longcontextname', '[length] -> 1 / [time]: c / value',
'1 / [time] -> [length]: c / value'
]
c = Context.from_lines(s)
self.assertEqual(c.name, 'longcontextname')
self.assertEqual(c.aliases, ())
self.assertEqual(c.defaults, {})
self.assertEqual(set(c.funcs.keys()), set((a, b)))
self._test_ctx(c)
s = [
'@context longcontextname = lc',
'[length] <-> 1 / [time]: c / value'
]
c = Context.from_lines(s)
self.assertEqual(c.name, 'longcontextname')
self.assertEqual(c.aliases, ('lc', ))
self.assertEqual(c.defaults, {})
self.assertEqual(set(c.funcs.keys()), set((a, b)))
self._test_ctx(c)
s = [
'@context longcontextname = lc = lcn',
'[length] <-> 1 / [time]: c / value'
]
c = Context.from_lines(s)
self.assertEqual(c.name, 'longcontextname')
self.assertEqual(c.aliases, (
'lc',
'lcn',
))
self.assertEqual(c.defaults, {})
self.assertEqual(set(c.funcs.keys()), set((a, b)))
self._test_ctx(c)
def test_graph_enable(self):
ureg = UnitRegistry()
add_ctxs(ureg)
l = UnitsContainer({"[length]": 1.0}) # noqa: E741
t = UnitsContainer({"[time]": -1.0})
c = UnitsContainer({"[current]": 1.0})
g_sp = defaultdict(set)
g_sp.update({l: {t}, t: {l}})
g_ab = defaultdict(set)
g_ab.update({l: {c}, c: {l}})
g = defaultdict(set)
g.update({l: {t, c}, t: {l}, c: {l}})
ureg.enable_contexts("lc")
self.assertEqual(ureg._active_ctx.graph, g_sp)
ureg.disable_contexts(1)
ureg.enable_contexts("lc", n=1)
self.assertEqual(ureg._active_ctx.graph, g_sp)
ureg.disable_contexts(1)
ureg.enable_contexts("ab")
self.assertEqual(ureg._active_ctx.graph, g_ab)
ureg.disable_contexts(1)
ureg.enable_contexts("lc")
ureg.enable_contexts("ab")
self.assertEqual(ureg._active_ctx.graph, g)
ureg.disable_contexts(2)
ureg.enable_contexts("ab")
ureg.enable_contexts("lc")
self.assertEqual(ureg._active_ctx.graph, g)
ureg.disable_contexts(2)
ureg.enable_contexts("lc", "ab")
self.assertEqual(ureg._active_ctx.graph, g)
ureg.disable_contexts(2)
ureg.enable_contexts("ab", "lc")
self.assertEqual(ureg._active_ctx.graph, g)
ureg.disable_contexts(2)
def add_sharedargdef_ctxs(ureg):
a, b = UnitsContainer({"[length]": 1}), UnitsContainer({"[time]": -1})
d = Context("lc", defaults=dict(n=1))
assert d.defaults == dict(n=1)
d.add_transformation(a, b, lambda ureg, x, n: ureg.speed_of_light / x / n)
d.add_transformation(b, a, lambda ureg, x, n: ureg.speed_of_light / x / n)
ureg.add_context(d)
a, b = UnitsContainer({"[length]": 1}), UnitsContainer({"[current]": 1})
d = Context("ab", defaults=dict(n=0))
d.add_transformation(a, b,
lambda ureg, x, n: ureg.ampere * ureg.meter * n / x)
d.add_transformation(b, a,
lambda ureg, x, n: ureg.ampere * ureg.meter * n / x)
ureg.add_context(d)
def test_parse_simple(self):
a = Context.__keytransform__(UnitsContainer({"[time]": -1}),
UnitsContainer({"[length]": 1}))
b = Context.__keytransform__(UnitsContainer({"[length]": 1}),
UnitsContainer({"[time]": -1}))
s = [
"@context longcontextname",
"[length] -> 1 / [time]: c / value",
"1 / [time] -> [length]: c / value",
]
c = Context.from_lines(s)
assert c.name == "longcontextname"
assert c.aliases == ()
assert c.defaults == {}
assert c.funcs.keys() == {a, b}
self._test_ctx(c)
s = [
"@context longcontextname = lc",
"[length] <-> 1 / [time]: c / value"
]
c = Context.from_lines(s)
assert c.name == "longcontextname"
assert c.aliases == ("lc", )
assert c.defaults == {}
assert c.funcs.keys() == {a, b}
self._test_ctx(c)
s = [
"@context longcontextname = lc = lcn",
"[length] <-> 1 / [time]: c / value",
]
c = Context.from_lines(s)
assert c.name == "longcontextname"
assert c.aliases == ("lc", "lcn")
assert c.defaults == {}
assert c.funcs.keys() == {a, b}
self._test_ctx(c)
def test_parse_expression_with_preprocessor(self):
# Add parsing of UDUNITS-style power
self.ureg.preprocessors.append(
functools.partial(
re.sub,
r"(?<=[A-Za-z])(?![A-Za-z])(?<![0-9\-][eE])(?<![0-9\-])(?=[0-9\-])",
"**",
))
# Test equality
assert self.ureg.parse_expression("42 m2") == self.Q_(
42, UnitsContainer(meter=2.0))
assert self.ureg.parse_expression("1e6 Hz s-2") == self.Q_(
1e6, UnitsContainer(second=-3.0))
assert self.ureg.parse_expression("3 metre3") == self.Q_(
3, UnitsContainer(meter=3.0))
# Clean up and test previously expected value
self.ureg.preprocessors.pop()
assert self.ureg.parse_expression("1e6 Hz s-2") == self.Q_(
999998.0, UnitsContainer())
def test_as_delta(self):
parse = self.ureg.parse_units
assert parse("kelvin", as_delta=True) == UnitsContainer(kelvin=1)
assert parse("kelvin", as_delta=False) == UnitsContainer(kelvin=1)
assert parse("kelvin**(-1)", as_delta=True) == UnitsContainer(kelvin=-1)
assert parse("kelvin**(-1)", as_delta=False) == UnitsContainer(kelvin=-1)
assert parse("kelvin**2", as_delta=True) == UnitsContainer(kelvin=2)
assert parse("kelvin**2", as_delta=False) == UnitsContainer(kelvin=2)
assert parse("kelvin*meter", as_delta=True) == UnitsContainer(kelvin=1, meter=1)
assert parse("kelvin*meter", as_delta=False) == UnitsContainer(
kelvin=1, meter=1
)
def test_to_and_from_offset_units(self, input_tuple, expected):
src, dst = input_tuple
src, dst = UnitsContainer(src), UnitsContainer(dst)
value = 10.0
convert = self.ureg.convert
if isinstance(expected, str):
with pytest.raises(DimensionalityError):
convert(value, src, dst)
if src != dst:
with pytest.raises(DimensionalityError):
convert(value, dst, src)
else:
helpers.assert_quantity_almost_equal(
convert(value, src, dst), expected, atol=0.001
)
if src != dst:
helpers.assert_quantity_almost_equal(
convert(expected, dst, src), value, atol=0.001
)
def test_parse_simple(self):
a = Context.__keytransform__(UnitsContainer({"[time]": -1}),
UnitsContainer({"[length]": 1}))
b = Context.__keytransform__(UnitsContainer({"[length]": 1}),
UnitsContainer({"[time]": -1}))
s = [
"@context longcontextname",
"[length] -> 1 / [time]: c / value",
"1 / [time] -> [length]: c / value",
]
c = Context.from_lines(s)
self.assertEqual(c.name, "longcontextname")
self.assertEqual(c.aliases, ())
self.assertEqual(c.defaults, {})
self.assertEqual(c.funcs.keys(), {a, b})
self._test_ctx(c)
s = [
"@context longcontextname = lc",
"[length] <-> 1 / [time]: c / value"
]
c = Context.from_lines(s)
self.assertEqual(c.name, "longcontextname")
self.assertEqual(c.aliases, ("lc", ))
self.assertEqual(c.defaults, {})
self.assertEqual(c.funcs.keys(), {a, b})
self._test_ctx(c)
s = [
"@context longcontextname = lc = lcn",
"[length] <-> 1 / [time]: c / value",
]
c = Context.from_lines(s)
self.assertEqual(c.name, "longcontextname")
self.assertEqual(c.aliases, ("lc", "lcn"))
self.assertEqual(c.defaults, {})
self.assertEqual(c.funcs.keys(), {a, b})
self._test_ctx(c)
def test_case_sensitivity(self):
ureg = self.ureg
# Default
self.assertEqual(ureg.parse_units("Meter"), UnitsContainer(meter=1))
self.assertEqual(ureg.parse_units("j"), UnitsContainer(joule=1))
# Force True
self.assertRaises(UndefinedUnitError,
ureg.parse_units,
"Meter",
case_sensitive=True)
self.assertRaises(UndefinedUnitError,
ureg.parse_units,
"j",
case_sensitive=True)
# Force False
self.assertEqual(ureg.parse_units("Meter", case_sensitive=False),
UnitsContainer(meter=1))
self.assertEqual(ureg.parse_units("j", case_sensitive=False),
UnitsContainer(joule=1))
def test_graph(self):
ureg = UnitRegistry()
add_ctxs(ureg)
l = UnitsContainer({'[length]': 1.})
t = UnitsContainer({'[time]': -1.})
c = UnitsContainer({'[current]': -1.})
g_sp = defaultdict(set)
g_sp.update({l: set((t,)),
t: set((l,))})
g_ab = defaultdict(set)
g_ab.update({l: set((c,)),
c: set((l,))})
g = defaultdict(set)
g.update({l: set((t, c)),
t: set((l,)),
c: set((l,))})
with ureg.context('lc'):
self.assertEqual(ureg._active_ctx.graph, g_sp)
with ureg.context('lc', n=1):
self.assertEqual(ureg._active_ctx.graph, g_sp)
with ureg.context('ab'):
self.assertEqual(ureg._active_ctx.graph, g_ab)
with ureg.context('lc'):
with ureg.context('ab'):
self.assertEqual(ureg._active_ctx.graph, g)
with ureg.context('ab'):
with ureg.context('lc'):
self.assertEqual(ureg._active_ctx.graph, g)
with ureg.context('lc', 'ab'):
self.assertEqual(ureg._active_ctx.graph, g)
with ureg.context('ab', 'lc'):
self.assertEqual(ureg._active_ctx.graph, g)
def test_convert_inplace(self):
ureg = self.ureg
# Conversions with single units take a different codepath than
# Conversions with more than one unit.
src_dst1 = UnitsContainer(meter=1), UnitsContainer(inch=1)
src_dst2 = UnitsContainer(meter=1, second=-1), UnitsContainer(inch=1, minute=-1)
for src, dst in (src_dst1, src_dst2):
v = (ureg.convert(1, src, dst),)
a = np.ones((3, 1))
ac = np.ones((3, 1))
r1 = ureg.convert(a, src, dst)
np.testing.assert_allclose(r1, v * ac)
self.assertIsNot(r1, a)
r2 = ureg.convert(a, src, dst, inplace=True)
np.testing.assert_allclose(r2, v * ac)
self.assertIs(r2, a)
