def testSetFloatValue():
"""
The fraction scalar should accept a float-convertible value. Since the fraction is a subclass
from scalar, it should be able to respect the same interface.
"""
f = units.FractionScalar("length", value=FractionValue(0), unit="in")
f = f.CreateCopy(value=0.75)
assert f.GetValue("in") == FractionValue(0.75)
def testStr():
f = FractionValue(3, Fraction(5, 3))
assert str(f) == "3 5/3"
assert repr(f) == "FractionValue(3, 5/3)"
f = FractionValue(3)
assert str(f) == "3"
assert repr(f) == "FractionValue(3, 0/1)"
def testCopy():
f = FractionValue(3, (5, 3))
cf = copy.copy(f)
assert f == cf
assert f is not cf
cf.fraction.numerator = 10
cf.fraction.denominator = 4
assert f == FractionValue(3, (5, 3))
def testFractionScalarConversion():
db = units.UnitDatabase()
db.AddUnit("length", "milimeters", "mm", "%f * 1000.0", "%f / 1000.0")
db.AddUnitBase("length", "meters", "m")
f = units.FractionScalar("length",
value=FractionValue(3, (1, 2)),
unit="m")
converted = db.Convert("length", "m", "mm", f.value)
assert converted == FractionValue(3500)
def testComparison():
f1 = units.FractionScalar("length", value=FractionValue(10), unit="in")
f3 = units.FractionScalar("volume", value=FractionValue(4), unit="m3")
with pytest.raises(TypeError):
f1 < f3
f2 = units.FractionScalar("length", unit="in")
f1 = f1.CreateCopy(value=FractionValue(250, (1, 2)), unit="m")
f2 = f2.CreateCopy(value=FractionValue(220, (3, 4)), unit="m")
assert f1 > f2
assert f2 < f1
def testFractionScalarWithDefaultValueOnCategory(unit_database_len):
"""
FractionScalar is not considering the default value from category on initialization
"""
db = unit_database_len
db.AddCategory("my length",
"length",
default_value=FractionValue(5, (1, 2)))
scalar = units.FractionScalar("my length", unit="m")
assert scalar.GetValue("m") == FractionValue(5, (1, 2))
assert scalar.GetUnit() == "m"
assert scalar.GetFormatted() == "5 1/2 [m]"
def ConvertFractionValue(cls, fraction_value, quantity, from_unit, to_unit):
"""
Converts the given fraction value to the given unit.
:type fraction_value: L{FractionValue}
:param fraction_value:
the fraction value to convert
:type quantity: IQuantity or str
:param quantity:
the IQuantity object to use in the conversion, or the quantity type itself
:type from_unit: L{FractionValue}
:param from_unit:
current unit of the given fraction value
:type to_unit: L{FractionValue}
:param to_unit:
the unit to convert the fraction value to
:rtype: L{FractionValue}
:returns:
the converted fraction value
"""
# check if a quantity type str was passed
if quantity.__class__ == str:
# Note: actually ignoring the initial quantity type in this case because we
# do the operation just using the from unit which may have any category (i.e.
# the important thing is the quantity type, so, it can be created with the
# default category).
quantity = ObtainQuantity(from_unit)
convert_to_quantity = ObtainQuantity(from_unit, quantity.GetComposingCategories())
converted_number = convert_to_quantity.ConvertScalarValue(
fraction_value.GetNumber(), to_unit
)
# convert the number
result = FractionValue(number=converted_number)
# convert fraction's numerator
if fraction_value.GetFraction() is not None:
converted_numerator = convert_to_quantity.ConvertScalarValue(
fraction_value.GetFraction().numerator, to_unit
)
converted_fraction = copy.copy(fraction_value.GetFraction())
converted_fraction.numerator = converted_numerator
result.SetFraction(converted_fraction)
return result
def _InternalCreateWithQuantity(self, quantity, value, unit_database=None):
"""
For internal use only. Is used to initialize the actual quantity.
:type quantity: str or IQuantity
:param quantity:
The quantity of this scalar.
:param FractionValue value:
The initial value
"""
# Considering fraction values values are easily coerced from float values (though it is
# important to note the opposite is not true) if the input value is not a fraction already
# try to convert value to float. This also makes this subclass SetValue interface compatible
# with superclass interface.
try:
if type(value) != FractionValue:
value = FractionValue(number=float(value))
except Exception:
# If not a fraction and coercion to float fails, use CheckType to provide a better error
# message.
CheckType(value, (FractionValue, float))
self._value = value
self._quantity = quantity
self._unit_database = unit_database or UnitDatabase.GetSingleton()
def ConvertFractionScalar(db_unit, quantity_type, from_unit, to_unit,
value):
"""
Converts the given Fraction Scalar by applying the converts method of this class.
"""
converted = cls.ConvertFractionValue(value, quantity_type,
from_unit, to_unit)
return FractionValue(number=float(converted))
def testConvertFractionValues(unit_database_custom_conversion) -> None:
"""
Test unit database handling fraction values.
"""
db = unit_database_custom_conversion
# Converting half meter to cm
value = FractionValue(0, (1, 2))
value = db.Convert("length", "m", "cm", value)
assert float(value) == 50
def testRegisterTwoFunctionsForTheSameClass(unit_database_custom_conversion):
"""
Test the behavior when we attempt to register two convert functions for the same class
"""
def ConvertFunction1(*args, **kwargs):
return 0
db = unit_database_custom_conversion
# There is a function specialized in convert fraction values. Attempting to register another
# function should raise an error
value = FractionValue(0, (1, 2))
db.Convert("length", "m", "cm", value)
with pytest.raises(AssertionError):
db.RegisterAdditionalConversionType(FractionValue, ConvertFunction1)
def testBasicUsage():
f = FractionValue(3, Fraction(5, 3))
assert f.number == 3
assert f.fraction == Fraction(5, 3)
f.number = 5.5
f.fraction = Fraction(6, 5)
assert f.number == 5.5
assert f.fraction == Fraction(6, 5)
with pytest.raises(TypeError):
f.SetNumber("hello")
with pytest.raises(TypeError):
f.SetFraction("hello")
with pytest.raises(ValueError):
f.SetFraction((1, 2, 3))
assert FractionValue(3).GetFraction() == Fraction(0, 1)
def testPartsArentNone():
"""
FractionValue can't be initialized nor modified to have None as number or fraction part.
"""
with pytest.raises(TypeError):
FractionValue(1, None)
with pytest.raises(TypeError):
FractionValue(None, (0 / 1))
with pytest.raises(TypeError):
FractionValue(None, None)
f = FractionValue(1, Fraction(0, 1))
with pytest.raises(TypeError):
f.SetNumber(None)
with pytest.raises(TypeError):
f.SetFraction(None)
def testFractionScalarInvalidValue(unit_database_len):
db = unit_database_len
db.AddCategory("another-length", "length", min_value=5, max_value=15)
scalar = units.FractionScalar("another-length",
value=FractionValue(1, (1, 5)),
unit="m")
assert not scalar.IsValid()
with pytest.raises(ValueError):
scalar.CheckValidity()
# By default the validation will be performed, 10 is a valid value
scalar = scalar.CreateCopy(value=FractionValue(10))
assert scalar.IsValid()
# Even invalid ,the scalar returns the value, unit and a formatted text.
another = units.FractionScalar("another-length",
value=FractionValue(3000),
unit="m")
assert not another.IsValid()
assert another.GetValue("m") == FractionValue(3000)
assert another.GetUnit() == "m"
assert another.GetFormatted() == "3000 [m]"
# By default the validation will be performed, and in this cases will raise ValueError.
another_2 = scalar.CreateCopy(value=FractionValue(5000))
assert not another_2.IsValid()
another_3 = units.FractionScalar("another-length",
unit="m",
value=FractionValue(5000))
assert not another_3.IsValid()
# Performing copy between invalid fraction scalars. The validation is not performed on copy.
copied = another.Copy()
assert not copied.IsValid()
assert copied.GetValue("m") == FractionValue(3000)
assert copied.GetUnit() == "m"
assert copied.GetFormatted() == "3000 [m]"
def AssertCreateFromString(text, whole, fraction=None):
assert (FractionValue.CreateFromString(text) == FractionValue(
whole, fraction) if fraction is not None else FractionValue(whole))
def testDefault():
f = FractionValue()
assert f.number == 0.0
assert f.fraction == Fraction(0, 1)
def testEquality():
assert FractionValue(3, Fraction(5, 3)) == FractionValue(3, Fraction(5, 3))
assert not FractionValue(3, Fraction(5, 3)) != FractionValue(
3, Fraction(5, 3))
assert FractionValue(3) == FractionValue(3)
assert not FractionValue(3) != FractionValue(3)
assert FractionValue(10, Fraction(5, 3)) != FractionValue(
3, Fraction(5, 3))
assert not FractionValue(10, Fraction(5, 3)) == FractionValue(
3, Fraction(5, 3))
assert FractionValue(10, (5, 3)) == FractionValue(10, Fraction(5, 3))
def testFormatValue():
f = units.FractionScalar("length",
value=FractionValue(250.0, (3, 4)),
unit="m")
assert f.GetFormattedValue() == "250 3/4"
def testFractionScalar():
# create our scalar
f = units.FractionScalar("length",
value=FractionValue(250, (3, 4)),
unit="m")
# check formatting
assert f.GetFormatted() == "250 3/4 [m]"
# check conversion
# f.unit = 'km'
assert f.GetValue("km") == FractionValue(0.25, (3 / 1000.0, 4))
assert f.GetValue("m") == FractionValue(250.0, (3, 4))
# test no fraction part
f = f.CreateCopy(value=FractionValue(0.25), unit="km")
assert f.value == FractionValue(0.25)
assert f.GetFormatted() == "0.25 [km]"
# set fraction again
f = f.CreateCopy(value=FractionValue(250, (3, 4)), unit="m")
assert f.GetValue("km") == FractionValue(0.25, (3 / 1000.0, 4))
assert f.GetFormatted() == "250 3/4 [m]"
assert f.GetValue("m") == FractionValue(250, (3, 4))
f = f.CreateCopy(value=FractionValue(0.25, (3, 4)), unit="km")
assert f.value == FractionValue(0.25, (3, 4))
assert f.GetFormatted() == "0.25 3/4 [km]"
assert f.GetValue("m") == FractionValue(250.0, (3000, 4))
with pytest.raises(AttributeError):
setattr(f, "value", 10)
def testRepr():
assert repr(FractionValue(250, (3, 4))) == "FractionValue(250, 3/4)"
def Create(number, fraction):
return units.FractionScalar("length",
value=FractionValue(number, fraction),
unit="m")
def testCopy():
f = units.FractionScalar("length",
value=FractionValue(250.0, (3, 4)),
unit="m")
c = copy.copy(f)
assert c.value == FractionValue(250.0, (3, 4))
def testComparison():
assert FractionValue(3) < FractionValue(3, (3, 4))
assert FractionValue(3) <= FractionValue(3, (3, 4))
assert FractionValue(3, (3, 4)) > FractionValue(3)
assert FractionValue(3, (3, 4)) >= FractionValue(3)
def testMatchFractionPart():
# Text Ok, should not raise error
FractionValue.MatchFractionPart("3/4")
with pytest.raises(ValueError):
FractionValue.MatchFractionPart("2 3/4")
def testCreateFromFloat():
"""
Allow the user enter only the fraction value
"""
assert FractionValue.CreateFromFloat(1.375) == FractionValue(1, (3, 8))
assert FractionValue.CreateFromFloat(2.5) == FractionValue(2, (1, 2))
def testFloat():
assert float(FractionValue(3, Fraction(5, 3))) == 3 + 5 / 3.0
assert float(FractionValue(3)) == 3.0
