class TestCompatibleUnits(QuantityTestCase):
FORCE_NDARRAY = False
def setUp(self):
super(TestCompatibleUnits, self).setUp()
self.ureg = UnitRegistry(force_ndarray=self.FORCE_NDARRAY)
self.Q_ = self.ureg.Quantity
self.U_ = self.ureg.Unit
def _test(self, input_units):
gd = self.ureg.get_dimensionality
dim = gd(input_units)
equiv = self.ureg.get_compatible_units(input_units)
for eq in equiv:
self.assertEqual(gd(eq), dim)
self.assertEqual(equiv, self.ureg.get_compatible_units(dim))
def _test2(self, units1, units2):
equiv1 = self.ureg.get_compatible_units(units1)
equiv2 = self.ureg.get_compatible_units(units2)
self.assertEqual(equiv1, equiv2)
def test_many(self):
self._test(self.ureg.meter)
self._test(self.ureg.seconds)
self._test(self.ureg.newton)
self._test(self.ureg.kelvin)
def test_context_sp(self):
gd = self.ureg.get_dimensionality
# length, frequency, energy
valid = [gd(self.ureg.meter), gd(self.ureg.hertz),
gd(self.ureg.joule), 1/gd(self.ureg.meter)]
with self.ureg.context('sp'):
equiv = self.ureg.get_compatible_units(self.ureg.meter)
result = set()
for eq in equiv:
dim = gd(eq)
result.add(dim)
self.assertIn(dim, valid)
self.assertEqual(len(result), len(valid))
def test_get_base_units(self):
ureg = UnitRegistry()
self.assertEqual(ureg.get_base_units(''), (1, ureg.Unit('')))
self.assertEqual(ureg.get_base_units('meter'), ureg.get_base_units(ParserHelper(meter=1)))
def test_get_compatible_units(self):
ureg = UnitRegistry()
self.assertEqual(ureg.get_compatible_units(''), frozenset())
self.assertEqual(ureg.get_compatible_units('meter'),
ureg.get_compatible_units(ParserHelper(meter=1)))
def test_default_format(self):
ureg = UnitRegistry()
q = ureg.meter
s1 = '{0}'.format(q)
s2 = '{0:~}'.format(q)
ureg.default_format = '~'
s3 = '{0}'.format(q)
self.assertEqual(s2, s3)
self.assertNotEqual(s1, s3)
self.assertEqual(ureg.default_format, '~')
def test_unit_default_formatting(self):
ureg = UnitRegistry()
x = ureg.Unit(UnitsContainer(meter=2, kilogram=1, second=-1))
for spec, result in (('L', r'\frac{\mathrm{kilogram} \cdot \mathrm{meter}^{2}}{\mathrm{second}}'),
('P', 'kilogram·meter²/second'),
('H', 'kilogram meter<sup>2</sup>/second'),
('C', 'kilogram*meter**2/second'),
('~', 'kg * m ** 2 / s'),
('L~', r'\frac{\mathrm{kg} \cdot \mathrm{m}^{2}}{\mathrm{s}}'),
('P~', 'kg·m²/s'),
('H~', 'kg m<sup>2</sup>/s'),
('C~', 'kg*m**2/s'),
):
ureg.default_format = spec
self.assertEqual('{0}'.format(x), result,
'Failed for {0}, {1}'.format(spec, result))
def test_unit_formatting_snake_case(self):
# Test that snake_case units are escaped where appropriate
ureg = UnitRegistry()
x = ureg.Unit(UnitsContainer(oil_barrel=1))
for spec, result in (
("L", r"\mathrm{oil\_barrel}"),
("P", "oil_barrel"),
("H", r"\[oil\_barrel\]"),
("C", "oil_barrel"),
("~", "oil_bbl"),
("L~", r"\mathrm{oil\_bbl}"),
("P~", "oil_bbl"),
("H~", r"\[oil\_bbl\]"),
("C~", "oil_bbl"),
):
with self.subTest(spec):
ureg.default_format = spec
self.assertEqual(f"{x}", result,
f"Failed for {spec}, {result}")
def test_unit_default_formatting(self):
ureg = UnitRegistry()
x = ureg.Unit(UnitsContainer(meter=2, kilogram=1, second=-1))
for spec, result in (
('L',
r'\frac{\mathrm{kilogram} \cdot \mathrm{meter}^{2}}{\mathrm{second}}'
),
('P', 'kilogram·meter²/second'),
('H', 'kilogram meter<sup>2</sup>/second'),
('C', 'kilogram*meter**2/second'),
('~', 'kg * m ** 2 / s'),
('L~', r'\frac{\mathrm{kg} \cdot \mathrm{m}^{2}}{\mathrm{s}}'),
('P~', 'kg·m²/s'),
('H~', 'kg m<sup>2</sup>/s'),
('C~', 'kg*m**2/s'),
):
ureg.default_format = spec
self.assertEqual('{0}'.format(x), result,
'Failed for {0}, {1}'.format(spec, result))
def test_unit_default_formatting(self):
ureg = UnitRegistry()
x = ureg.Unit(UnitsContainer(meter=2, kilogram=1, second=-1))
for spec, result in (
(
"L",
r"\frac{\mathrm{kilogram} \cdot \mathrm{meter}^{2}}{\mathrm{second}}",
),
("P", "kilogram·meter²/second"),
("H", r"\[kilogram\ meter^2/second\]"),
("C", "kilogram*meter**2/second"),
("~", "kg * m ** 2 / s"),
("L~", r"\frac{\mathrm{kg} \cdot \mathrm{m}^{2}}{\mathrm{s}}"),
("P~", "kg·m²/s"),
("H~", r"\[kg\ m^2/s\]"),
("C~", "kg*m**2/s"),
):
with self.subTest(spec):
ureg.default_format = spec
self.assertEqual(f"{x}", result, f"Failed for {spec}, {result}")
def test_unit_default_formatting(self, subtests):
ureg = UnitRegistry()
x = ureg.Unit(UnitsContainer(meter=2, kilogram=1, second=-1))
for spec, result in (
(
"L",
r"\frac{\mathrm{kilogram} \cdot \mathrm{meter}^{2}}{\mathrm{second}}",
),
("P", "kilogram·meter²/second"),
("H", "kilogram meter<sup>2</sup>/second"),
("C", "kilogram*meter**2/second"),
("~", "kg * m ** 2 / s"),
("L~", r"\frac{\mathrm{kg} \cdot \mathrm{m}^{2}}{\mathrm{s}}"),
("P~", "kg·m²/s"),
("H~", "kg m<sup>2</sup>/s"),
("C~", "kg*m**2/s"),
):
with subtests.test(spec):
ureg.default_format = spec
assert f"{x}" == result, f"Failed for {spec}, {result}"
def test_unit_formatting_custom(self, monkeypatch):
from pint import formatting, register_unit_format
monkeypatch.setattr(formatting, "_FORMATTERS", formatting._FORMATTERS.copy())
@register_unit_format("new")
def format_new(unit, **options):
return "new format"
ureg = UnitRegistry()
assert "{:new}".format(ureg.m) == "new format"
def test_base(self):
ureg = UnitRegistry(None)
ureg.define("meter = [length]")
self.assertRaises(DefinitionSyntaxError, ureg.define,
"meter = [length]")
self.assertRaises(TypeError, ureg.define, list())
ureg.define("degC = kelvin; offset: 273.15")
def test_alias(self):
# Use load_definitions
ureg = UnitRegistry([
"canonical = [] = can = alias1 = alias2\n",
# overlapping aliases
"@alias canonical = alias2 = alias3\n",
# Against another alias
"@alias alias3 = alias4\n",
])
# Use define
ureg.define("@alias canonical = alias5")
# Test that new aliases work
# Test that pre-existing aliases and symbol are not eliminated
for a in ("can", "alias1", "alias2", "alias3", "alias4", "alias5"):
self.assertEqual(ureg.Unit(a), ureg.Unit("canonical"))
# Test that aliases defined multiple times are not duplicated
self.assertEqual(
ureg._units["canonical"].aliases,
("alias1", "alias2", "alias3", "alias4", "alias5"),
)
# Define against unknown name
self.assertRaises(KeyError, ureg.define, "@alias notexist = something")
def test_ipython(self):
alltext = []
class Pretty(object):
@staticmethod
def text(text):
alltext.append(text)
ureg = UnitRegistry()
x = ureg.Unit(UnitsContainer(meter=2, kilogram=1, second=-1))
self.assertEqual(x._repr_html_(), "kilogram meter<sup>2</sup>/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_(), "kg m<sup>2</sup>/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_ipython(self):
alltext = []
class Pretty(object):
@staticmethod
def text(text):
alltext.append(text)
ureg = UnitRegistry()
x = ureg.Unit(UnitsContainer(meter=2, kilogram=1, second=-1))
self.assertEqual(x._repr_html_(), "kilogram meter<sup>2</sup>/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_(), "kg m<sup>2</sup>/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_redefinition(self, caplog):
d = UnitRegistry().define
with caplog.at_level(logging.DEBUG):
d("meter = [fruits]")
d("kilo- = 1000")
d("[speed] = [vegetables]")
# aliases
d("bla = 3.2 meter = inch")
d("myk- = 1000 = kilo-")
assert len(caplog.records) == 5
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_redefinition(self):
d = UnitRegistry().define
with self.capture_log() as buffer:
d('meter = [fruits]')
d('kilo- = 1000')
d('[speed] = [vegetables]')
# aliases
d('bla = 3.2 meter = inch')
d('myk- = 1000 = kilo-')
self.assertEqual(len(buffer), 5)
def test_redefinition(self):
d = UnitRegistry().define
with self.capture_log() as buffer:
d("meter = [fruits]")
d("kilo- = 1000")
d("[speed] = [vegetables]")
# aliases
d("bla = 3.2 meter = inch")
d("myk- = 1000 = kilo-")
self.assertEqual(len(buffer), 5)
def test_define(self):
ureg = UnitRegistry(None)
self.assertIsInstance(dir(ureg), list)
self.assertGreater(len(dir(ureg)), 0)
def test_base(self):
ureg = UnitRegistry(None)
ureg.define('meter = [length]')
self.assertRaises(ValueError, ureg.define, 'meter = [length]')
self.assertRaises(TypeError, ureg.define, list())
x = ureg.define('degC = kelvin; offset: 273.15')
class TestCompatibleUnits(QuantityTestCase):
FORCE_NDARRAY = False
def setUp(self):
super(TestCompatibleUnits, self).setUp()
self.ureg = UnitRegistry(force_ndarray=self.FORCE_NDARRAY)
self.Q_ = self.ureg.Quantity
self.U_ = self.ureg.Unit
def _test(self, input_units):
gd = self.ureg.get_dimensionality
dim = gd(input_units)
equiv = self.ureg.get_compatible_units(input_units)
for eq in equiv:
self.assertEqual(gd(eq), dim)
self.assertEqual(equiv, self.ureg.get_compatible_units(dim))
def _test2(self, units1, units2):
equiv1 = self.ureg.get_compatible_units(units1)
equiv2 = self.ureg.get_compatible_units(units2)
self.assertEqual(equiv1, equiv2)
def test_many(self):
self._test(self.ureg.meter)
self._test(self.ureg.seconds)
self._test(self.ureg.newton)
self._test(self.ureg.kelvin)
def test_context_sp(self):
gd = self.ureg.get_dimensionality
# length, frequency, energy
valid = [
gd(self.ureg.meter),
gd(self.ureg.hertz),
gd(self.ureg.joule), 1 / gd(self.ureg.meter)
]
with self.ureg.context('sp'):
equiv = self.ureg.get_compatible_units(self.ureg.meter)
result = set()
for eq in equiv:
dim = gd(eq)
result.add(dim)
self.assertIn(dim, valid)
self.assertEqual(len(result), len(valid))
def test_get_base_units(self):
ureg = UnitRegistry()
self.assertEqual(ureg.get_base_units(''), (1, ureg.Unit('')))
self.assertEqual(ureg.get_base_units('pi'), (math.pi, ureg.Unit('')))
self.assertEqual(ureg.get_base_units('ln10'),
(math.log(10), ureg.Unit('')))
self.assertEqual(ureg.get_base_units('meter'),
ureg.get_base_units(ParserHelper(meter=1)))
def test_get_compatible_units(self):
ureg = UnitRegistry()
self.assertEqual(ureg.get_compatible_units(''), frozenset())
self.assertEqual(ureg.get_compatible_units('meter'),
ureg.get_compatible_units(ParserHelper(meter=1)))
def test_iterate(self):
ureg = UnitRegistry()
assert "meter" in list(ureg)
- PERL (automatically during installation)
'''
import os
import pickle as pl
import subprocess
from enum import Enum
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
# matplotlib.use("Agg")
from pint.registry import UnitRegistry
ureg = UnitRegistry()
class Journal(Enum):
SPRINGER = "SPRINGER"
ELSEVIER = "ELSEVIER"
POWERPOINT = "PTT"
POWERPOINT_A3 = "PTTA3"
class Columnes(Enum):
ONE = "1"
ONE_POINT_FIVE = "1.5"
TWO = "2"
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_get_base_units(self):
ureg = UnitRegistry()
self.assertEqual(ureg.get_base_units(''), (1, ureg.Unit('')))
self.assertEqual(ureg.get_base_units('meter'),
ureg.get_base_units(ParserHelper(meter=1)))
def test_get_compatible_units(self):
ureg = UnitRegistry()
assert ureg.get_compatible_units("") == frozenset()
assert ureg.get_compatible_units("meter") == ureg.get_compatible_units(
ParserHelper(meter=1)
)
def setUp(self):
super(TestCompatibleUnits, self).setUp()
self.ureg = UnitRegistry(force_ndarray=self.FORCE_NDARRAY)
self.Q_ = self.ureg.Quantity
self.U_ = self.ureg.Unit
def test_iterate(self):
ureg = UnitRegistry()
self.assertTrue("meter" in list(ureg))
def test_get_compatible_units(self):
ureg = UnitRegistry()
self.assertEqual(ureg.get_compatible_units(''), frozenset())
self.assertEqual(ureg.get_compatible_units('meter'),
ureg.get_compatible_units(ParserHelper(meter=1)))
def test_define(self):
ureg = UnitRegistry(None)
assert isinstance(dir(ureg), list)
assert len(dir(ureg)) > 0
def test_parse_with_force_ndarray(self):
ureg = UnitRegistry(force_ndarray=True)
assert ureg.parse_expression("m * s ** -2").units == ureg.m / ureg.s ** 2
def setUp(self):
super(TestCompatibleUnits, self).setUp()
self.ureg = UnitRegistry(force_ndarray=self.FORCE_NDARRAY)
self.Q_ = self.ureg.Quantity
self.U_ = self.ureg.Unit
def test_base(self):
ureg = UnitRegistry(None)
ureg.define('meter = [length]')
self.assertRaises(ValueError, ureg.define, 'meter = [length]')
self.assertRaises(TypeError, ureg.define, list())
x = ureg.define('degC = kelvin; offset: 273.15')
def test_get_compatible_units(self):
ureg = UnitRegistry()
self.assertEqual(ureg.get_compatible_units(''), frozenset())
self.assertEqual(ureg.get_compatible_units('meter'),
ureg.get_compatible_units(ParserHelper(meter=1)))
def test_get_base_units(self):
ureg = UnitRegistry()
self.assertEqual(ureg.get_base_units(''), (1, ureg.Unit('')))
self.assertEqual(ureg.get_base_units('meter'), ureg.get_base_units(ParserHelper(meter=1)))
