Use unit enums in unit utilities (#81030)
This commit is contained in:
epenet
GitHub
parent
37cfa3e19b
commit
2a2e097e17
5 changed files with 690 additions and 591 deletions
|
|
@ -2,39 +2,6 @@
|
|||
from __future__ import annotations
|
||||
|
||||
from homeassistant.const import (
|
||||
LENGTH_CENTIMETERS,
|
||||
LENGTH_FEET,
|
||||
LENGTH_INCHES,
|
||||
LENGTH_KILOMETERS,
|
||||
LENGTH_METERS,
|
||||
LENGTH_MILES,
|
||||
LENGTH_MILLIMETERS,
|
||||
LENGTH_YARD,
|
||||
MASS_GRAMS,
|
||||
MASS_KILOGRAMS,
|
||||
MASS_MICROGRAMS,
|
||||
MASS_MILLIGRAMS,
|
||||
MASS_OUNCES,
|
||||
MASS_POUNDS,
|
||||
POWER_KILO_WATT,
|
||||
POWER_WATT,
|
||||
PRESSURE_BAR,
|
||||
PRESSURE_CBAR,
|
||||
PRESSURE_HPA,
|
||||
PRESSURE_INHG,
|
||||
PRESSURE_KPA,
|
||||
PRESSURE_MBAR,
|
||||
PRESSURE_MMHG,
|
||||
PRESSURE_PA,
|
||||
PRESSURE_PSI,
|
||||
SPEED_FEET_PER_SECOND,
|
||||
SPEED_KILOMETERS_PER_HOUR,
|
||||
SPEED_KNOTS,
|
||||
SPEED_METERS_PER_SECOND,
|
||||
SPEED_MILES_PER_HOUR,
|
||||
TEMP_CELSIUS,
|
||||
TEMP_FAHRENHEIT,
|
||||
TEMP_KELVIN,
|
||||
UNIT_NOT_RECOGNIZED_TEMPLATE,
|
||||
VOLUME_CUBIC_FEET,
|
||||
VOLUME_CUBIC_METERS,
|
||||
|
|
@ -43,6 +10,12 @@ from homeassistant.const import (
|
|||
VOLUME_LITERS,
|
||||
VOLUME_MILLILITERS,
|
||||
UnitOfEnergy,
|
||||
UnitOfLength,
|
||||
UnitOfMass,
|
||||
UnitOfPower,
|
||||
UnitOfPressure,
|
||||
UnitOfSpeed,
|
||||
UnitOfTemperature,
|
||||
UnitOfVolumetricFlux,
|
||||
)
|
||||
from homeassistant.exceptions import HomeAssistantError
|
||||
|
|
@ -121,26 +94,26 @@ class DistanceConverter(BaseUnitConverter):
|
|||
"""Utility to convert distance values."""
|
||||
|
||||
UNIT_CLASS = "distance"
|
||||
NORMALIZED_UNIT = LENGTH_METERS
|
||||
NORMALIZED_UNIT = UnitOfLength.METERS
|
||||
_UNIT_CONVERSION: dict[str, float] = {
|
||||
LENGTH_METERS: 1,
|
||||
LENGTH_MILLIMETERS: 1 / _MM_TO_M,
|
||||
LENGTH_CENTIMETERS: 1 / _CM_TO_M,
|
||||
LENGTH_KILOMETERS: 1 / _KM_TO_M,
|
||||
LENGTH_INCHES: 1 / _IN_TO_M,
|
||||
LENGTH_FEET: 1 / _FOOT_TO_M,
|
||||
LENGTH_YARD: 1 / _YARD_TO_M,
|
||||
LENGTH_MILES: 1 / _MILE_TO_M,
|
||||
UnitOfLength.METERS: 1,
|
||||
UnitOfLength.MILLIMETERS: 1 / _MM_TO_M,
|
||||
UnitOfLength.CENTIMETERS: 1 / _CM_TO_M,
|
||||
UnitOfLength.KILOMETERS: 1 / _KM_TO_M,
|
||||
UnitOfLength.INCHES: 1 / _IN_TO_M,
|
||||
UnitOfLength.FEET: 1 / _FOOT_TO_M,
|
||||
UnitOfLength.YARDS: 1 / _YARD_TO_M,
|
||||
UnitOfLength.MILES: 1 / _MILE_TO_M,
|
||||
}
|
||||
VALID_UNITS = {
|
||||
LENGTH_KILOMETERS,
|
||||
LENGTH_MILES,
|
||||
LENGTH_FEET,
|
||||
LENGTH_METERS,
|
||||
LENGTH_CENTIMETERS,
|
||||
LENGTH_MILLIMETERS,
|
||||
LENGTH_INCHES,
|
||||
LENGTH_YARD,
|
||||
UnitOfLength.KILOMETERS,
|
||||
UnitOfLength.MILES,
|
||||
UnitOfLength.FEET,
|
||||
UnitOfLength.METERS,
|
||||
UnitOfLength.CENTIMETERS,
|
||||
UnitOfLength.MILLIMETERS,
|
||||
UnitOfLength.INCHES,
|
||||
UnitOfLength.YARDS,
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -167,22 +140,22 @@ class MassConverter(BaseUnitConverter):
|
|||
"""Utility to convert mass values."""
|
||||
|
||||
UNIT_CLASS = "mass"
|
||||
NORMALIZED_UNIT = MASS_GRAMS
|
||||
NORMALIZED_UNIT = UnitOfMass.GRAMS
|
||||
_UNIT_CONVERSION: dict[str, float] = {
|
||||
MASS_MICROGRAMS: 1 * 1000 * 1000,
|
||||
MASS_MILLIGRAMS: 1 * 1000,
|
||||
MASS_GRAMS: 1,
|
||||
MASS_KILOGRAMS: 1 / 1000,
|
||||
MASS_OUNCES: 1 / _OUNCE_TO_G,
|
||||
MASS_POUNDS: 1 / _POUND_TO_G,
|
||||
UnitOfMass.MICROGRAMS: 1 * 1000 * 1000,
|
||||
UnitOfMass.MILLIGRAMS: 1 * 1000,
|
||||
UnitOfMass.GRAMS: 1,
|
||||
UnitOfMass.KILOGRAMS: 1 / 1000,
|
||||
UnitOfMass.OUNCES: 1 / _OUNCE_TO_G,
|
||||
UnitOfMass.POUNDS: 1 / _POUND_TO_G,
|
||||
}
|
||||
VALID_UNITS = {
|
||||
MASS_GRAMS,
|
||||
MASS_KILOGRAMS,
|
||||
MASS_MILLIGRAMS,
|
||||
MASS_MICROGRAMS,
|
||||
MASS_OUNCES,
|
||||
MASS_POUNDS,
|
||||
UnitOfMass.GRAMS,
|
||||
UnitOfMass.KILOGRAMS,
|
||||
UnitOfMass.MILLIGRAMS,
|
||||
UnitOfMass.MICROGRAMS,
|
||||
UnitOfMass.OUNCES,
|
||||
UnitOfMass.POUNDS,
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -190,14 +163,14 @@ class PowerConverter(BaseUnitConverter):
|
|||
"""Utility to convert power values."""
|
||||
|
||||
UNIT_CLASS = "power"
|
||||
NORMALIZED_UNIT = POWER_WATT
|
||||
NORMALIZED_UNIT = UnitOfPower.WATT
|
||||
_UNIT_CONVERSION: dict[str, float] = {
|
||||
POWER_WATT: 1,
|
||||
POWER_KILO_WATT: 1 / 1000,
|
||||
UnitOfPower.WATT: 1,
|
||||
UnitOfPower.KILO_WATT: 1 / 1000,
|
||||
}
|
||||
VALID_UNITS = {
|
||||
POWER_WATT,
|
||||
POWER_KILO_WATT,
|
||||
UnitOfPower.WATT,
|
||||
UnitOfPower.KILO_WATT,
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -205,28 +178,30 @@ class PressureConverter(BaseUnitConverter):
|
|||
"""Utility to convert pressure values."""
|
||||
|
||||
UNIT_CLASS = "pressure"
|
||||
NORMALIZED_UNIT = PRESSURE_PA
|
||||
NORMALIZED_UNIT = UnitOfPressure.PA
|
||||
_UNIT_CONVERSION: dict[str, float] = {
|
||||
PRESSURE_PA: 1,
|
||||
PRESSURE_HPA: 1 / 100,
|
||||
PRESSURE_KPA: 1 / 1000,
|
||||
PRESSURE_BAR: 1 / 100000,
|
||||
PRESSURE_CBAR: 1 / 1000,
|
||||
PRESSURE_MBAR: 1 / 100,
|
||||
PRESSURE_INHG: 1 / (_IN_TO_M * 1000 * _STANDARD_GRAVITY * _MERCURY_DENSITY),
|
||||
PRESSURE_PSI: 1 / 6894.757,
|
||||
PRESSURE_MMHG: 1 / (_MM_TO_M * 1000 * _STANDARD_GRAVITY * _MERCURY_DENSITY),
|
||||
UnitOfPressure.PA: 1,
|
||||
UnitOfPressure.HPA: 1 / 100,
|
||||
UnitOfPressure.KPA: 1 / 1000,
|
||||
UnitOfPressure.BAR: 1 / 100000,
|
||||
UnitOfPressure.CBAR: 1 / 1000,
|
||||
UnitOfPressure.MBAR: 1 / 100,
|
||||
UnitOfPressure.INHG: 1
|
||||
/ (_IN_TO_M * 1000 * _STANDARD_GRAVITY * _MERCURY_DENSITY),
|
||||
UnitOfPressure.PSI: 1 / 6894.757,
|
||||
UnitOfPressure.MMHG: 1
|
||||
/ (_MM_TO_M * 1000 * _STANDARD_GRAVITY * _MERCURY_DENSITY),
|
||||
}
|
||||
VALID_UNITS = {
|
||||
PRESSURE_PA,
|
||||
PRESSURE_HPA,
|
||||
PRESSURE_KPA,
|
||||
PRESSURE_BAR,
|
||||
PRESSURE_CBAR,
|
||||
PRESSURE_MBAR,
|
||||
PRESSURE_INHG,
|
||||
PRESSURE_PSI,
|
||||
PRESSURE_MMHG,
|
||||
UnitOfPressure.PA,
|
||||
UnitOfPressure.HPA,
|
||||
UnitOfPressure.KPA,
|
||||
UnitOfPressure.BAR,
|
||||
UnitOfPressure.CBAR,
|
||||
UnitOfPressure.MBAR,
|
||||
UnitOfPressure.INHG,
|
||||
UnitOfPressure.PSI,
|
||||
UnitOfPressure.MMHG,
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -234,28 +209,28 @@ class SpeedConverter(BaseUnitConverter):
|
|||
"""Utility to convert speed values."""
|
||||
|
||||
UNIT_CLASS = "speed"
|
||||
NORMALIZED_UNIT = SPEED_METERS_PER_SECOND
|
||||
NORMALIZED_UNIT = UnitOfSpeed.METERS_PER_SECOND
|
||||
_UNIT_CONVERSION: dict[str, float] = {
|
||||
UnitOfVolumetricFlux.INCHES_PER_DAY: _DAYS_TO_SECS / _IN_TO_M,
|
||||
UnitOfVolumetricFlux.INCHES_PER_HOUR: _HRS_TO_SECS / _IN_TO_M,
|
||||
UnitOfVolumetricFlux.MILLIMETERS_PER_DAY: _DAYS_TO_SECS / _MM_TO_M,
|
||||
UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR: _HRS_TO_SECS / _MM_TO_M,
|
||||
SPEED_FEET_PER_SECOND: 1 / _FOOT_TO_M,
|
||||
SPEED_KILOMETERS_PER_HOUR: _HRS_TO_SECS / _KM_TO_M,
|
||||
SPEED_KNOTS: _HRS_TO_SECS / _NAUTICAL_MILE_TO_M,
|
||||
SPEED_METERS_PER_SECOND: 1,
|
||||
SPEED_MILES_PER_HOUR: _HRS_TO_SECS / _MILE_TO_M,
|
||||
UnitOfSpeed.FEET_PER_SECOND: 1 / _FOOT_TO_M,
|
||||
UnitOfSpeed.KILOMETERS_PER_HOUR: _HRS_TO_SECS / _KM_TO_M,
|
||||
UnitOfSpeed.KNOTS: _HRS_TO_SECS / _NAUTICAL_MILE_TO_M,
|
||||
UnitOfSpeed.METERS_PER_SECOND: 1,
|
||||
UnitOfSpeed.MILES_PER_HOUR: _HRS_TO_SECS / _MILE_TO_M,
|
||||
}
|
||||
VALID_UNITS = {
|
||||
UnitOfVolumetricFlux.INCHES_PER_DAY,
|
||||
UnitOfVolumetricFlux.INCHES_PER_HOUR,
|
||||
UnitOfVolumetricFlux.MILLIMETERS_PER_DAY,
|
||||
UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR,
|
||||
SPEED_FEET_PER_SECOND,
|
||||
SPEED_KILOMETERS_PER_HOUR,
|
||||
SPEED_KNOTS,
|
||||
SPEED_METERS_PER_SECOND,
|
||||
SPEED_MILES_PER_HOUR,
|
||||
UnitOfSpeed.FEET_PER_SECOND,
|
||||
UnitOfSpeed.KILOMETERS_PER_HOUR,
|
||||
UnitOfSpeed.KNOTS,
|
||||
UnitOfSpeed.METERS_PER_SECOND,
|
||||
UnitOfSpeed.MILES_PER_HOUR,
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -263,16 +238,16 @@ class TemperatureConverter(BaseUnitConverter):
|
|||
"""Utility to convert temperature values."""
|
||||
|
||||
UNIT_CLASS = "temperature"
|
||||
NORMALIZED_UNIT = TEMP_CELSIUS
|
||||
NORMALIZED_UNIT = UnitOfTemperature.CELSIUS
|
||||
VALID_UNITS = {
|
||||
TEMP_CELSIUS,
|
||||
TEMP_FAHRENHEIT,
|
||||
TEMP_KELVIN,
|
||||
UnitOfTemperature.CELSIUS,
|
||||
UnitOfTemperature.FAHRENHEIT,
|
||||
UnitOfTemperature.KELVIN,
|
||||
}
|
||||
_UNIT_CONVERSION = {
|
||||
TEMP_CELSIUS: 1.0,
|
||||
TEMP_FAHRENHEIT: 1.8,
|
||||
TEMP_KELVIN: 1.0,
|
||||
UnitOfTemperature.CELSIUS: 1.0,
|
||||
UnitOfTemperature.FAHRENHEIT: 1.8,
|
||||
UnitOfTemperature.KELVIN: 1.0,
|
||||
}
|
||||
|
||||
@classmethod
|
||||
|
|
@ -289,28 +264,28 @@ class TemperatureConverter(BaseUnitConverter):
|
|||
if from_unit == to_unit:
|
||||
return value
|
||||
|
||||
if from_unit == TEMP_CELSIUS:
|
||||
if to_unit == TEMP_FAHRENHEIT:
|
||||
if from_unit == UnitOfTemperature.CELSIUS:
|
||||
if to_unit == UnitOfTemperature.FAHRENHEIT:
|
||||
return cls._celsius_to_fahrenheit(value)
|
||||
if to_unit == TEMP_KELVIN:
|
||||
if to_unit == UnitOfTemperature.KELVIN:
|
||||
return cls._celsius_to_kelvin(value)
|
||||
raise HomeAssistantError(
|
||||
UNIT_NOT_RECOGNIZED_TEMPLATE.format(to_unit, cls.UNIT_CLASS)
|
||||
)
|
||||
|
||||
if from_unit == TEMP_FAHRENHEIT:
|
||||
if to_unit == TEMP_CELSIUS:
|
||||
if from_unit == UnitOfTemperature.FAHRENHEIT:
|
||||
if to_unit == UnitOfTemperature.CELSIUS:
|
||||
return cls._fahrenheit_to_celsius(value)
|
||||
if to_unit == TEMP_KELVIN:
|
||||
if to_unit == UnitOfTemperature.KELVIN:
|
||||
return cls._celsius_to_kelvin(cls._fahrenheit_to_celsius(value))
|
||||
raise HomeAssistantError(
|
||||
UNIT_NOT_RECOGNIZED_TEMPLATE.format(to_unit, cls.UNIT_CLASS)
|
||||
)
|
||||
|
||||
if from_unit == TEMP_KELVIN:
|
||||
if to_unit == TEMP_CELSIUS:
|
||||
if from_unit == UnitOfTemperature.KELVIN:
|
||||
if to_unit == UnitOfTemperature.CELSIUS:
|
||||
return cls._kelvin_to_celsius(value)
|
||||
if to_unit == TEMP_FAHRENHEIT:
|
||||
if to_unit == UnitOfTemperature.FAHRENHEIT:
|
||||
return cls._celsius_to_fahrenheit(cls._kelvin_to_celsius(value))
|
||||
raise HomeAssistantError(
|
||||
UNIT_NOT_RECOGNIZED_TEMPLATE.format(to_unit, cls.UNIT_CLASS)
|
||||
|
|
|
|||
|
|
@ -9,40 +9,18 @@ import voluptuous as vol
|
|||
from homeassistant.const import (
|
||||
ACCUMULATED_PRECIPITATION,
|
||||
LENGTH,
|
||||
LENGTH_CENTIMETERS,
|
||||
LENGTH_FEET,
|
||||
LENGTH_INCHES,
|
||||
LENGTH_KILOMETERS,
|
||||
LENGTH_METERS,
|
||||
LENGTH_MILES,
|
||||
LENGTH_MILLIMETERS,
|
||||
LENGTH_YARD,
|
||||
MASS,
|
||||
MASS_GRAMS,
|
||||
MASS_KILOGRAMS,
|
||||
MASS_OUNCES,
|
||||
MASS_POUNDS,
|
||||
PRECIPITATION_INCHES,
|
||||
PRECIPITATION_MILLIMETERS,
|
||||
PRESSURE,
|
||||
PRESSURE_PA,
|
||||
PRESSURE_PSI,
|
||||
SPEED_FEET_PER_SECOND,
|
||||
SPEED_KILOMETERS_PER_HOUR,
|
||||
SPEED_METERS_PER_SECOND,
|
||||
SPEED_MILES_PER_HOUR,
|
||||
TEMP_CELSIUS,
|
||||
TEMP_FAHRENHEIT,
|
||||
TEMPERATURE,
|
||||
UNIT_NOT_RECOGNIZED_TEMPLATE,
|
||||
VOLUME,
|
||||
VOLUME_CUBIC_FEET,
|
||||
VOLUME_CUBIC_METERS,
|
||||
VOLUME_FLUID_OUNCE,
|
||||
VOLUME_GALLONS,
|
||||
VOLUME_LITERS,
|
||||
VOLUME_MILLILITERS,
|
||||
WIND_SPEED,
|
||||
UnitOfLength,
|
||||
UnitOfMass,
|
||||
UnitOfPressure,
|
||||
UnitOfSpeed,
|
||||
UnitOfTemperature,
|
||||
UnitOfVolume,
|
||||
)
|
||||
from homeassistant.helpers.frame import report
|
||||
|
||||
|
|
@ -63,7 +41,12 @@ _CONF_UNIT_SYSTEM_US_CUSTOMARY: Final = "us_customary"
|
|||
|
||||
LENGTH_UNITS = DistanceConverter.VALID_UNITS
|
||||
|
||||
MASS_UNITS: set[str] = {MASS_POUNDS, MASS_OUNCES, MASS_KILOGRAMS, MASS_GRAMS}
|
||||
MASS_UNITS: set[str] = {
|
||||
UnitOfMass.POUNDS,
|
||||
UnitOfMass.OUNCES,
|
||||
UnitOfMass.KILOGRAMS,
|
||||
UnitOfMass.GRAMS,
|
||||
}
|
||||
|
||||
PRESSURE_UNITS = PressureConverter.VALID_UNITS
|
||||
|
||||
|
|
@ -71,29 +54,26 @@ VOLUME_UNITS = VolumeConverter.VALID_UNITS
|
|||
|
||||
WIND_SPEED_UNITS = SpeedConverter.VALID_UNITS
|
||||
|
||||
TEMPERATURE_UNITS: set[str] = {TEMP_FAHRENHEIT, TEMP_CELSIUS}
|
||||
TEMPERATURE_UNITS: set[str] = {UnitOfTemperature.FAHRENHEIT, UnitOfTemperature.CELSIUS}
|
||||
|
||||
|
||||
def _is_valid_unit(unit: str, unit_type: str) -> bool:
|
||||
"""Check if the unit is valid for it's type."""
|
||||
if unit_type == LENGTH:
|
||||
units = LENGTH_UNITS
|
||||
elif unit_type == ACCUMULATED_PRECIPITATION:
|
||||
units = LENGTH_UNITS
|
||||
elif unit_type == WIND_SPEED:
|
||||
units = WIND_SPEED_UNITS
|
||||
elif unit_type == TEMPERATURE:
|
||||
units = TEMPERATURE_UNITS
|
||||
elif unit_type == MASS:
|
||||
units = MASS_UNITS
|
||||
elif unit_type == VOLUME:
|
||||
units = VOLUME_UNITS
|
||||
elif unit_type == PRESSURE:
|
||||
units = PRESSURE_UNITS
|
||||
else:
|
||||
return False
|
||||
|
||||
return unit in units
|
||||
return unit in LENGTH_UNITS
|
||||
if unit_type == ACCUMULATED_PRECIPITATION:
|
||||
return unit in LENGTH_UNITS
|
||||
if unit_type == WIND_SPEED:
|
||||
return unit in WIND_SPEED_UNITS
|
||||
if unit_type == TEMPERATURE:
|
||||
return unit in TEMPERATURE_UNITS
|
||||
if unit_type == MASS:
|
||||
return unit in MASS_UNITS
|
||||
if unit_type == VOLUME:
|
||||
return unit in VOLUME_UNITS
|
||||
if unit_type == PRESSURE:
|
||||
return unit in PRESSURE_UNITS
|
||||
return False
|
||||
|
||||
|
||||
class UnitSystem:
|
||||
|
|
@ -267,62 +247,62 @@ validate_unit_system = vol.All(
|
|||
|
||||
METRIC_SYSTEM = UnitSystem(
|
||||
_CONF_UNIT_SYSTEM_METRIC,
|
||||
accumulated_precipitation=PRECIPITATION_MILLIMETERS,
|
||||
accumulated_precipitation=UnitOfLength.MILLIMETERS,
|
||||
conversions={
|
||||
# Convert non-metric distances
|
||||
("distance", LENGTH_FEET): LENGTH_METERS,
|
||||
("distance", LENGTH_INCHES): LENGTH_MILLIMETERS,
|
||||
("distance", LENGTH_MILES): LENGTH_KILOMETERS,
|
||||
("distance", LENGTH_YARD): LENGTH_METERS,
|
||||
("distance", UnitOfLength.FEET): UnitOfLength.METERS,
|
||||
("distance", UnitOfLength.INCHES): UnitOfLength.MILLIMETERS,
|
||||
("distance", UnitOfLength.MILES): UnitOfLength.KILOMETERS,
|
||||
("distance", UnitOfLength.YARDS): UnitOfLength.METERS,
|
||||
# Convert non-metric volumes of gas meters
|
||||
("gas", VOLUME_CUBIC_FEET): VOLUME_CUBIC_METERS,
|
||||
("gas", UnitOfVolume.CUBIC_FEET): UnitOfVolume.CUBIC_METERS,
|
||||
# Convert non-metric speeds except knots to km/h
|
||||
("speed", SPEED_FEET_PER_SECOND): SPEED_KILOMETERS_PER_HOUR,
|
||||
("speed", SPEED_MILES_PER_HOUR): SPEED_KILOMETERS_PER_HOUR,
|
||||
("speed", UnitOfSpeed.FEET_PER_SECOND): UnitOfSpeed.KILOMETERS_PER_HOUR,
|
||||
("speed", UnitOfSpeed.MILES_PER_HOUR): UnitOfSpeed.KILOMETERS_PER_HOUR,
|
||||
# Convert non-metric volumes
|
||||
("volume", VOLUME_CUBIC_FEET): VOLUME_CUBIC_METERS,
|
||||
("volume", VOLUME_FLUID_OUNCE): VOLUME_MILLILITERS,
|
||||
("volume", VOLUME_GALLONS): VOLUME_LITERS,
|
||||
("volume", UnitOfVolume.CUBIC_FEET): UnitOfVolume.CUBIC_METERS,
|
||||
("volume", UnitOfVolume.FLUID_OUNCES): UnitOfVolume.MILLILITERS,
|
||||
("volume", UnitOfVolume.GALLONS): UnitOfVolume.LITERS,
|
||||
# Convert non-metric volumes of water meters
|
||||
("water", VOLUME_CUBIC_FEET): VOLUME_CUBIC_METERS,
|
||||
("water", VOLUME_GALLONS): VOLUME_LITERS,
|
||||
("water", UnitOfVolume.CUBIC_FEET): UnitOfVolume.CUBIC_METERS,
|
||||
("water", UnitOfVolume.GALLONS): UnitOfVolume.LITERS,
|
||||
},
|
||||
length=LENGTH_KILOMETERS,
|
||||
mass=MASS_GRAMS,
|
||||
pressure=PRESSURE_PA,
|
||||
temperature=TEMP_CELSIUS,
|
||||
volume=VOLUME_LITERS,
|
||||
wind_speed=SPEED_METERS_PER_SECOND,
|
||||
length=UnitOfLength.KILOMETERS,
|
||||
mass=UnitOfMass.GRAMS,
|
||||
pressure=UnitOfPressure.PA,
|
||||
temperature=UnitOfTemperature.CELSIUS,
|
||||
volume=UnitOfVolume.LITERS,
|
||||
wind_speed=UnitOfSpeed.METERS_PER_SECOND,
|
||||
)
|
||||
|
||||
US_CUSTOMARY_SYSTEM = UnitSystem(
|
||||
_CONF_UNIT_SYSTEM_US_CUSTOMARY,
|
||||
accumulated_precipitation=PRECIPITATION_INCHES,
|
||||
accumulated_precipitation=UnitOfLength.INCHES,
|
||||
conversions={
|
||||
# Convert non-USCS distances
|
||||
("distance", LENGTH_CENTIMETERS): LENGTH_INCHES,
|
||||
("distance", LENGTH_KILOMETERS): LENGTH_MILES,
|
||||
("distance", LENGTH_METERS): LENGTH_FEET,
|
||||
("distance", LENGTH_MILLIMETERS): LENGTH_INCHES,
|
||||
("distance", UnitOfLength.CENTIMETERS): UnitOfLength.INCHES,
|
||||
("distance", UnitOfLength.KILOMETERS): UnitOfLength.MILES,
|
||||
("distance", UnitOfLength.METERS): UnitOfLength.FEET,
|
||||
("distance", UnitOfLength.MILLIMETERS): UnitOfLength.INCHES,
|
||||
# Convert non-USCS volumes of gas meters
|
||||
("gas", VOLUME_CUBIC_METERS): VOLUME_CUBIC_FEET,
|
||||
("gas", UnitOfVolume.CUBIC_METERS): UnitOfVolume.CUBIC_FEET,
|
||||
# Convert non-USCS speeds except knots to mph
|
||||
("speed", SPEED_METERS_PER_SECOND): SPEED_MILES_PER_HOUR,
|
||||
("speed", SPEED_KILOMETERS_PER_HOUR): SPEED_MILES_PER_HOUR,
|
||||
("speed", UnitOfSpeed.METERS_PER_SECOND): UnitOfSpeed.MILES_PER_HOUR,
|
||||
("speed", UnitOfSpeed.KILOMETERS_PER_HOUR): UnitOfSpeed.MILES_PER_HOUR,
|
||||
# Convert non-USCS volumes
|
||||
("volume", VOLUME_CUBIC_METERS): VOLUME_CUBIC_FEET,
|
||||
("volume", VOLUME_LITERS): VOLUME_GALLONS,
|
||||
("volume", VOLUME_MILLILITERS): VOLUME_FLUID_OUNCE,
|
||||
("volume", UnitOfVolume.CUBIC_METERS): UnitOfVolume.CUBIC_FEET,
|
||||
("volume", UnitOfVolume.LITERS): UnitOfVolume.GALLONS,
|
||||
("volume", UnitOfVolume.MILLILITERS): UnitOfVolume.FLUID_OUNCES,
|
||||
# Convert non-USCS volumes of water meters
|
||||
("water", VOLUME_CUBIC_METERS): VOLUME_CUBIC_FEET,
|
||||
("water", VOLUME_LITERS): VOLUME_GALLONS,
|
||||
("water", UnitOfVolume.CUBIC_METERS): UnitOfVolume.CUBIC_FEET,
|
||||
("water", UnitOfVolume.LITERS): UnitOfVolume.GALLONS,
|
||||
},
|
||||
length=LENGTH_MILES,
|
||||
mass=MASS_POUNDS,
|
||||
pressure=PRESSURE_PSI,
|
||||
temperature=TEMP_FAHRENHEIT,
|
||||
volume=VOLUME_GALLONS,
|
||||
wind_speed=SPEED_MILES_PER_HOUR,
|
||||
length=UnitOfLength.MILES,
|
||||
mass=UnitOfMass.POUNDS,
|
||||
pressure=UnitOfPressure.PSI,
|
||||
temperature=UnitOfTemperature.FAHRENHEIT,
|
||||
volume=UnitOfVolume.GALLONS,
|
||||
wind_speed=UnitOfSpeed.MILES_PER_HOUR,
|
||||
)
|
||||
|
||||
IMPERIAL_SYSTEM = US_CUSTOMARY_SYSTEM
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ async def test_sensors(hass: HomeAssistant) -> None:
|
|||
state = hass.states.get("sensor.flipr_myfliprid_water_temp")
|
||||
assert state
|
||||
assert state.attributes.get(ATTR_ICON) is None
|
||||
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) is TEMP_CELSIUS
|
||||
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == TEMP_CELSIUS
|
||||
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
|
||||
assert state.state == "10.5"
|
||||
|
||||
|
|
|
|||
|
|
@ -2,45 +2,14 @@
|
|||
import pytest
|
||||
|
||||
from homeassistant.const import (
|
||||
LENGTH_CENTIMETERS,
|
||||
LENGTH_FEET,
|
||||
LENGTH_INCHES,
|
||||
LENGTH_KILOMETERS,
|
||||
LENGTH_METERS,
|
||||
LENGTH_MILES,
|
||||
LENGTH_MILLIMETERS,
|
||||
LENGTH_YARD,
|
||||
MASS_GRAMS,
|
||||
MASS_KILOGRAMS,
|
||||
MASS_MICROGRAMS,
|
||||
MASS_MILLIGRAMS,
|
||||
MASS_OUNCES,
|
||||
MASS_POUNDS,
|
||||
POWER_KILO_WATT,
|
||||
POWER_WATT,
|
||||
PRESSURE_CBAR,
|
||||
PRESSURE_HPA,
|
||||
PRESSURE_INHG,
|
||||
PRESSURE_KPA,
|
||||
PRESSURE_MBAR,
|
||||
PRESSURE_MMHG,
|
||||
PRESSURE_PA,
|
||||
PRESSURE_PSI,
|
||||
SPEED_FEET_PER_SECOND,
|
||||
SPEED_KILOMETERS_PER_HOUR,
|
||||
SPEED_KNOTS,
|
||||
SPEED_METERS_PER_SECOND,
|
||||
SPEED_MILES_PER_HOUR,
|
||||
TEMP_CELSIUS,
|
||||
TEMP_FAHRENHEIT,
|
||||
TEMP_KELVIN,
|
||||
VOLUME_CUBIC_FEET,
|
||||
VOLUME_CUBIC_METERS,
|
||||
VOLUME_FLUID_OUNCE,
|
||||
VOLUME_GALLONS,
|
||||
VOLUME_LITERS,
|
||||
VOLUME_MILLILITERS,
|
||||
UnitOfEnergy,
|
||||
UnitOfLength,
|
||||
UnitOfMass,
|
||||
UnitOfPower,
|
||||
UnitOfPressure,
|
||||
UnitOfSpeed,
|
||||
UnitOfTemperature,
|
||||
UnitOfVolume,
|
||||
UnitOfVolumetricFlux,
|
||||
)
|
||||
from homeassistant.exceptions import HomeAssistantError
|
||||
|
|
@ -62,50 +31,50 @@ INVALID_SYMBOL = "bob"
|
|||
@pytest.mark.parametrize(
|
||||
"converter,valid_unit",
|
||||
[
|
||||
(DistanceConverter, LENGTH_KILOMETERS),
|
||||
(DistanceConverter, LENGTH_METERS),
|
||||
(DistanceConverter, LENGTH_CENTIMETERS),
|
||||
(DistanceConverter, LENGTH_MILLIMETERS),
|
||||
(DistanceConverter, LENGTH_MILES),
|
||||
(DistanceConverter, LENGTH_YARD),
|
||||
(DistanceConverter, LENGTH_FEET),
|
||||
(DistanceConverter, LENGTH_INCHES),
|
||||
(DistanceConverter, UnitOfLength.KILOMETERS),
|
||||
(DistanceConverter, UnitOfLength.METERS),
|
||||
(DistanceConverter, UnitOfLength.CENTIMETERS),
|
||||
(DistanceConverter, UnitOfLength.MILLIMETERS),
|
||||
(DistanceConverter, UnitOfLength.MILES),
|
||||
(DistanceConverter, UnitOfLength.YARDS),
|
||||
(DistanceConverter, UnitOfLength.FEET),
|
||||
(DistanceConverter, UnitOfLength.INCHES),
|
||||
(EnergyConverter, UnitOfEnergy.WATT_HOUR),
|
||||
(EnergyConverter, UnitOfEnergy.KILO_WATT_HOUR),
|
||||
(EnergyConverter, UnitOfEnergy.MEGA_WATT_HOUR),
|
||||
(EnergyConverter, UnitOfEnergy.GIGA_JOULE),
|
||||
(MassConverter, MASS_GRAMS),
|
||||
(MassConverter, MASS_KILOGRAMS),
|
||||
(MassConverter, MASS_MICROGRAMS),
|
||||
(MassConverter, MASS_MILLIGRAMS),
|
||||
(MassConverter, MASS_OUNCES),
|
||||
(MassConverter, MASS_POUNDS),
|
||||
(PowerConverter, POWER_WATT),
|
||||
(PowerConverter, POWER_KILO_WATT),
|
||||
(PressureConverter, PRESSURE_PA),
|
||||
(PressureConverter, PRESSURE_HPA),
|
||||
(PressureConverter, PRESSURE_MBAR),
|
||||
(PressureConverter, PRESSURE_INHG),
|
||||
(PressureConverter, PRESSURE_KPA),
|
||||
(PressureConverter, PRESSURE_CBAR),
|
||||
(PressureConverter, PRESSURE_MMHG),
|
||||
(PressureConverter, PRESSURE_PSI),
|
||||
(MassConverter, UnitOfMass.GRAMS),
|
||||
(MassConverter, UnitOfMass.KILOGRAMS),
|
||||
(MassConverter, UnitOfMass.MICROGRAMS),
|
||||
(MassConverter, UnitOfMass.MILLIGRAMS),
|
||||
(MassConverter, UnitOfMass.OUNCES),
|
||||
(MassConverter, UnitOfMass.POUNDS),
|
||||
(PowerConverter, UnitOfPower.WATT),
|
||||
(PowerConverter, UnitOfPower.KILO_WATT),
|
||||
(PressureConverter, UnitOfPressure.PA),
|
||||
(PressureConverter, UnitOfPressure.HPA),
|
||||
(PressureConverter, UnitOfPressure.MBAR),
|
||||
(PressureConverter, UnitOfPressure.INHG),
|
||||
(PressureConverter, UnitOfPressure.KPA),
|
||||
(PressureConverter, UnitOfPressure.CBAR),
|
||||
(PressureConverter, UnitOfPressure.MMHG),
|
||||
(PressureConverter, UnitOfPressure.PSI),
|
||||
(SpeedConverter, UnitOfVolumetricFlux.INCHES_PER_DAY),
|
||||
(SpeedConverter, UnitOfVolumetricFlux.INCHES_PER_HOUR),
|
||||
(SpeedConverter, UnitOfVolumetricFlux.MILLIMETERS_PER_DAY),
|
||||
(SpeedConverter, UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR),
|
||||
(SpeedConverter, SPEED_FEET_PER_SECOND),
|
||||
(SpeedConverter, SPEED_KILOMETERS_PER_HOUR),
|
||||
(SpeedConverter, SPEED_KNOTS),
|
||||
(SpeedConverter, SPEED_METERS_PER_SECOND),
|
||||
(SpeedConverter, SPEED_MILES_PER_HOUR),
|
||||
(TemperatureConverter, TEMP_CELSIUS),
|
||||
(TemperatureConverter, TEMP_FAHRENHEIT),
|
||||
(TemperatureConverter, TEMP_KELVIN),
|
||||
(VolumeConverter, VOLUME_LITERS),
|
||||
(VolumeConverter, VOLUME_MILLILITERS),
|
||||
(VolumeConverter, VOLUME_GALLONS),
|
||||
(VolumeConverter, VOLUME_FLUID_OUNCE),
|
||||
(SpeedConverter, UnitOfSpeed.FEET_PER_SECOND),
|
||||
(SpeedConverter, UnitOfSpeed.KILOMETERS_PER_HOUR),
|
||||
(SpeedConverter, UnitOfSpeed.KNOTS),
|
||||
(SpeedConverter, UnitOfSpeed.METERS_PER_SECOND),
|
||||
(SpeedConverter, UnitOfSpeed.MILES_PER_HOUR),
|
||||
(TemperatureConverter, UnitOfTemperature.CELSIUS),
|
||||
(TemperatureConverter, UnitOfTemperature.FAHRENHEIT),
|
||||
(TemperatureConverter, UnitOfTemperature.KELVIN),
|
||||
(VolumeConverter, UnitOfVolume.LITERS),
|
||||
(VolumeConverter, UnitOfVolume.MILLILITERS),
|
||||
(VolumeConverter, UnitOfVolume.GALLONS),
|
||||
(VolumeConverter, UnitOfVolume.FLUID_OUNCES),
|
||||
],
|
||||
)
|
||||
def test_convert_same_unit(converter: type[BaseUnitConverter], valid_unit: str) -> None:
|
||||
|
|
@ -116,16 +85,16 @@ def test_convert_same_unit(converter: type[BaseUnitConverter], valid_unit: str)
|
|||
@pytest.mark.parametrize(
|
||||
"converter,valid_unit",
|
||||
[
|
||||
(DistanceConverter, LENGTH_KILOMETERS),
|
||||
(DistanceConverter, UnitOfLength.KILOMETERS),
|
||||
(EnergyConverter, UnitOfEnergy.KILO_WATT_HOUR),
|
||||
(MassConverter, MASS_GRAMS),
|
||||
(PowerConverter, POWER_WATT),
|
||||
(PressureConverter, PRESSURE_PA),
|
||||
(SpeedConverter, SPEED_KILOMETERS_PER_HOUR),
|
||||
(TemperatureConverter, TEMP_CELSIUS),
|
||||
(TemperatureConverter, TEMP_FAHRENHEIT),
|
||||
(TemperatureConverter, TEMP_KELVIN),
|
||||
(VolumeConverter, VOLUME_LITERS),
|
||||
(MassConverter, UnitOfMass.GRAMS),
|
||||
(PowerConverter, UnitOfPower.WATT),
|
||||
(PressureConverter, UnitOfPressure.PA),
|
||||
(SpeedConverter, UnitOfSpeed.KILOMETERS_PER_HOUR),
|
||||
(TemperatureConverter, UnitOfTemperature.CELSIUS),
|
||||
(TemperatureConverter, UnitOfTemperature.FAHRENHEIT),
|
||||
(TemperatureConverter, UnitOfTemperature.KELVIN),
|
||||
(VolumeConverter, UnitOfVolume.LITERS),
|
||||
],
|
||||
)
|
||||
def test_convert_invalid_unit(
|
||||
|
|
@ -142,14 +111,14 @@ def test_convert_invalid_unit(
|
|||
@pytest.mark.parametrize(
|
||||
"converter,from_unit,to_unit",
|
||||
[
|
||||
(DistanceConverter, LENGTH_KILOMETERS, LENGTH_METERS),
|
||||
(DistanceConverter, UnitOfLength.KILOMETERS, UnitOfLength.METERS),
|
||||
(EnergyConverter, UnitOfEnergy.WATT_HOUR, UnitOfEnergy.KILO_WATT_HOUR),
|
||||
(MassConverter, MASS_GRAMS, MASS_KILOGRAMS),
|
||||
(PowerConverter, POWER_WATT, POWER_KILO_WATT),
|
||||
(PressureConverter, PRESSURE_HPA, PRESSURE_INHG),
|
||||
(SpeedConverter, SPEED_KILOMETERS_PER_HOUR, SPEED_MILES_PER_HOUR),
|
||||
(TemperatureConverter, TEMP_CELSIUS, TEMP_FAHRENHEIT),
|
||||
(VolumeConverter, VOLUME_GALLONS, VOLUME_LITERS),
|
||||
(MassConverter, UnitOfMass.GRAMS, UnitOfMass.KILOGRAMS),
|
||||
(PowerConverter, UnitOfPower.WATT, UnitOfPower.KILO_WATT),
|
||||
(PressureConverter, UnitOfPressure.HPA, UnitOfPressure.INHG),
|
||||
(SpeedConverter, UnitOfSpeed.KILOMETERS_PER_HOUR, UnitOfSpeed.MILES_PER_HOUR),
|
||||
(TemperatureConverter, UnitOfTemperature.CELSIUS, UnitOfTemperature.FAHRENHEIT),
|
||||
(VolumeConverter, UnitOfVolume.GALLONS, UnitOfVolume.LITERS),
|
||||
],
|
||||
)
|
||||
def test_convert_nonnumeric_value(
|
||||
|
|
@ -163,18 +132,33 @@ def test_convert_nonnumeric_value(
|
|||
@pytest.mark.parametrize(
|
||||
"converter,from_unit,to_unit,expected",
|
||||
[
|
||||
(DistanceConverter, LENGTH_KILOMETERS, LENGTH_METERS, 1 / 1000),
|
||||
(DistanceConverter, UnitOfLength.KILOMETERS, UnitOfLength.METERS, 1 / 1000),
|
||||
(EnergyConverter, UnitOfEnergy.WATT_HOUR, UnitOfEnergy.KILO_WATT_HOUR, 1000),
|
||||
(PowerConverter, POWER_WATT, POWER_KILO_WATT, 1000),
|
||||
(PressureConverter, PRESSURE_HPA, PRESSURE_INHG, pytest.approx(33.86389)),
|
||||
(PowerConverter, UnitOfPower.WATT, UnitOfPower.KILO_WATT, 1000),
|
||||
(
|
||||
PressureConverter,
|
||||
UnitOfPressure.HPA,
|
||||
UnitOfPressure.INHG,
|
||||
pytest.approx(33.86389),
|
||||
),
|
||||
(
|
||||
SpeedConverter,
|
||||
SPEED_KILOMETERS_PER_HOUR,
|
||||
SPEED_MILES_PER_HOUR,
|
||||
UnitOfSpeed.KILOMETERS_PER_HOUR,
|
||||
UnitOfSpeed.MILES_PER_HOUR,
|
||||
pytest.approx(1.609343),
|
||||
),
|
||||
(TemperatureConverter, TEMP_CELSIUS, TEMP_FAHRENHEIT, 1 / 1.8),
|
||||
(VolumeConverter, VOLUME_GALLONS, VOLUME_LITERS, pytest.approx(0.264172)),
|
||||
(
|
||||
TemperatureConverter,
|
||||
UnitOfTemperature.CELSIUS,
|
||||
UnitOfTemperature.FAHRENHEIT,
|
||||
1 / 1.8,
|
||||
),
|
||||
(
|
||||
VolumeConverter,
|
||||
UnitOfVolume.GALLONS,
|
||||
UnitOfVolume.LITERS,
|
||||
pytest.approx(0.264172),
|
||||
),
|
||||
],
|
||||
)
|
||||
def test_get_unit_ratio(
|
||||
|
|
@ -187,62 +171,107 @@ def test_get_unit_ratio(
|
|||
@pytest.mark.parametrize(
|
||||
"value,from_unit,expected,to_unit",
|
||||
[
|
||||
(5, LENGTH_MILES, pytest.approx(8.04672), LENGTH_KILOMETERS),
|
||||
(5, LENGTH_MILES, pytest.approx(8046.72), LENGTH_METERS),
|
||||
(5, LENGTH_MILES, pytest.approx(804672.0), LENGTH_CENTIMETERS),
|
||||
(5, LENGTH_MILES, pytest.approx(8046720.0), LENGTH_MILLIMETERS),
|
||||
(5, LENGTH_MILES, pytest.approx(8800.0), LENGTH_YARD),
|
||||
(5, LENGTH_MILES, pytest.approx(26400.0008448), LENGTH_FEET),
|
||||
(5, LENGTH_MILES, pytest.approx(316800.171072), LENGTH_INCHES),
|
||||
(5, LENGTH_YARD, pytest.approx(0.0045720000000000005), LENGTH_KILOMETERS),
|
||||
(5, LENGTH_YARD, pytest.approx(4.572), LENGTH_METERS),
|
||||
(5, LENGTH_YARD, pytest.approx(457.2), LENGTH_CENTIMETERS),
|
||||
(5, LENGTH_YARD, pytest.approx(4572), LENGTH_MILLIMETERS),
|
||||
(5, LENGTH_YARD, pytest.approx(0.002840908212), LENGTH_MILES),
|
||||
(5, LENGTH_YARD, pytest.approx(15.00000048), LENGTH_FEET),
|
||||
(5, LENGTH_YARD, pytest.approx(180.0000972), LENGTH_INCHES),
|
||||
(5000, LENGTH_FEET, pytest.approx(1.524), LENGTH_KILOMETERS),
|
||||
(5000, LENGTH_FEET, pytest.approx(1524), LENGTH_METERS),
|
||||
(5000, LENGTH_FEET, pytest.approx(152400.0), LENGTH_CENTIMETERS),
|
||||
(5000, LENGTH_FEET, pytest.approx(1524000.0), LENGTH_MILLIMETERS),
|
||||
(5000, LENGTH_FEET, pytest.approx(0.9469694040000001), LENGTH_MILES),
|
||||
(5000, LENGTH_FEET, pytest.approx(1666.66667), LENGTH_YARD),
|
||||
(5000, LENGTH_FEET, pytest.approx(60000.032400000004), LENGTH_INCHES),
|
||||
(5000, LENGTH_INCHES, pytest.approx(0.127), LENGTH_KILOMETERS),
|
||||
(5000, LENGTH_INCHES, pytest.approx(127.0), LENGTH_METERS),
|
||||
(5000, LENGTH_INCHES, pytest.approx(12700.0), LENGTH_CENTIMETERS),
|
||||
(5000, LENGTH_INCHES, pytest.approx(127000.0), LENGTH_MILLIMETERS),
|
||||
(5000, LENGTH_INCHES, pytest.approx(0.078914117), LENGTH_MILES),
|
||||
(5000, LENGTH_INCHES, pytest.approx(138.88889), LENGTH_YARD),
|
||||
(5000, LENGTH_INCHES, pytest.approx(416.66668), LENGTH_FEET),
|
||||
(5, LENGTH_KILOMETERS, pytest.approx(5000), LENGTH_METERS),
|
||||
(5, LENGTH_KILOMETERS, pytest.approx(500000), LENGTH_CENTIMETERS),
|
||||
(5, LENGTH_KILOMETERS, pytest.approx(5000000), LENGTH_MILLIMETERS),
|
||||
(5, LENGTH_KILOMETERS, pytest.approx(3.106855), LENGTH_MILES),
|
||||
(5, LENGTH_KILOMETERS, pytest.approx(5468.066), LENGTH_YARD),
|
||||
(5, LENGTH_KILOMETERS, pytest.approx(16404.2), LENGTH_FEET),
|
||||
(5, LENGTH_KILOMETERS, pytest.approx(196850.5), LENGTH_INCHES),
|
||||
(5000, LENGTH_METERS, pytest.approx(5), LENGTH_KILOMETERS),
|
||||
(5000, LENGTH_METERS, pytest.approx(500000), LENGTH_CENTIMETERS),
|
||||
(5000, LENGTH_METERS, pytest.approx(5000000), LENGTH_MILLIMETERS),
|
||||
(5000, LENGTH_METERS, pytest.approx(3.106855), LENGTH_MILES),
|
||||
(5000, LENGTH_METERS, pytest.approx(5468.066), LENGTH_YARD),
|
||||
(5000, LENGTH_METERS, pytest.approx(16404.2), LENGTH_FEET),
|
||||
(5000, LENGTH_METERS, pytest.approx(196850.5), LENGTH_INCHES),
|
||||
(500000, LENGTH_CENTIMETERS, pytest.approx(5), LENGTH_KILOMETERS),
|
||||
(500000, LENGTH_CENTIMETERS, pytest.approx(5000), LENGTH_METERS),
|
||||
(500000, LENGTH_CENTIMETERS, pytest.approx(5000000), LENGTH_MILLIMETERS),
|
||||
(500000, LENGTH_CENTIMETERS, pytest.approx(3.106855), LENGTH_MILES),
|
||||
(500000, LENGTH_CENTIMETERS, pytest.approx(5468.066), LENGTH_YARD),
|
||||
(500000, LENGTH_CENTIMETERS, pytest.approx(16404.2), LENGTH_FEET),
|
||||
(500000, LENGTH_CENTIMETERS, pytest.approx(196850.5), LENGTH_INCHES),
|
||||
(5000000, LENGTH_MILLIMETERS, pytest.approx(5), LENGTH_KILOMETERS),
|
||||
(5000000, LENGTH_MILLIMETERS, pytest.approx(5000), LENGTH_METERS),
|
||||
(5000000, LENGTH_MILLIMETERS, pytest.approx(500000), LENGTH_CENTIMETERS),
|
||||
(5000000, LENGTH_MILLIMETERS, pytest.approx(3.106855), LENGTH_MILES),
|
||||
(5000000, LENGTH_MILLIMETERS, pytest.approx(5468.066), LENGTH_YARD),
|
||||
(5000000, LENGTH_MILLIMETERS, pytest.approx(16404.2), LENGTH_FEET),
|
||||
(5000000, LENGTH_MILLIMETERS, pytest.approx(196850.5), LENGTH_INCHES),
|
||||
(5, UnitOfLength.MILES, pytest.approx(8.04672), UnitOfLength.KILOMETERS),
|
||||
(5, UnitOfLength.MILES, pytest.approx(8046.72), UnitOfLength.METERS),
|
||||
(5, UnitOfLength.MILES, pytest.approx(804672.0), UnitOfLength.CENTIMETERS),
|
||||
(5, UnitOfLength.MILES, pytest.approx(8046720.0), UnitOfLength.MILLIMETERS),
|
||||
(5, UnitOfLength.MILES, pytest.approx(8800.0), UnitOfLength.YARDS),
|
||||
(5, UnitOfLength.MILES, pytest.approx(26400.0008448), UnitOfLength.FEET),
|
||||
(5, UnitOfLength.MILES, pytest.approx(316800.171072), UnitOfLength.INCHES),
|
||||
(
|
||||
5,
|
||||
UnitOfLength.YARDS,
|
||||
pytest.approx(0.0045720000000000005),
|
||||
UnitOfLength.KILOMETERS,
|
||||
),
|
||||
(5, UnitOfLength.YARDS, pytest.approx(4.572), UnitOfLength.METERS),
|
||||
(5, UnitOfLength.YARDS, pytest.approx(457.2), UnitOfLength.CENTIMETERS),
|
||||
(5, UnitOfLength.YARDS, pytest.approx(4572), UnitOfLength.MILLIMETERS),
|
||||
(5, UnitOfLength.YARDS, pytest.approx(0.002840908212), UnitOfLength.MILES),
|
||||
(5, UnitOfLength.YARDS, pytest.approx(15.00000048), UnitOfLength.FEET),
|
||||
(5, UnitOfLength.YARDS, pytest.approx(180.0000972), UnitOfLength.INCHES),
|
||||
(5000, UnitOfLength.FEET, pytest.approx(1.524), UnitOfLength.KILOMETERS),
|
||||
(5000, UnitOfLength.FEET, pytest.approx(1524), UnitOfLength.METERS),
|
||||
(5000, UnitOfLength.FEET, pytest.approx(152400.0), UnitOfLength.CENTIMETERS),
|
||||
(5000, UnitOfLength.FEET, pytest.approx(1524000.0), UnitOfLength.MILLIMETERS),
|
||||
(
|
||||
5000,
|
||||
UnitOfLength.FEET,
|
||||
pytest.approx(0.9469694040000001),
|
||||
UnitOfLength.MILES,
|
||||
),
|
||||
(5000, UnitOfLength.FEET, pytest.approx(1666.66667), UnitOfLength.YARDS),
|
||||
(
|
||||
5000,
|
||||
UnitOfLength.FEET,
|
||||
pytest.approx(60000.032400000004),
|
||||
UnitOfLength.INCHES,
|
||||
),
|
||||
(5000, UnitOfLength.INCHES, pytest.approx(0.127), UnitOfLength.KILOMETERS),
|
||||
(5000, UnitOfLength.INCHES, pytest.approx(127.0), UnitOfLength.METERS),
|
||||
(5000, UnitOfLength.INCHES, pytest.approx(12700.0), UnitOfLength.CENTIMETERS),
|
||||
(5000, UnitOfLength.INCHES, pytest.approx(127000.0), UnitOfLength.MILLIMETERS),
|
||||
(5000, UnitOfLength.INCHES, pytest.approx(0.078914117), UnitOfLength.MILES),
|
||||
(5000, UnitOfLength.INCHES, pytest.approx(138.88889), UnitOfLength.YARDS),
|
||||
(5000, UnitOfLength.INCHES, pytest.approx(416.66668), UnitOfLength.FEET),
|
||||
(5, UnitOfLength.KILOMETERS, pytest.approx(5000), UnitOfLength.METERS),
|
||||
(5, UnitOfLength.KILOMETERS, pytest.approx(500000), UnitOfLength.CENTIMETERS),
|
||||
(5, UnitOfLength.KILOMETERS, pytest.approx(5000000), UnitOfLength.MILLIMETERS),
|
||||
(5, UnitOfLength.KILOMETERS, pytest.approx(3.106855), UnitOfLength.MILES),
|
||||
(5, UnitOfLength.KILOMETERS, pytest.approx(5468.066), UnitOfLength.YARDS),
|
||||
(5, UnitOfLength.KILOMETERS, pytest.approx(16404.2), UnitOfLength.FEET),
|
||||
(5, UnitOfLength.KILOMETERS, pytest.approx(196850.5), UnitOfLength.INCHES),
|
||||
(5000, UnitOfLength.METERS, pytest.approx(5), UnitOfLength.KILOMETERS),
|
||||
(5000, UnitOfLength.METERS, pytest.approx(500000), UnitOfLength.CENTIMETERS),
|
||||
(5000, UnitOfLength.METERS, pytest.approx(5000000), UnitOfLength.MILLIMETERS),
|
||||
(5000, UnitOfLength.METERS, pytest.approx(3.106855), UnitOfLength.MILES),
|
||||
(5000, UnitOfLength.METERS, pytest.approx(5468.066), UnitOfLength.YARDS),
|
||||
(5000, UnitOfLength.METERS, pytest.approx(16404.2), UnitOfLength.FEET),
|
||||
(5000, UnitOfLength.METERS, pytest.approx(196850.5), UnitOfLength.INCHES),
|
||||
(500000, UnitOfLength.CENTIMETERS, pytest.approx(5), UnitOfLength.KILOMETERS),
|
||||
(500000, UnitOfLength.CENTIMETERS, pytest.approx(5000), UnitOfLength.METERS),
|
||||
(
|
||||
500000,
|
||||
UnitOfLength.CENTIMETERS,
|
||||
pytest.approx(5000000),
|
||||
UnitOfLength.MILLIMETERS,
|
||||
),
|
||||
(500000, UnitOfLength.CENTIMETERS, pytest.approx(3.106855), UnitOfLength.MILES),
|
||||
(500000, UnitOfLength.CENTIMETERS, pytest.approx(5468.066), UnitOfLength.YARDS),
|
||||
(500000, UnitOfLength.CENTIMETERS, pytest.approx(16404.2), UnitOfLength.FEET),
|
||||
(
|
||||
500000,
|
||||
UnitOfLength.CENTIMETERS,
|
||||
pytest.approx(196850.5),
|
||||
UnitOfLength.INCHES,
|
||||
),
|
||||
(5000000, UnitOfLength.MILLIMETERS, pytest.approx(5), UnitOfLength.KILOMETERS),
|
||||
(5000000, UnitOfLength.MILLIMETERS, pytest.approx(5000), UnitOfLength.METERS),
|
||||
(
|
||||
5000000,
|
||||
UnitOfLength.MILLIMETERS,
|
||||
pytest.approx(500000),
|
||||
UnitOfLength.CENTIMETERS,
|
||||
),
|
||||
(
|
||||
5000000,
|
||||
UnitOfLength.MILLIMETERS,
|
||||
pytest.approx(3.106855),
|
||||
UnitOfLength.MILES,
|
||||
),
|
||||
(
|
||||
5000000,
|
||||
UnitOfLength.MILLIMETERS,
|
||||
pytest.approx(5468.066),
|
||||
UnitOfLength.YARDS,
|
||||
),
|
||||
(5000000, UnitOfLength.MILLIMETERS, pytest.approx(16404.2), UnitOfLength.FEET),
|
||||
(
|
||||
5000000,
|
||||
UnitOfLength.MILLIMETERS,
|
||||
pytest.approx(196850.5),
|
||||
UnitOfLength.INCHES,
|
||||
),
|
||||
],
|
||||
)
|
||||
def test_distance_convert(
|
||||
|
|
@ -281,36 +310,41 @@ def test_energy_convert(
|
|||
@pytest.mark.parametrize(
|
||||
"value,from_unit,expected,to_unit",
|
||||
[
|
||||
(10, MASS_KILOGRAMS, 10000, MASS_GRAMS),
|
||||
(10, MASS_KILOGRAMS, 10000000, MASS_MILLIGRAMS),
|
||||
(10, MASS_KILOGRAMS, 10000000000, MASS_MICROGRAMS),
|
||||
(10, MASS_KILOGRAMS, pytest.approx(352.73961), MASS_OUNCES),
|
||||
(10, MASS_KILOGRAMS, pytest.approx(22.046226), MASS_POUNDS),
|
||||
(10, MASS_GRAMS, 0.01, MASS_KILOGRAMS),
|
||||
(10, MASS_GRAMS, 10000, MASS_MILLIGRAMS),
|
||||
(10, MASS_GRAMS, 10000000, MASS_MICROGRAMS),
|
||||
(10, MASS_GRAMS, pytest.approx(0.35273961), MASS_OUNCES),
|
||||
(10, MASS_GRAMS, pytest.approx(0.022046226), MASS_POUNDS),
|
||||
(10, MASS_MILLIGRAMS, 0.00001, MASS_KILOGRAMS),
|
||||
(10, MASS_MILLIGRAMS, 0.01, MASS_GRAMS),
|
||||
(10, MASS_MILLIGRAMS, 10000, MASS_MICROGRAMS),
|
||||
(10, MASS_MILLIGRAMS, pytest.approx(0.00035273961), MASS_OUNCES),
|
||||
(10, MASS_MILLIGRAMS, pytest.approx(0.000022046226), MASS_POUNDS),
|
||||
(10000, MASS_MICROGRAMS, 0.00001, MASS_KILOGRAMS),
|
||||
(10000, MASS_MICROGRAMS, 0.01, MASS_GRAMS),
|
||||
(10000, MASS_MICROGRAMS, 10, MASS_MILLIGRAMS),
|
||||
(10000, MASS_MICROGRAMS, pytest.approx(0.00035273961), MASS_OUNCES),
|
||||
(10000, MASS_MICROGRAMS, pytest.approx(0.000022046226), MASS_POUNDS),
|
||||
(1, MASS_POUNDS, 0.45359237, MASS_KILOGRAMS),
|
||||
(1, MASS_POUNDS, 453.59237, MASS_GRAMS),
|
||||
(1, MASS_POUNDS, 453592.37, MASS_MILLIGRAMS),
|
||||
(1, MASS_POUNDS, 453592370, MASS_MICROGRAMS),
|
||||
(1, MASS_POUNDS, 16, MASS_OUNCES),
|
||||
(16, MASS_OUNCES, 0.45359237, MASS_KILOGRAMS),
|
||||
(16, MASS_OUNCES, 453.59237, MASS_GRAMS),
|
||||
(16, MASS_OUNCES, 453592.37, MASS_MILLIGRAMS),
|
||||
(16, MASS_OUNCES, 453592370, MASS_MICROGRAMS),
|
||||
(16, MASS_OUNCES, 1, MASS_POUNDS),
|
||||
(10, UnitOfMass.KILOGRAMS, 10000, UnitOfMass.GRAMS),
|
||||
(10, UnitOfMass.KILOGRAMS, 10000000, UnitOfMass.MILLIGRAMS),
|
||||
(10, UnitOfMass.KILOGRAMS, 10000000000, UnitOfMass.MICROGRAMS),
|
||||
(10, UnitOfMass.KILOGRAMS, pytest.approx(352.73961), UnitOfMass.OUNCES),
|
||||
(10, UnitOfMass.KILOGRAMS, pytest.approx(22.046226), UnitOfMass.POUNDS),
|
||||
(10, UnitOfMass.GRAMS, 0.01, UnitOfMass.KILOGRAMS),
|
||||
(10, UnitOfMass.GRAMS, 10000, UnitOfMass.MILLIGRAMS),
|
||||
(10, UnitOfMass.GRAMS, 10000000, UnitOfMass.MICROGRAMS),
|
||||
(10, UnitOfMass.GRAMS, pytest.approx(0.35273961), UnitOfMass.OUNCES),
|
||||
(10, UnitOfMass.GRAMS, pytest.approx(0.022046226), UnitOfMass.POUNDS),
|
||||
(10, UnitOfMass.MILLIGRAMS, 0.00001, UnitOfMass.KILOGRAMS),
|
||||
(10, UnitOfMass.MILLIGRAMS, 0.01, UnitOfMass.GRAMS),
|
||||
(10, UnitOfMass.MILLIGRAMS, 10000, UnitOfMass.MICROGRAMS),
|
||||
(10, UnitOfMass.MILLIGRAMS, pytest.approx(0.00035273961), UnitOfMass.OUNCES),
|
||||
(10, UnitOfMass.MILLIGRAMS, pytest.approx(0.000022046226), UnitOfMass.POUNDS),
|
||||
(10000, UnitOfMass.MICROGRAMS, 0.00001, UnitOfMass.KILOGRAMS),
|
||||
(10000, UnitOfMass.MICROGRAMS, 0.01, UnitOfMass.GRAMS),
|
||||
(10000, UnitOfMass.MICROGRAMS, 10, UnitOfMass.MILLIGRAMS),
|
||||
(10000, UnitOfMass.MICROGRAMS, pytest.approx(0.00035273961), UnitOfMass.OUNCES),
|
||||
(
|
||||
10000,
|
||||
UnitOfMass.MICROGRAMS,
|
||||
pytest.approx(0.000022046226),
|
||||
UnitOfMass.POUNDS,
|
||||
),
|
||||
(1, UnitOfMass.POUNDS, 0.45359237, UnitOfMass.KILOGRAMS),
|
||||
(1, UnitOfMass.POUNDS, 453.59237, UnitOfMass.GRAMS),
|
||||
(1, UnitOfMass.POUNDS, 453592.37, UnitOfMass.MILLIGRAMS),
|
||||
(1, UnitOfMass.POUNDS, 453592370, UnitOfMass.MICROGRAMS),
|
||||
(1, UnitOfMass.POUNDS, 16, UnitOfMass.OUNCES),
|
||||
(16, UnitOfMass.OUNCES, 0.45359237, UnitOfMass.KILOGRAMS),
|
||||
(16, UnitOfMass.OUNCES, 453.59237, UnitOfMass.GRAMS),
|
||||
(16, UnitOfMass.OUNCES, 453592.37, UnitOfMass.MILLIGRAMS),
|
||||
(16, UnitOfMass.OUNCES, 453592370, UnitOfMass.MICROGRAMS),
|
||||
(16, UnitOfMass.OUNCES, 1, UnitOfMass.POUNDS),
|
||||
],
|
||||
)
|
||||
def test_mass_convert(
|
||||
|
|
@ -326,8 +360,8 @@ def test_mass_convert(
|
|||
@pytest.mark.parametrize(
|
||||
"value,from_unit,expected,to_unit",
|
||||
[
|
||||
(10, POWER_KILO_WATT, 10000, POWER_WATT),
|
||||
(10, POWER_WATT, 0.01, POWER_KILO_WATT),
|
||||
(10, UnitOfPower.KILO_WATT, 10000, UnitOfPower.WATT),
|
||||
(10, UnitOfPower.WATT, 0.01, UnitOfPower.KILO_WATT),
|
||||
],
|
||||
)
|
||||
def test_power_convert(
|
||||
|
|
@ -343,32 +377,32 @@ def test_power_convert(
|
|||
@pytest.mark.parametrize(
|
||||
"value,from_unit,expected,to_unit",
|
||||
[
|
||||
(1000, PRESSURE_HPA, pytest.approx(14.5037743897), PRESSURE_PSI),
|
||||
(1000, PRESSURE_HPA, pytest.approx(29.5299801647), PRESSURE_INHG),
|
||||
(1000, PRESSURE_HPA, pytest.approx(100000), PRESSURE_PA),
|
||||
(1000, PRESSURE_HPA, pytest.approx(100), PRESSURE_KPA),
|
||||
(1000, PRESSURE_HPA, pytest.approx(1000), PRESSURE_MBAR),
|
||||
(1000, PRESSURE_HPA, pytest.approx(100), PRESSURE_CBAR),
|
||||
(100, PRESSURE_KPA, pytest.approx(14.5037743897), PRESSURE_PSI),
|
||||
(100, PRESSURE_KPA, pytest.approx(29.5299801647), PRESSURE_INHG),
|
||||
(100, PRESSURE_KPA, pytest.approx(100000), PRESSURE_PA),
|
||||
(100, PRESSURE_KPA, pytest.approx(1000), PRESSURE_HPA),
|
||||
(100, PRESSURE_KPA, pytest.approx(1000), PRESSURE_MBAR),
|
||||
(100, PRESSURE_KPA, pytest.approx(100), PRESSURE_CBAR),
|
||||
(30, PRESSURE_INHG, pytest.approx(14.7346266155), PRESSURE_PSI),
|
||||
(30, PRESSURE_INHG, pytest.approx(101.59167), PRESSURE_KPA),
|
||||
(30, PRESSURE_INHG, pytest.approx(1015.9167), PRESSURE_HPA),
|
||||
(30, PRESSURE_INHG, pytest.approx(101591.67), PRESSURE_PA),
|
||||
(30, PRESSURE_INHG, pytest.approx(1015.9167), PRESSURE_MBAR),
|
||||
(30, PRESSURE_INHG, pytest.approx(101.59167), PRESSURE_CBAR),
|
||||
(30, PRESSURE_INHG, pytest.approx(762), PRESSURE_MMHG),
|
||||
(30, PRESSURE_MMHG, pytest.approx(0.580103), PRESSURE_PSI),
|
||||
(30, PRESSURE_MMHG, pytest.approx(3.99967), PRESSURE_KPA),
|
||||
(30, PRESSURE_MMHG, pytest.approx(39.9967), PRESSURE_HPA),
|
||||
(30, PRESSURE_MMHG, pytest.approx(3999.67), PRESSURE_PA),
|
||||
(30, PRESSURE_MMHG, pytest.approx(39.9967), PRESSURE_MBAR),
|
||||
(30, PRESSURE_MMHG, pytest.approx(3.99967), PRESSURE_CBAR),
|
||||
(30, PRESSURE_MMHG, pytest.approx(1.181102), PRESSURE_INHG),
|
||||
(1000, UnitOfPressure.HPA, pytest.approx(14.5037743897), UnitOfPressure.PSI),
|
||||
(1000, UnitOfPressure.HPA, pytest.approx(29.5299801647), UnitOfPressure.INHG),
|
||||
(1000, UnitOfPressure.HPA, pytest.approx(100000), UnitOfPressure.PA),
|
||||
(1000, UnitOfPressure.HPA, pytest.approx(100), UnitOfPressure.KPA),
|
||||
(1000, UnitOfPressure.HPA, pytest.approx(1000), UnitOfPressure.MBAR),
|
||||
(1000, UnitOfPressure.HPA, pytest.approx(100), UnitOfPressure.CBAR),
|
||||
(100, UnitOfPressure.KPA, pytest.approx(14.5037743897), UnitOfPressure.PSI),
|
||||
(100, UnitOfPressure.KPA, pytest.approx(29.5299801647), UnitOfPressure.INHG),
|
||||
(100, UnitOfPressure.KPA, pytest.approx(100000), UnitOfPressure.PA),
|
||||
(100, UnitOfPressure.KPA, pytest.approx(1000), UnitOfPressure.HPA),
|
||||
(100, UnitOfPressure.KPA, pytest.approx(1000), UnitOfPressure.MBAR),
|
||||
(100, UnitOfPressure.KPA, pytest.approx(100), UnitOfPressure.CBAR),
|
||||
(30, UnitOfPressure.INHG, pytest.approx(14.7346266155), UnitOfPressure.PSI),
|
||||
(30, UnitOfPressure.INHG, pytest.approx(101.59167), UnitOfPressure.KPA),
|
||||
(30, UnitOfPressure.INHG, pytest.approx(1015.9167), UnitOfPressure.HPA),
|
||||
(30, UnitOfPressure.INHG, pytest.approx(101591.67), UnitOfPressure.PA),
|
||||
(30, UnitOfPressure.INHG, pytest.approx(1015.9167), UnitOfPressure.MBAR),
|
||||
(30, UnitOfPressure.INHG, pytest.approx(101.59167), UnitOfPressure.CBAR),
|
||||
(30, UnitOfPressure.INHG, pytest.approx(762), UnitOfPressure.MMHG),
|
||||
(30, UnitOfPressure.MMHG, pytest.approx(0.580103), UnitOfPressure.PSI),
|
||||
(30, UnitOfPressure.MMHG, pytest.approx(3.99967), UnitOfPressure.KPA),
|
||||
(30, UnitOfPressure.MMHG, pytest.approx(39.9967), UnitOfPressure.HPA),
|
||||
(30, UnitOfPressure.MMHG, pytest.approx(3999.67), UnitOfPressure.PA),
|
||||
(30, UnitOfPressure.MMHG, pytest.approx(39.9967), UnitOfPressure.MBAR),
|
||||
(30, UnitOfPressure.MMHG, pytest.approx(3.99967), UnitOfPressure.CBAR),
|
||||
(30, UnitOfPressure.MMHG, pytest.approx(1.181102), UnitOfPressure.INHG),
|
||||
],
|
||||
)
|
||||
def test_pressure_convert(
|
||||
|
|
@ -385,9 +419,14 @@ def test_pressure_convert(
|
|||
"value,from_unit,expected,to_unit",
|
||||
[
|
||||
# 5 km/h / 1.609 km/mi = 3.10686 mi/h
|
||||
(5, SPEED_KILOMETERS_PER_HOUR, pytest.approx(3.106856), SPEED_MILES_PER_HOUR),
|
||||
(
|
||||
5,
|
||||
UnitOfSpeed.KILOMETERS_PER_HOUR,
|
||||
pytest.approx(3.106856),
|
||||
UnitOfSpeed.MILES_PER_HOUR,
|
||||
),
|
||||
# 5 mi/h * 1.609 km/mi = 8.04672 km/h
|
||||
(5, SPEED_MILES_PER_HOUR, 8.04672, SPEED_KILOMETERS_PER_HOUR),
|
||||
(5, UnitOfSpeed.MILES_PER_HOUR, 8.04672, UnitOfSpeed.KILOMETERS_PER_HOUR),
|
||||
# 5 in/day * 25.4 mm/in = 127 mm/day
|
||||
(
|
||||
5,
|
||||
|
|
@ -419,7 +458,7 @@ def test_pressure_convert(
|
|||
# 5 m/s * 39.3701 in/m * 3600 s/hr = 708661
|
||||
(
|
||||
5,
|
||||
SPEED_METERS_PER_SECOND,
|
||||
UnitOfSpeed.METERS_PER_SECOND,
|
||||
pytest.approx(708661.42),
|
||||
UnitOfVolumetricFlux.INCHES_PER_HOUR,
|
||||
),
|
||||
|
|
@ -428,12 +467,17 @@ def test_pressure_convert(
|
|||
5000,
|
||||
UnitOfVolumetricFlux.INCHES_PER_HOUR,
|
||||
pytest.approx(0.0352778),
|
||||
SPEED_METERS_PER_SECOND,
|
||||
UnitOfSpeed.METERS_PER_SECOND,
|
||||
),
|
||||
# 5 kt * 1852 m/nmi / 3600 s/h = 2.5722 m/s
|
||||
(5, SPEED_KNOTS, pytest.approx(2.57222), SPEED_METERS_PER_SECOND),
|
||||
(5, UnitOfSpeed.KNOTS, pytest.approx(2.57222), UnitOfSpeed.METERS_PER_SECOND),
|
||||
# 5 ft/s * 0.3048 m/ft = 1.524 m/s
|
||||
(5, SPEED_FEET_PER_SECOND, pytest.approx(1.524), SPEED_METERS_PER_SECOND),
|
||||
(
|
||||
5,
|
||||
UnitOfSpeed.FEET_PER_SECOND,
|
||||
pytest.approx(1.524),
|
||||
UnitOfSpeed.METERS_PER_SECOND,
|
||||
),
|
||||
],
|
||||
)
|
||||
def test_speed_convert(
|
||||
|
|
@ -449,12 +493,32 @@ def test_speed_convert(
|
|||
@pytest.mark.parametrize(
|
||||
"value,from_unit,expected,to_unit",
|
||||
[
|
||||
(100, TEMP_CELSIUS, 212, TEMP_FAHRENHEIT),
|
||||
(100, TEMP_CELSIUS, 373.15, TEMP_KELVIN),
|
||||
(100, TEMP_FAHRENHEIT, pytest.approx(37.77777777777778), TEMP_CELSIUS),
|
||||
(100, TEMP_FAHRENHEIT, pytest.approx(310.92777777777775), TEMP_KELVIN),
|
||||
(100, TEMP_KELVIN, pytest.approx(-173.15), TEMP_CELSIUS),
|
||||
(100, TEMP_KELVIN, pytest.approx(-279.66999999999996), TEMP_FAHRENHEIT),
|
||||
(100, UnitOfTemperature.CELSIUS, 212, UnitOfTemperature.FAHRENHEIT),
|
||||
(100, UnitOfTemperature.CELSIUS, 373.15, UnitOfTemperature.KELVIN),
|
||||
(
|
||||
100,
|
||||
UnitOfTemperature.FAHRENHEIT,
|
||||
pytest.approx(37.77777777777778),
|
||||
UnitOfTemperature.CELSIUS,
|
||||
),
|
||||
(
|
||||
100,
|
||||
UnitOfTemperature.FAHRENHEIT,
|
||||
pytest.approx(310.92777777777775),
|
||||
UnitOfTemperature.KELVIN,
|
||||
),
|
||||
(
|
||||
100,
|
||||
UnitOfTemperature.KELVIN,
|
||||
pytest.approx(-173.15),
|
||||
UnitOfTemperature.CELSIUS,
|
||||
),
|
||||
(
|
||||
100,
|
||||
UnitOfTemperature.KELVIN,
|
||||
pytest.approx(-279.66999999999996),
|
||||
UnitOfTemperature.FAHRENHEIT,
|
||||
),
|
||||
],
|
||||
)
|
||||
def test_temperature_convert(
|
||||
|
|
@ -467,12 +531,22 @@ def test_temperature_convert(
|
|||
@pytest.mark.parametrize(
|
||||
"value,from_unit,expected,to_unit",
|
||||
[
|
||||
(100, TEMP_CELSIUS, 180, TEMP_FAHRENHEIT),
|
||||
(100, TEMP_CELSIUS, 100, TEMP_KELVIN),
|
||||
(100, TEMP_FAHRENHEIT, pytest.approx(55.55555555555556), TEMP_CELSIUS),
|
||||
(100, TEMP_FAHRENHEIT, pytest.approx(55.55555555555556), TEMP_KELVIN),
|
||||
(100, TEMP_KELVIN, 100, TEMP_CELSIUS),
|
||||
(100, TEMP_KELVIN, 180, TEMP_FAHRENHEIT),
|
||||
(100, UnitOfTemperature.CELSIUS, 180, UnitOfTemperature.FAHRENHEIT),
|
||||
(100, UnitOfTemperature.CELSIUS, 100, UnitOfTemperature.KELVIN),
|
||||
(
|
||||
100,
|
||||
UnitOfTemperature.FAHRENHEIT,
|
||||
pytest.approx(55.55555555555556),
|
||||
UnitOfTemperature.CELSIUS,
|
||||
),
|
||||
(
|
||||
100,
|
||||
UnitOfTemperature.FAHRENHEIT,
|
||||
pytest.approx(55.55555555555556),
|
||||
UnitOfTemperature.KELVIN,
|
||||
),
|
||||
(100, UnitOfTemperature.KELVIN, 100, UnitOfTemperature.CELSIUS),
|
||||
(100, UnitOfTemperature.KELVIN, 180, UnitOfTemperature.FAHRENHEIT),
|
||||
],
|
||||
)
|
||||
def test_temperature_convert_with_interval(
|
||||
|
|
@ -485,40 +559,110 @@ def test_temperature_convert_with_interval(
|
|||
@pytest.mark.parametrize(
|
||||
"value,from_unit,expected,to_unit",
|
||||
[
|
||||
(5, VOLUME_LITERS, pytest.approx(1.32086), VOLUME_GALLONS),
|
||||
(5, VOLUME_GALLONS, pytest.approx(18.92706), VOLUME_LITERS),
|
||||
(5, VOLUME_CUBIC_METERS, pytest.approx(176.5733335), VOLUME_CUBIC_FEET),
|
||||
(500, VOLUME_CUBIC_FEET, pytest.approx(14.1584233), VOLUME_CUBIC_METERS),
|
||||
(500, VOLUME_CUBIC_FEET, pytest.approx(14.1584233), VOLUME_CUBIC_METERS),
|
||||
(500, VOLUME_CUBIC_FEET, pytest.approx(478753.2467), VOLUME_FLUID_OUNCE),
|
||||
(500, VOLUME_CUBIC_FEET, pytest.approx(3740.25974), VOLUME_GALLONS),
|
||||
(500, VOLUME_CUBIC_FEET, pytest.approx(14158.42329599), VOLUME_LITERS),
|
||||
(500, VOLUME_CUBIC_FEET, pytest.approx(14158423.29599), VOLUME_MILLILITERS),
|
||||
(500, VOLUME_CUBIC_METERS, 500, VOLUME_CUBIC_METERS),
|
||||
(500, VOLUME_CUBIC_METERS, pytest.approx(16907011.35), VOLUME_FLUID_OUNCE),
|
||||
(500, VOLUME_CUBIC_METERS, pytest.approx(132086.02617), VOLUME_GALLONS),
|
||||
(500, VOLUME_CUBIC_METERS, 500000, VOLUME_LITERS),
|
||||
(500, VOLUME_CUBIC_METERS, 500000000, VOLUME_MILLILITERS),
|
||||
(500, VOLUME_FLUID_OUNCE, pytest.approx(0.52218967), VOLUME_CUBIC_FEET),
|
||||
(500, VOLUME_FLUID_OUNCE, pytest.approx(0.014786764), VOLUME_CUBIC_METERS),
|
||||
(500, VOLUME_FLUID_OUNCE, 3.90625, VOLUME_GALLONS),
|
||||
(500, VOLUME_FLUID_OUNCE, pytest.approx(14.786764), VOLUME_LITERS),
|
||||
(500, VOLUME_FLUID_OUNCE, pytest.approx(14786.764), VOLUME_MILLILITERS),
|
||||
(500, VOLUME_GALLONS, pytest.approx(66.84027), VOLUME_CUBIC_FEET),
|
||||
(500, VOLUME_GALLONS, pytest.approx(1.892706), VOLUME_CUBIC_METERS),
|
||||
(500, VOLUME_GALLONS, 64000, VOLUME_FLUID_OUNCE),
|
||||
(500, VOLUME_GALLONS, pytest.approx(1892.70589), VOLUME_LITERS),
|
||||
(500, VOLUME_GALLONS, pytest.approx(1892705.89), VOLUME_MILLILITERS),
|
||||
(500, VOLUME_LITERS, pytest.approx(17.65733), VOLUME_CUBIC_FEET),
|
||||
(500, VOLUME_LITERS, 0.5, VOLUME_CUBIC_METERS),
|
||||
(500, VOLUME_LITERS, pytest.approx(16907.011), VOLUME_FLUID_OUNCE),
|
||||
(500, VOLUME_LITERS, pytest.approx(132.086), VOLUME_GALLONS),
|
||||
(500, VOLUME_LITERS, 500000, VOLUME_MILLILITERS),
|
||||
(500, VOLUME_MILLILITERS, pytest.approx(0.01765733), VOLUME_CUBIC_FEET),
|
||||
(500, VOLUME_MILLILITERS, 0.0005, VOLUME_CUBIC_METERS),
|
||||
(500, VOLUME_MILLILITERS, pytest.approx(16.907), VOLUME_FLUID_OUNCE),
|
||||
(500, VOLUME_MILLILITERS, pytest.approx(0.132086), VOLUME_GALLONS),
|
||||
(500, VOLUME_MILLILITERS, 0.5, VOLUME_LITERS),
|
||||
(5, UnitOfVolume.LITERS, pytest.approx(1.32086), UnitOfVolume.GALLONS),
|
||||
(5, UnitOfVolume.GALLONS, pytest.approx(18.92706), UnitOfVolume.LITERS),
|
||||
(
|
||||
5,
|
||||
UnitOfVolume.CUBIC_METERS,
|
||||
pytest.approx(176.5733335),
|
||||
UnitOfVolume.CUBIC_FEET,
|
||||
),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.CUBIC_FEET,
|
||||
pytest.approx(14.1584233),
|
||||
UnitOfVolume.CUBIC_METERS,
|
||||
),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.CUBIC_FEET,
|
||||
pytest.approx(14.1584233),
|
||||
UnitOfVolume.CUBIC_METERS,
|
||||
),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.CUBIC_FEET,
|
||||
pytest.approx(478753.2467),
|
||||
UnitOfVolume.FLUID_OUNCES,
|
||||
),
|
||||
(500, UnitOfVolume.CUBIC_FEET, pytest.approx(3740.25974), UnitOfVolume.GALLONS),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.CUBIC_FEET,
|
||||
pytest.approx(14158.42329599),
|
||||
UnitOfVolume.LITERS,
|
||||
),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.CUBIC_FEET,
|
||||
pytest.approx(14158423.29599),
|
||||
UnitOfVolume.MILLILITERS,
|
||||
),
|
||||
(500, UnitOfVolume.CUBIC_METERS, 500, UnitOfVolume.CUBIC_METERS),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.CUBIC_METERS,
|
||||
pytest.approx(16907011.35),
|
||||
UnitOfVolume.FLUID_OUNCES,
|
||||
),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.CUBIC_METERS,
|
||||
pytest.approx(132086.02617),
|
||||
UnitOfVolume.GALLONS,
|
||||
),
|
||||
(500, UnitOfVolume.CUBIC_METERS, 500000, UnitOfVolume.LITERS),
|
||||
(500, UnitOfVolume.CUBIC_METERS, 500000000, UnitOfVolume.MILLILITERS),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.FLUID_OUNCES,
|
||||
pytest.approx(0.52218967),
|
||||
UnitOfVolume.CUBIC_FEET,
|
||||
),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.FLUID_OUNCES,
|
||||
pytest.approx(0.014786764),
|
||||
UnitOfVolume.CUBIC_METERS,
|
||||
),
|
||||
(500, UnitOfVolume.FLUID_OUNCES, 3.90625, UnitOfVolume.GALLONS),
|
||||
(500, UnitOfVolume.FLUID_OUNCES, pytest.approx(14.786764), UnitOfVolume.LITERS),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.FLUID_OUNCES,
|
||||
pytest.approx(14786.764),
|
||||
UnitOfVolume.MILLILITERS,
|
||||
),
|
||||
(500, UnitOfVolume.GALLONS, pytest.approx(66.84027), UnitOfVolume.CUBIC_FEET),
|
||||
(500, UnitOfVolume.GALLONS, pytest.approx(1.892706), UnitOfVolume.CUBIC_METERS),
|
||||
(500, UnitOfVolume.GALLONS, 64000, UnitOfVolume.FLUID_OUNCES),
|
||||
(500, UnitOfVolume.GALLONS, pytest.approx(1892.70589), UnitOfVolume.LITERS),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.GALLONS,
|
||||
pytest.approx(1892705.89),
|
||||
UnitOfVolume.MILLILITERS,
|
||||
),
|
||||
(500, UnitOfVolume.LITERS, pytest.approx(17.65733), UnitOfVolume.CUBIC_FEET),
|
||||
(500, UnitOfVolume.LITERS, 0.5, UnitOfVolume.CUBIC_METERS),
|
||||
(500, UnitOfVolume.LITERS, pytest.approx(16907.011), UnitOfVolume.FLUID_OUNCES),
|
||||
(500, UnitOfVolume.LITERS, pytest.approx(132.086), UnitOfVolume.GALLONS),
|
||||
(500, UnitOfVolume.LITERS, 500000, UnitOfVolume.MILLILITERS),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.MILLILITERS,
|
||||
pytest.approx(0.01765733),
|
||||
UnitOfVolume.CUBIC_FEET,
|
||||
),
|
||||
(500, UnitOfVolume.MILLILITERS, 0.0005, UnitOfVolume.CUBIC_METERS),
|
||||
(
|
||||
500,
|
||||
UnitOfVolume.MILLILITERS,
|
||||
pytest.approx(16.907),
|
||||
UnitOfVolume.FLUID_OUNCES,
|
||||
),
|
||||
(500, UnitOfVolume.MILLILITERS, pytest.approx(0.132086), UnitOfVolume.GALLONS),
|
||||
(500, UnitOfVolume.MILLILITERS, 0.5, UnitOfVolume.LITERS),
|
||||
],
|
||||
)
|
||||
def test_volume_convert(
|
||||
|
|
|
|||
|
|
@ -7,33 +7,17 @@ from homeassistant.components.sensor import SensorDeviceClass
|
|||
from homeassistant.const import (
|
||||
ACCUMULATED_PRECIPITATION,
|
||||
LENGTH,
|
||||
LENGTH_CENTIMETERS,
|
||||
LENGTH_FEET,
|
||||
LENGTH_INCHES,
|
||||
LENGTH_KILOMETERS,
|
||||
LENGTH_METERS,
|
||||
LENGTH_MILES,
|
||||
LENGTH_MILLIMETERS,
|
||||
LENGTH_YARD,
|
||||
MASS,
|
||||
MASS_GRAMS,
|
||||
PRESSURE,
|
||||
PRESSURE_PA,
|
||||
SPEED_FEET_PER_SECOND,
|
||||
SPEED_KILOMETERS_PER_HOUR,
|
||||
SPEED_KNOTS,
|
||||
SPEED_METERS_PER_SECOND,
|
||||
SPEED_MILES_PER_HOUR,
|
||||
TEMP_CELSIUS,
|
||||
TEMPERATURE,
|
||||
VOLUME,
|
||||
VOLUME_CUBIC_FEET,
|
||||
VOLUME_CUBIC_METERS,
|
||||
VOLUME_FLUID_OUNCE,
|
||||
VOLUME_GALLONS,
|
||||
VOLUME_LITERS,
|
||||
VOLUME_MILLILITERS,
|
||||
WIND_SPEED,
|
||||
UnitOfLength,
|
||||
UnitOfMass,
|
||||
UnitOfPressure,
|
||||
UnitOfSpeed,
|
||||
UnitOfTemperature,
|
||||
UnitOfVolume,
|
||||
)
|
||||
from homeassistant.exceptions import HomeAssistantError
|
||||
from homeassistant.util.unit_system import (
|
||||
|
|
@ -56,79 +40,79 @@ def test_invalid_units():
|
|||
with pytest.raises(ValueError):
|
||||
UnitSystem(
|
||||
SYSTEM_NAME,
|
||||
accumulated_precipitation=LENGTH_MILLIMETERS,
|
||||
accumulated_precipitation=UnitOfLength.MILLIMETERS,
|
||||
conversions={},
|
||||
length=LENGTH_METERS,
|
||||
mass=MASS_GRAMS,
|
||||
pressure=PRESSURE_PA,
|
||||
length=UnitOfLength.METERS,
|
||||
mass=UnitOfMass.GRAMS,
|
||||
pressure=UnitOfPressure.PA,
|
||||
temperature=INVALID_UNIT,
|
||||
volume=VOLUME_LITERS,
|
||||
wind_speed=SPEED_METERS_PER_SECOND,
|
||||
volume=UnitOfVolume.LITERS,
|
||||
wind_speed=UnitOfSpeed.METERS_PER_SECOND,
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
UnitSystem(
|
||||
SYSTEM_NAME,
|
||||
accumulated_precipitation=LENGTH_MILLIMETERS,
|
||||
accumulated_precipitation=UnitOfLength.MILLIMETERS,
|
||||
conversions={},
|
||||
length=INVALID_UNIT,
|
||||
mass=MASS_GRAMS,
|
||||
pressure=PRESSURE_PA,
|
||||
temperature=TEMP_CELSIUS,
|
||||
volume=VOLUME_LITERS,
|
||||
wind_speed=SPEED_METERS_PER_SECOND,
|
||||
mass=UnitOfMass.GRAMS,
|
||||
pressure=UnitOfPressure.PA,
|
||||
temperature=UnitOfTemperature.CELSIUS,
|
||||
volume=UnitOfVolume.LITERS,
|
||||
wind_speed=UnitOfSpeed.METERS_PER_SECOND,
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
UnitSystem(
|
||||
SYSTEM_NAME,
|
||||
accumulated_precipitation=LENGTH_MILLIMETERS,
|
||||
accumulated_precipitation=UnitOfLength.MILLIMETERS,
|
||||
conversions={},
|
||||
length=LENGTH_METERS,
|
||||
mass=MASS_GRAMS,
|
||||
pressure=PRESSURE_PA,
|
||||
temperature=TEMP_CELSIUS,
|
||||
volume=VOLUME_LITERS,
|
||||
length=UnitOfLength.METERS,
|
||||
mass=UnitOfMass.GRAMS,
|
||||
pressure=UnitOfPressure.PA,
|
||||
temperature=UnitOfTemperature.CELSIUS,
|
||||
volume=UnitOfVolume.LITERS,
|
||||
wind_speed=INVALID_UNIT,
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
UnitSystem(
|
||||
SYSTEM_NAME,
|
||||
accumulated_precipitation=LENGTH_MILLIMETERS,
|
||||
accumulated_precipitation=UnitOfLength.MILLIMETERS,
|
||||
conversions={},
|
||||
length=LENGTH_METERS,
|
||||
mass=MASS_GRAMS,
|
||||
pressure=PRESSURE_PA,
|
||||
temperature=TEMP_CELSIUS,
|
||||
length=UnitOfLength.METERS,
|
||||
mass=UnitOfMass.GRAMS,
|
||||
pressure=UnitOfPressure.PA,
|
||||
temperature=UnitOfTemperature.CELSIUS,
|
||||
volume=INVALID_UNIT,
|
||||
wind_speed=SPEED_METERS_PER_SECOND,
|
||||
wind_speed=UnitOfSpeed.METERS_PER_SECOND,
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
UnitSystem(
|
||||
SYSTEM_NAME,
|
||||
accumulated_precipitation=LENGTH_MILLIMETERS,
|
||||
accumulated_precipitation=UnitOfLength.MILLIMETERS,
|
||||
conversions={},
|
||||
length=LENGTH_METERS,
|
||||
length=UnitOfLength.METERS,
|
||||
mass=INVALID_UNIT,
|
||||
pressure=PRESSURE_PA,
|
||||
temperature=TEMP_CELSIUS,
|
||||
volume=VOLUME_LITERS,
|
||||
wind_speed=SPEED_METERS_PER_SECOND,
|
||||
pressure=UnitOfPressure.PA,
|
||||
temperature=UnitOfTemperature.CELSIUS,
|
||||
volume=UnitOfVolume.LITERS,
|
||||
wind_speed=UnitOfSpeed.METERS_PER_SECOND,
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
UnitSystem(
|
||||
SYSTEM_NAME,
|
||||
accumulated_precipitation=LENGTH_MILLIMETERS,
|
||||
accumulated_precipitation=UnitOfLength.MILLIMETERS,
|
||||
conversions={},
|
||||
length=LENGTH_METERS,
|
||||
mass=MASS_GRAMS,
|
||||
length=UnitOfLength.METERS,
|
||||
mass=UnitOfMass.GRAMS,
|
||||
pressure=INVALID_UNIT,
|
||||
temperature=TEMP_CELSIUS,
|
||||
volume=VOLUME_LITERS,
|
||||
wind_speed=SPEED_METERS_PER_SECOND,
|
||||
temperature=UnitOfTemperature.CELSIUS,
|
||||
volume=UnitOfVolume.LITERS,
|
||||
wind_speed=UnitOfSpeed.METERS_PER_SECOND,
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
|
|
@ -136,41 +120,41 @@ def test_invalid_units():
|
|||
SYSTEM_NAME,
|
||||
accumulated_precipitation=INVALID_UNIT,
|
||||
conversions={},
|
||||
length=LENGTH_METERS,
|
||||
mass=MASS_GRAMS,
|
||||
pressure=PRESSURE_PA,
|
||||
temperature=TEMP_CELSIUS,
|
||||
volume=VOLUME_LITERS,
|
||||
wind_speed=SPEED_METERS_PER_SECOND,
|
||||
length=UnitOfLength.METERS,
|
||||
mass=UnitOfMass.GRAMS,
|
||||
pressure=UnitOfPressure.PA,
|
||||
temperature=UnitOfTemperature.CELSIUS,
|
||||
volume=UnitOfVolume.LITERS,
|
||||
wind_speed=UnitOfSpeed.METERS_PER_SECOND,
|
||||
)
|
||||
|
||||
|
||||
def test_invalid_value():
|
||||
"""Test no conversion happens if value is non-numeric."""
|
||||
with pytest.raises(TypeError):
|
||||
METRIC_SYSTEM.length("25a", LENGTH_KILOMETERS)
|
||||
METRIC_SYSTEM.length("25a", UnitOfLength.KILOMETERS)
|
||||
with pytest.raises(TypeError):
|
||||
METRIC_SYSTEM.temperature("50K", TEMP_CELSIUS)
|
||||
METRIC_SYSTEM.temperature("50K", UnitOfTemperature.CELSIUS)
|
||||
with pytest.raises(TypeError):
|
||||
METRIC_SYSTEM.wind_speed("50km/h", SPEED_METERS_PER_SECOND)
|
||||
METRIC_SYSTEM.wind_speed("50km/h", UnitOfSpeed.METERS_PER_SECOND)
|
||||
with pytest.raises(TypeError):
|
||||
METRIC_SYSTEM.volume("50L", VOLUME_LITERS)
|
||||
METRIC_SYSTEM.volume("50L", UnitOfVolume.LITERS)
|
||||
with pytest.raises(TypeError):
|
||||
METRIC_SYSTEM.pressure("50Pa", PRESSURE_PA)
|
||||
METRIC_SYSTEM.pressure("50Pa", UnitOfPressure.PA)
|
||||
with pytest.raises(TypeError):
|
||||
METRIC_SYSTEM.accumulated_precipitation("50mm", LENGTH_MILLIMETERS)
|
||||
METRIC_SYSTEM.accumulated_precipitation("50mm", UnitOfLength.MILLIMETERS)
|
||||
|
||||
|
||||
def test_as_dict():
|
||||
"""Test that the as_dict() method returns the expected dictionary."""
|
||||
expected = {
|
||||
LENGTH: LENGTH_KILOMETERS,
|
||||
WIND_SPEED: SPEED_METERS_PER_SECOND,
|
||||
TEMPERATURE: TEMP_CELSIUS,
|
||||
VOLUME: VOLUME_LITERS,
|
||||
MASS: MASS_GRAMS,
|
||||
PRESSURE: PRESSURE_PA,
|
||||
ACCUMULATED_PRECIPITATION: LENGTH_MILLIMETERS,
|
||||
LENGTH: UnitOfLength.KILOMETERS,
|
||||
WIND_SPEED: UnitOfSpeed.METERS_PER_SECOND,
|
||||
TEMPERATURE: UnitOfTemperature.CELSIUS,
|
||||
VOLUME: UnitOfVolume.LITERS,
|
||||
MASS: UnitOfMass.GRAMS,
|
||||
PRESSURE: UnitOfPressure.PA,
|
||||
ACCUMULATED_PRECIPITATION: UnitOfLength.MILLIMETERS,
|
||||
}
|
||||
|
||||
assert expected == METRIC_SYSTEM.as_dict()
|
||||
|
|
@ -318,13 +302,13 @@ def test_accumulated_precipitation_to_imperial():
|
|||
|
||||
def test_properties():
|
||||
"""Test the unit properties are returned as expected."""
|
||||
assert METRIC_SYSTEM.length_unit == LENGTH_KILOMETERS
|
||||
assert METRIC_SYSTEM.wind_speed_unit == SPEED_METERS_PER_SECOND
|
||||
assert METRIC_SYSTEM.temperature_unit == TEMP_CELSIUS
|
||||
assert METRIC_SYSTEM.mass_unit == MASS_GRAMS
|
||||
assert METRIC_SYSTEM.volume_unit == VOLUME_LITERS
|
||||
assert METRIC_SYSTEM.pressure_unit == PRESSURE_PA
|
||||
assert METRIC_SYSTEM.accumulated_precipitation_unit == LENGTH_MILLIMETERS
|
||||
assert METRIC_SYSTEM.length_unit == UnitOfLength.KILOMETERS
|
||||
assert METRIC_SYSTEM.wind_speed_unit == UnitOfSpeed.METERS_PER_SECOND
|
||||
assert METRIC_SYSTEM.temperature_unit == UnitOfTemperature.CELSIUS
|
||||
assert METRIC_SYSTEM.mass_unit == UnitOfMass.GRAMS
|
||||
assert METRIC_SYSTEM.volume_unit == UnitOfVolume.LITERS
|
||||
assert METRIC_SYSTEM.pressure_unit == UnitOfPressure.PA
|
||||
assert METRIC_SYSTEM.accumulated_precipitation_unit == UnitOfLength.MILLIMETERS
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
|
|
@ -397,36 +381,44 @@ def test_get_unit_system_invalid(key: str) -> None:
|
|||
"device_class, original_unit, state_unit",
|
||||
(
|
||||
# Test distance conversion
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_FEET, LENGTH_METERS),
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_INCHES, LENGTH_MILLIMETERS),
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_MILES, LENGTH_KILOMETERS),
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_YARD, LENGTH_METERS),
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_KILOMETERS, None),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.FEET, UnitOfLength.METERS),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.INCHES, UnitOfLength.MILLIMETERS),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.MILES, UnitOfLength.KILOMETERS),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.YARDS, UnitOfLength.METERS),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.KILOMETERS, None),
|
||||
(SensorDeviceClass.DISTANCE, "very_long", None),
|
||||
# Test gas meter conversion
|
||||
(SensorDeviceClass.GAS, VOLUME_CUBIC_FEET, VOLUME_CUBIC_METERS),
|
||||
(SensorDeviceClass.GAS, VOLUME_CUBIC_METERS, None),
|
||||
(SensorDeviceClass.GAS, UnitOfVolume.CUBIC_FEET, UnitOfVolume.CUBIC_METERS),
|
||||
(SensorDeviceClass.GAS, UnitOfVolume.CUBIC_METERS, None),
|
||||
(SensorDeviceClass.GAS, "very_much", None),
|
||||
# Test speed conversion
|
||||
(SensorDeviceClass.SPEED, SPEED_FEET_PER_SECOND, SPEED_KILOMETERS_PER_HOUR),
|
||||
(SensorDeviceClass.SPEED, SPEED_MILES_PER_HOUR, SPEED_KILOMETERS_PER_HOUR),
|
||||
(SensorDeviceClass.SPEED, SPEED_KILOMETERS_PER_HOUR, None),
|
||||
(SensorDeviceClass.SPEED, SPEED_KNOTS, None),
|
||||
(SensorDeviceClass.SPEED, SPEED_METERS_PER_SECOND, None),
|
||||
(
|
||||
SensorDeviceClass.SPEED,
|
||||
UnitOfSpeed.FEET_PER_SECOND,
|
||||
UnitOfSpeed.KILOMETERS_PER_HOUR,
|
||||
),
|
||||
(
|
||||
SensorDeviceClass.SPEED,
|
||||
UnitOfSpeed.MILES_PER_HOUR,
|
||||
UnitOfSpeed.KILOMETERS_PER_HOUR,
|
||||
),
|
||||
(SensorDeviceClass.SPEED, UnitOfSpeed.KILOMETERS_PER_HOUR, None),
|
||||
(SensorDeviceClass.SPEED, UnitOfSpeed.KNOTS, None),
|
||||
(SensorDeviceClass.SPEED, UnitOfSpeed.METERS_PER_SECOND, None),
|
||||
(SensorDeviceClass.SPEED, "very_fast", None),
|
||||
# Test volume conversion
|
||||
(SensorDeviceClass.VOLUME, VOLUME_CUBIC_FEET, VOLUME_CUBIC_METERS),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_FLUID_OUNCE, VOLUME_MILLILITERS),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_GALLONS, VOLUME_LITERS),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_CUBIC_METERS, None),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_LITERS, None),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_MILLILITERS, None),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.CUBIC_FEET, UnitOfVolume.CUBIC_METERS),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.FLUID_OUNCES, UnitOfVolume.MILLILITERS),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.GALLONS, UnitOfVolume.LITERS),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.CUBIC_METERS, None),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.LITERS, None),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.MILLILITERS, None),
|
||||
(SensorDeviceClass.VOLUME, "very_much", None),
|
||||
# Test water meter conversion
|
||||
(SensorDeviceClass.WATER, VOLUME_CUBIC_FEET, VOLUME_CUBIC_METERS),
|
||||
(SensorDeviceClass.WATER, VOLUME_GALLONS, VOLUME_LITERS),
|
||||
(SensorDeviceClass.WATER, VOLUME_CUBIC_METERS, None),
|
||||
(SensorDeviceClass.WATER, VOLUME_LITERS, None),
|
||||
(SensorDeviceClass.WATER, UnitOfVolume.CUBIC_FEET, UnitOfVolume.CUBIC_METERS),
|
||||
(SensorDeviceClass.WATER, UnitOfVolume.GALLONS, UnitOfVolume.LITERS),
|
||||
(SensorDeviceClass.WATER, UnitOfVolume.CUBIC_METERS, None),
|
||||
(SensorDeviceClass.WATER, UnitOfVolume.LITERS, None),
|
||||
(SensorDeviceClass.WATER, "very_much", None),
|
||||
),
|
||||
)
|
||||
|
|
@ -444,36 +436,44 @@ def test_get_metric_converted_unit_(
|
|||
"device_class, original_unit, state_unit",
|
||||
(
|
||||
# Test distance conversion
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_CENTIMETERS, LENGTH_INCHES),
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_KILOMETERS, LENGTH_MILES),
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_METERS, LENGTH_FEET),
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_MILLIMETERS, LENGTH_INCHES),
|
||||
(SensorDeviceClass.DISTANCE, LENGTH_MILES, None),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.CENTIMETERS, UnitOfLength.INCHES),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.KILOMETERS, UnitOfLength.MILES),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.METERS, UnitOfLength.FEET),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.MILLIMETERS, UnitOfLength.INCHES),
|
||||
(SensorDeviceClass.DISTANCE, UnitOfLength.MILES, None),
|
||||
(SensorDeviceClass.DISTANCE, "very_long", None),
|
||||
# Test gas meter conversion
|
||||
(SensorDeviceClass.GAS, VOLUME_CUBIC_METERS, VOLUME_CUBIC_FEET),
|
||||
(SensorDeviceClass.GAS, VOLUME_CUBIC_FEET, None),
|
||||
(SensorDeviceClass.GAS, UnitOfVolume.CUBIC_METERS, UnitOfVolume.CUBIC_FEET),
|
||||
(SensorDeviceClass.GAS, UnitOfVolume.CUBIC_FEET, None),
|
||||
(SensorDeviceClass.GAS, "very_much", None),
|
||||
# Test speed conversion
|
||||
(SensorDeviceClass.SPEED, SPEED_METERS_PER_SECOND, SPEED_MILES_PER_HOUR),
|
||||
(SensorDeviceClass.SPEED, SPEED_KILOMETERS_PER_HOUR, SPEED_MILES_PER_HOUR),
|
||||
(SensorDeviceClass.SPEED, SPEED_FEET_PER_SECOND, None),
|
||||
(SensorDeviceClass.SPEED, SPEED_KNOTS, None),
|
||||
(SensorDeviceClass.SPEED, SPEED_MILES_PER_HOUR, None),
|
||||
(
|
||||
SensorDeviceClass.SPEED,
|
||||
UnitOfSpeed.METERS_PER_SECOND,
|
||||
UnitOfSpeed.MILES_PER_HOUR,
|
||||
),
|
||||
(
|
||||
SensorDeviceClass.SPEED,
|
||||
UnitOfSpeed.KILOMETERS_PER_HOUR,
|
||||
UnitOfSpeed.MILES_PER_HOUR,
|
||||
),
|
||||
(SensorDeviceClass.SPEED, UnitOfSpeed.FEET_PER_SECOND, None),
|
||||
(SensorDeviceClass.SPEED, UnitOfSpeed.KNOTS, None),
|
||||
(SensorDeviceClass.SPEED, UnitOfSpeed.MILES_PER_HOUR, None),
|
||||
(SensorDeviceClass.SPEED, "very_fast", None),
|
||||
# Test volume conversion
|
||||
(SensorDeviceClass.VOLUME, VOLUME_CUBIC_METERS, VOLUME_CUBIC_FEET),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_LITERS, VOLUME_GALLONS),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_MILLILITERS, VOLUME_FLUID_OUNCE),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_CUBIC_FEET, None),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_FLUID_OUNCE, None),
|
||||
(SensorDeviceClass.VOLUME, VOLUME_GALLONS, None),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.CUBIC_METERS, UnitOfVolume.CUBIC_FEET),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.LITERS, UnitOfVolume.GALLONS),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.MILLILITERS, UnitOfVolume.FLUID_OUNCES),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.CUBIC_FEET, None),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.FLUID_OUNCES, None),
|
||||
(SensorDeviceClass.VOLUME, UnitOfVolume.GALLONS, None),
|
||||
(SensorDeviceClass.VOLUME, "very_much", None),
|
||||
# Test water meter conversion
|
||||
(SensorDeviceClass.WATER, VOLUME_CUBIC_METERS, VOLUME_CUBIC_FEET),
|
||||
(SensorDeviceClass.WATER, VOLUME_LITERS, VOLUME_GALLONS),
|
||||
(SensorDeviceClass.WATER, VOLUME_CUBIC_FEET, None),
|
||||
(SensorDeviceClass.WATER, VOLUME_GALLONS, None),
|
||||
(SensorDeviceClass.WATER, UnitOfVolume.CUBIC_METERS, UnitOfVolume.CUBIC_FEET),
|
||||
(SensorDeviceClass.WATER, UnitOfVolume.LITERS, UnitOfVolume.GALLONS),
|
||||
(SensorDeviceClass.WATER, UnitOfVolume.CUBIC_FEET, None),
|
||||
(SensorDeviceClass.WATER, UnitOfVolume.GALLONS, None),
|
||||
(SensorDeviceClass.WATER, "very_much", None),
|
||||
),
|
||||
)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue