diff --git a/homeassistant/util/unit_conversion.py b/homeassistant/util/unit_conversion.py index 1cf00230d1c..aa2782e423f 100644 --- a/homeassistant/util/unit_conversion.py +++ b/homeassistant/util/unit_conversion.py @@ -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) diff --git a/homeassistant/util/unit_system.py b/homeassistant/util/unit_system.py index 42cf429650a..7e338f8f313 100644 --- a/homeassistant/util/unit_system.py +++ b/homeassistant/util/unit_system.py @@ -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 diff --git a/tests/components/flipr/test_sensor.py b/tests/components/flipr/test_sensor.py index 30468064dae..1b8a1928b1f 100644 --- a/tests/components/flipr/test_sensor.py +++ b/tests/components/flipr/test_sensor.py @@ -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" diff --git a/tests/util/test_unit_conversion.py b/tests/util/test_unit_conversion.py index 1b43af09aec..b2b99d6f8c0 100644 --- a/tests/util/test_unit_conversion.py +++ b/tests/util/test_unit_conversion.py @@ -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( diff --git a/tests/util/test_unit_system.py b/tests/util/test_unit_system.py index db396738503..03385196cab 100644 --- a/tests/util/test_unit_system.py +++ b/tests/util/test_unit_system.py @@ -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), ), )