def test_get_xlsx_validation(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(
registry,
none=True,
unique=True,
default_cleaned_value=registry.parse_expression('1 g'))
attr.get_xlsx_validation()
attr = units.QuantityAttribute(registry, none=False, unique=False)
attr.get_xlsx_validation()
def test_value_equal(self):
registry1 = unit_registry
registry2 = pint.UnitRegistry()
registry3 = pint.UnitRegistry()
attr = units.QuantityAttribute(unit_registry)
self.assertTrue(
attr.value_equal(registry1.parse_expression('2 g'),
registry1.parse_expression('2 g')))
self.assertFalse(
attr.value_equal(registry1.parse_expression('2 g'),
registry2.parse_expression('2 g')))
self.assertTrue(
attr.value_equal(registry1.parse_expression('3 M'),
registry1.parse_expression('3 mol / l')))
self.assertTrue(attr.value_equal(None, None))
self.assertFalse(
attr.value_equal(None, registry1.parse_expression('2 mol / l')))
self.assertFalse(
attr.value_equal('2 g', registry1.parse_expression('2 g')))
self.assertFalse(
attr.value_equal(registry1.parse_expression('2 mol / l'), None))
self.assertFalse(
attr.value_equal(registry1.parse_expression('2 g'),
registry1.parse_expression('2 l')))
self.assertFalse(
attr.value_equal(registry1.parse_expression('2 mg'),
registry1.parse_expression('2 g')))
self.assertTrue(
attr.value_equal(registry1.parse_expression('2000 mg'),
registry1.parse_expression('2 g')))
self.assertTrue(
attr.value_equal(registry1.parse_expression('2 ml'),
registry1.parse_expression('2 cm^3')))
def test_from_builtin(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(registry)
self.assertEqual(attr.from_builtin(''), None)
self.assertEqual(attr.from_builtin(None), None)
self.assertEqual(attr.from_builtin({
'magnitude': 1,
'units': 's'
}), registry.parse_expression('s'))
def test_to_builtin(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(registry)
self.assertEqual(attr.to_builtin(''), None)
self.assertEqual(attr.to_builtin(None), None)
self.assertEqual(attr.to_builtin(registry.parse_expression('s')), {
'magnitude': 1.0,
'units': 'second',
})
def test_serialize(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(registry)
self.assertEqual(attr.serialize(''), '')
self.assertEqual(attr.serialize(None), '')
self.assertEqual(attr.serialize(registry.parse_expression('s')),
'1 second')
self.assertEqual(
attr.serialize(registry.parse_expression('dimensionless')),
'1 dimensionless')
def test_init(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(
registry,
choices=[registry.parse_units('s'),
registry.parse_units('g')],
default=registry.parse_expression('4 s'),
default_cleaned_value=registry.parse_expression('3 g'))
self.assertEqual(len(attr.choices), 2)
attr = units.QuantityAttribute(registry)
self.assertEqual(attr.choices, None)
with self.assertRaisesRegex(ValueError,
'`registry` must be an instance of'):
units.QuantityAttribute('registry')
with self.assertRaisesRegex(ValueError,
'`default` must be an instance of'):
units.QuantityAttribute(registry, default='2 g')
with self.assertRaisesRegex(
ValueError, '`default_cleaned_value` must be an instance of'):
units.QuantityAttribute(registry, default_cleaned_value='3 m')
with self.assertRaisesRegex(ValueError,
'choices must be instances of'):
units.QuantityAttribute(registry, choices=['g'])
def test_validate(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(registry,
choices=[registry.parse_units('s')])
self.assertNotEqual(attr.validate(None, ''), None)
self.assertEqual(attr.validate(None, None), None)
self.assertEqual(attr.validate(None, registry.parse_expression('s')),
None)
self.assertNotEqual(
attr.validate(None, registry.parse_expression('g')), None)
self.assertNotEqual(attr.validate(None, 's'), None)
self.assertNotEqual(attr.validate(None, 2.), None)
attr = units.QuantityAttribute(registry)
self.assertEqual(attr.validate(None, None), None)
self.assertEqual(attr.validate(None, registry.parse_expression('s')),
None)
self.assertEqual(attr.validate(None, registry.parse_expression('g')),
None)
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(registry, none=False)
self.assertNotEqual(attr.validate(None, None), None)
def test_clean(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(
registry, default_cleaned_value=registry.parse_expression('g'))
self.assertEqual(attr.clean(''),
(registry.parse_expression('g'), None))
self.assertEqual(attr.clean(None),
(registry.parse_expression('g'), None))
self.assertEqual(attr.clean('s'),
(registry.parse_expression('s'), None))
self.assertEqual(attr.clean('dimensionless'),
(registry.parse_expression('dimensionless'), None))
self.assertNotEqual(attr.clean('dimensionless')[0], None)
self.assertEqual(attr.clean(registry.parse_expression('s')),
(registry.parse_expression('s'), None))
self.assertNotEqual(attr.clean(1.)[1], None)
self.assertNotEqual(attr.clean('not_a_unit')[1], None)
attr = units.QuantityAttribute(registry, default_cleaned_value=None)
self.assertEqual(attr.clean(''), (None, None))
self.assertEqual(attr.clean(None), (None, None))
self.assertEqual(attr.clean('s'),
(registry.parse_expression('s'), None))
def test_copy_value(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(registry)
unit = registry.parse_expression('s')
self.assertTrue(attr.value_equal(attr.copy_value(unit, {}), unit))
def test_get_default_cleaned_value(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(
registry, default_cleaned_value=registry.parse_expression('3 g'))
self.assertEqual(attr.get_default_cleaned_value(),
registry.parse_expression('3 g'))
def test_get_default(self):
registry = pint.UnitRegistry()
attr = units.QuantityAttribute(
registry, default=registry.parse_expression('2 s'))
self.assertEqual(attr.get_default(),
registry.Quantity(2, registry.parse_units('s')))
