evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use unit enums in unit utilities (#81030)

Browse source
This commit is contained in:
epenet 2022-10-26 20:47:17 +02:00 • committed by GitHub
parent 37cfa3e19b
commit 2a2e097e17
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 690 additions and 591 deletions
Download patch file Download diff file Expand all files Collapse all files

203
homeassistant/util/unit_conversion.py
View file

@ -2,39 +2,6 @@
from __future__ import annotations from __future__ import annotations
from homeassistant.const import ( 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, UNIT_NOT_RECOGNIZED_TEMPLATE,
VOLUME_CUBIC_FEET, VOLUME_CUBIC_FEET,
VOLUME_CUBIC_METERS, VOLUME_CUBIC_METERS,
@ -43,6 +10,12 @@ from homeassistant.const import (
VOLUME_LITERS, VOLUME_LITERS,
VOLUME_MILLILITERS, VOLUME_MILLILITERS,
UnitOfEnergy, UnitOfEnergy,
UnitOfLength,
UnitOfMass,
UnitOfPower,
UnitOfPressure,
UnitOfSpeed,
UnitOfTemperature,
UnitOfVolumetricFlux, UnitOfVolumetricFlux,
) )
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
@ -121,26 +94,26 @@ class DistanceConverter(BaseUnitConverter):
"""Utility to convert distance values.""" """Utility to convert distance values."""
UNIT_CLASS = "distance" UNIT_CLASS = "distance"
NORMALIZED_UNIT = LENGTH_METERS NORMALIZED_UNIT = UnitOfLength.METERS
_UNIT_CONVERSION: dict[str, float] = { _UNIT_CONVERSION: dict[str, float] = {
LENGTH_METERS: 1, UnitOfLength.METERS: 1,
LENGTH_MILLIMETERS: 1 / _MM_TO_M, UnitOfLength.MILLIMETERS: 1 / _MM_TO_M,
LENGTH_CENTIMETERS: 1 / _CM_TO_M, UnitOfLength.CENTIMETERS: 1 / _CM_TO_M,
LENGTH_KILOMETERS: 1 / _KM_TO_M, UnitOfLength.KILOMETERS: 1 / _KM_TO_M,
LENGTH_INCHES: 1 / _IN_TO_M, UnitOfLength.INCHES: 1 / _IN_TO_M,
LENGTH_FEET: 1 / _FOOT_TO_M, UnitOfLength.FEET: 1 / _FOOT_TO_M,
LENGTH_YARD: 1 / _YARD_TO_M, UnitOfLength.YARDS: 1 / _YARD_TO_M,
LENGTH_MILES: 1 / _MILE_TO_M, UnitOfLength.MILES: 1 / _MILE_TO_M,
} }
VALID_UNITS = { VALID_UNITS = {
LENGTH_KILOMETERS, UnitOfLength.KILOMETERS,
LENGTH_MILES, UnitOfLength.MILES,
LENGTH_FEET, UnitOfLength.FEET,
LENGTH_METERS, UnitOfLength.METERS,
LENGTH_CENTIMETERS, UnitOfLength.CENTIMETERS,
LENGTH_MILLIMETERS, UnitOfLength.MILLIMETERS,
LENGTH_INCHES, UnitOfLength.INCHES,
LENGTH_YARD, UnitOfLength.YARDS,
} }
@ -167,22 +140,22 @@ class MassConverter(BaseUnitConverter):
"""Utility to convert mass values.""" """Utility to convert mass values."""
UNIT_CLASS = "mass" UNIT_CLASS = "mass"
NORMALIZED_UNIT = MASS_GRAMS NORMALIZED_UNIT = UnitOfMass.GRAMS
_UNIT_CONVERSION: dict[str, float] = { _UNIT_CONVERSION: dict[str, float] = {
MASS_MICROGRAMS: 1 * 1000 * 1000, UnitOfMass.MICROGRAMS: 1 * 1000 * 1000,
MASS_MILLIGRAMS: 1 * 1000, UnitOfMass.MILLIGRAMS: 1 * 1000,
MASS_GRAMS: 1, UnitOfMass.GRAMS: 1,
MASS_KILOGRAMS: 1 / 1000, UnitOfMass.KILOGRAMS: 1 / 1000,
MASS_OUNCES: 1 / _OUNCE_TO_G, UnitOfMass.OUNCES: 1 / _OUNCE_TO_G,
MASS_POUNDS: 1 / _POUND_TO_G, UnitOfMass.POUNDS: 1 / _POUND_TO_G,
} }
VALID_UNITS = { VALID_UNITS = {
MASS_GRAMS, UnitOfMass.GRAMS,
MASS_KILOGRAMS, UnitOfMass.KILOGRAMS,
MASS_MILLIGRAMS, UnitOfMass.MILLIGRAMS,
MASS_MICROGRAMS, UnitOfMass.MICROGRAMS,
MASS_OUNCES, UnitOfMass.OUNCES,
MASS_POUNDS, UnitOfMass.POUNDS,
} }
@ -190,14 +163,14 @@ class PowerConverter(BaseUnitConverter):
"""Utility to convert power values.""" """Utility to convert power values."""
UNIT_CLASS = "power" UNIT_CLASS = "power"
NORMALIZED_UNIT = POWER_WATT NORMALIZED_UNIT = UnitOfPower.WATT
_UNIT_CONVERSION: dict[str, float] = { _UNIT_CONVERSION: dict[str, float] = {
POWER_WATT: 1, UnitOfPower.WATT: 1,
POWER_KILO_WATT: 1 / 1000, UnitOfPower.KILO_WATT: 1 / 1000,
} }
VALID_UNITS = { VALID_UNITS = {
POWER_WATT, UnitOfPower.WATT,
POWER_KILO_WATT, UnitOfPower.KILO_WATT,
} }
@ -205,28 +178,30 @@ class PressureConverter(BaseUnitConverter):
"""Utility to convert pressure values.""" """Utility to convert pressure values."""
UNIT_CLASS = "pressure" UNIT_CLASS = "pressure"
NORMALIZED_UNIT = PRESSURE_PA NORMALIZED_UNIT = UnitOfPressure.PA
_UNIT_CONVERSION: dict[str, float] = { _UNIT_CONVERSION: dict[str, float] = {
PRESSURE_PA: 1, UnitOfPressure.PA: 1,
PRESSURE_HPA: 1 / 100, UnitOfPressure.HPA: 1 / 100,
PRESSURE_KPA: 1 / 1000, UnitOfPressure.KPA: 1 / 1000,
PRESSURE_BAR: 1 / 100000, UnitOfPressure.BAR: 1 / 100000,
PRESSURE_CBAR: 1 / 1000, UnitOfPressure.CBAR: 1 / 1000,
PRESSURE_MBAR: 1 / 100, UnitOfPressure.MBAR: 1 / 100,
PRESSURE_INHG: 1 / (_IN_TO_M * 1000 * _STANDARD_GRAVITY * _MERCURY_DENSITY), UnitOfPressure.INHG: 1
PRESSURE_PSI: 1 / 6894.757, / (_IN_TO_M * 1000 * _STANDARD_GRAVITY * _MERCURY_DENSITY),
PRESSURE_MMHG: 1 / (_MM_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 = { VALID_UNITS = {
PRESSURE_PA, UnitOfPressure.PA,
PRESSURE_HPA, UnitOfPressure.HPA,
PRESSURE_KPA, UnitOfPressure.KPA,
PRESSURE_BAR, UnitOfPressure.BAR,
PRESSURE_CBAR, UnitOfPressure.CBAR,
PRESSURE_MBAR, UnitOfPressure.MBAR,
PRESSURE_INHG, UnitOfPressure.INHG,
PRESSURE_PSI, UnitOfPressure.PSI,
PRESSURE_MMHG, UnitOfPressure.MMHG,
} }
@ -234,28 +209,28 @@ class SpeedConverter(BaseUnitConverter):
"""Utility to convert speed values.""" """Utility to convert speed values."""
UNIT_CLASS = "speed" UNIT_CLASS = "speed"
NORMALIZED_UNIT = SPEED_METERS_PER_SECOND NORMALIZED_UNIT = UnitOfSpeed.METERS_PER_SECOND
_UNIT_CONVERSION: dict[str, float] = { _UNIT_CONVERSION: dict[str, float] = {
UnitOfVolumetricFlux.INCHES_PER_DAY: _DAYS_TO_SECS / _IN_TO_M, UnitOfVolumetricFlux.INCHES_PER_DAY: _DAYS_TO_SECS / _IN_TO_M,
UnitOfVolumetricFlux.INCHES_PER_HOUR: _HRS_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_DAY: _DAYS_TO_SECS / _MM_TO_M,
UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR: _HRS_TO_SECS / _MM_TO_M, UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR: _HRS_TO_SECS / _MM_TO_M,
SPEED_FEET_PER_SECOND: 1 / _FOOT_TO_M, UnitOfSpeed.FEET_PER_SECOND: 1 / _FOOT_TO_M,
SPEED_KILOMETERS_PER_HOUR: _HRS_TO_SECS / _KM_TO_M, UnitOfSpeed.KILOMETERS_PER_HOUR: _HRS_TO_SECS / _KM_TO_M,
SPEED_KNOTS: _HRS_TO_SECS / _NAUTICAL_MILE_TO_M, UnitOfSpeed.KNOTS: _HRS_TO_SECS / _NAUTICAL_MILE_TO_M,
SPEED_METERS_PER_SECOND: 1, UnitOfSpeed.METERS_PER_SECOND: 1,
SPEED_MILES_PER_HOUR: _HRS_TO_SECS / _MILE_TO_M, UnitOfSpeed.MILES_PER_HOUR: _HRS_TO_SECS / _MILE_TO_M,
} }
VALID_UNITS = { VALID_UNITS = {
UnitOfVolumetricFlux.INCHES_PER_DAY, UnitOfVolumetricFlux.INCHES_PER_DAY,
UnitOfVolumetricFlux.INCHES_PER_HOUR, UnitOfVolumetricFlux.INCHES_PER_HOUR,
UnitOfVolumetricFlux.MILLIMETERS_PER_DAY, UnitOfVolumetricFlux.MILLIMETERS_PER_DAY,
UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR, UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR,
SPEED_FEET_PER_SECOND, UnitOfSpeed.FEET_PER_SECOND,
SPEED_KILOMETERS_PER_HOUR, UnitOfSpeed.KILOMETERS_PER_HOUR,
SPEED_KNOTS, UnitOfSpeed.KNOTS,
SPEED_METERS_PER_SECOND, UnitOfSpeed.METERS_PER_SECOND,
SPEED_MILES_PER_HOUR, UnitOfSpeed.MILES_PER_HOUR,
} }
@ -263,16 +238,16 @@ class TemperatureConverter(BaseUnitConverter):
"""Utility to convert temperature values.""" """Utility to convert temperature values."""
UNIT_CLASS = "temperature" UNIT_CLASS = "temperature"
NORMALIZED_UNIT = TEMP_CELSIUS NORMALIZED_UNIT = UnitOfTemperature.CELSIUS
VALID_UNITS = { VALID_UNITS = {
TEMP_CELSIUS, UnitOfTemperature.CELSIUS,
TEMP_FAHRENHEIT, UnitOfTemperature.FAHRENHEIT,
TEMP_KELVIN, UnitOfTemperature.KELVIN,
} }
_UNIT_CONVERSION = { _UNIT_CONVERSION = {
TEMP_CELSIUS: 1.0, UnitOfTemperature.CELSIUS: 1.0,
TEMP_FAHRENHEIT: 1.8, UnitOfTemperature.FAHRENHEIT: 1.8,
TEMP_KELVIN: 1.0, UnitOfTemperature.KELVIN: 1.0,
} }
@classmethod @classmethod
@ -289,28 +264,28 @@ class TemperatureConverter(BaseUnitConverter):
if from_unit == to_unit: if from_unit == to_unit:
return value return value
if from_unit == TEMP_CELSIUS: if from_unit == UnitOfTemperature.CELSIUS:
if to_unit == TEMP_FAHRENHEIT: if to_unit == UnitOfTemperature.FAHRENHEIT:
return cls._celsius_to_fahrenheit(value) return cls._celsius_to_fahrenheit(value)
if to_unit == TEMP_KELVIN: if to_unit == UnitOfTemperature.KELVIN:
return cls._celsius_to_kelvin(value) return cls._celsius_to_kelvin(value)
raise HomeAssistantError( raise HomeAssistantError(
UNIT_NOT_RECOGNIZED_TEMPLATE.format(to_unit, cls.UNIT_CLASS) UNIT_NOT_RECOGNIZED_TEMPLATE.format(to_unit, cls.UNIT_CLASS)
) )
if from_unit == TEMP_FAHRENHEIT: if from_unit == UnitOfTemperature.FAHRENHEIT:
if to_unit == TEMP_CELSIUS: if to_unit == UnitOfTemperature.CELSIUS:
return cls._fahrenheit_to_celsius(value) 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)) return cls._celsius_to_kelvin(cls._fahrenheit_to_celsius(value))
raise HomeAssistantError( raise HomeAssistantError(
UNIT_NOT_RECOGNIZED_TEMPLATE.format(to_unit, cls.UNIT_CLASS) UNIT_NOT_RECOGNIZED_TEMPLATE.format(to_unit, cls.UNIT_CLASS)
) )
if from_unit == TEMP_KELVIN: if from_unit == UnitOfTemperature.KELVIN:
if to_unit == TEMP_CELSIUS: if to_unit == UnitOfTemperature.CELSIUS:
return cls._kelvin_to_celsius(value) 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)) return cls._celsius_to_fahrenheit(cls._kelvin_to_celsius(value))
raise HomeAssistantError( raise HomeAssistantError(
UNIT_NOT_RECOGNIZED_TEMPLATE.format(to_unit, cls.UNIT_CLASS) UNIT_NOT_RECOGNIZED_TEMPLATE.format(to_unit, cls.UNIT_CLASS)

150
homeassistant/util/unit_system.py
View file

@ -9,40 +9,18 @@ import voluptuous as vol
from homeassistant.const import ( from homeassistant.const import (
ACCUMULATED_PRECIPITATION, ACCUMULATED_PRECIPITATION,
LENGTH, LENGTH,
LENGTH_CENTIMETERS,
LENGTH_FEET,
LENGTH_INCHES,
LENGTH_KILOMETERS,
LENGTH_METERS,
LENGTH_MILES,
LENGTH_MILLIMETERS,
LENGTH_YARD,
MASS, MASS,
MASS_GRAMS,
MASS_KILOGRAMS,
MASS_OUNCES,
MASS_POUNDS,
PRECIPITATION_INCHES,
PRECIPITATION_MILLIMETERS,
PRESSURE, 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, TEMPERATURE,
UNIT_NOT_RECOGNIZED_TEMPLATE, UNIT_NOT_RECOGNIZED_TEMPLATE,
VOLUME, VOLUME,
VOLUME_CUBIC_FEET,
VOLUME_CUBIC_METERS,
VOLUME_FLUID_OUNCE,
VOLUME_GALLONS,
VOLUME_LITERS,
VOLUME_MILLILITERS,
WIND_SPEED, WIND_SPEED,
UnitOfLength,
UnitOfMass,
UnitOfPressure,
UnitOfSpeed,
UnitOfTemperature,
UnitOfVolume,
) )
from homeassistant.helpers.frame import report from homeassistant.helpers.frame import report
@ -63,7 +41,12 @@ _CONF_UNIT_SYSTEM_US_CUSTOMARY: Final = "us_customary"
LENGTH_UNITS = DistanceConverter.VALID_UNITS 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 PRESSURE_UNITS = PressureConverter.VALID_UNITS
@ -71,29 +54,26 @@ VOLUME_UNITS = VolumeConverter.VALID_UNITS
WIND_SPEED_UNITS = SpeedConverter.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: def _is_valid_unit(unit: str, unit_type: str) -> bool:
"""Check if the unit is valid for it's type.""" """Check if the unit is valid for it's type."""
if unit_type == LENGTH: if unit_type == LENGTH:
units = LENGTH_UNITS return unit in LENGTH_UNITS
elif unit_type == ACCUMULATED_PRECIPITATION: if unit_type == ACCUMULATED_PRECIPITATION:
units = LENGTH_UNITS return unit in LENGTH_UNITS
elif unit_type == WIND_SPEED: if unit_type == WIND_SPEED:
units = WIND_SPEED_UNITS return unit in WIND_SPEED_UNITS
elif unit_type == TEMPERATURE: if unit_type == TEMPERATURE:
units = TEMPERATURE_UNITS return unit in TEMPERATURE_UNITS
elif unit_type == MASS: if unit_type == MASS:
units = MASS_UNITS return unit in MASS_UNITS
elif unit_type == VOLUME: if unit_type == VOLUME:
units = VOLUME_UNITS return unit in VOLUME_UNITS
elif unit_type == PRESSURE: if unit_type == PRESSURE:
units = PRESSURE_UNITS return unit in PRESSURE_UNITS
else: return False
return False
return unit in units
class UnitSystem: class UnitSystem:
@ -267,62 +247,62 @@ validate_unit_system = vol.All(
METRIC_SYSTEM = UnitSystem( METRIC_SYSTEM = UnitSystem(
_CONF_UNIT_SYSTEM_METRIC, _CONF_UNIT_SYSTEM_METRIC,
accumulated_precipitation=PRECIPITATION_MILLIMETERS, accumulated_precipitation=UnitOfLength.MILLIMETERS,
conversions={ conversions={
# Convert non-metric distances # Convert non-metric distances
("distance", LENGTH_FEET): LENGTH_METERS, ("distance", UnitOfLength.FEET): UnitOfLength.METERS,
("distance", LENGTH_INCHES): LENGTH_MILLIMETERS, ("distance", UnitOfLength.INCHES): UnitOfLength.MILLIMETERS,
("distance", LENGTH_MILES): LENGTH_KILOMETERS, ("distance", UnitOfLength.MILES): UnitOfLength.KILOMETERS,
("distance", LENGTH_YARD): LENGTH_METERS, ("distance", UnitOfLength.YARDS): UnitOfLength.METERS,
# Convert non-metric volumes of gas 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 # Convert non-metric speeds except knots to km/h
("speed", SPEED_FEET_PER_SECOND): SPEED_KILOMETERS_PER_HOUR, ("speed", UnitOfSpeed.FEET_PER_SECOND): UnitOfSpeed.KILOMETERS_PER_HOUR,
("speed", SPEED_MILES_PER_HOUR): SPEED_KILOMETERS_PER_HOUR, ("speed", UnitOfSpeed.MILES_PER_HOUR): UnitOfSpeed.KILOMETERS_PER_HOUR,
# Convert non-metric volumes # Convert non-metric volumes
("volume", VOLUME_CUBIC_FEET): VOLUME_CUBIC_METERS, ("volume", UnitOfVolume.CUBIC_FEET): UnitOfVolume.CUBIC_METERS,
("volume", VOLUME_FLUID_OUNCE): VOLUME_MILLILITERS, ("volume", UnitOfVolume.FLUID_OUNCES): UnitOfVolume.MILLILITERS,
("volume", VOLUME_GALLONS): VOLUME_LITERS, ("volume", UnitOfVolume.GALLONS): UnitOfVolume.LITERS,
# Convert non-metric volumes of water meters # Convert non-metric volumes of water meters
("water", VOLUME_CUBIC_FEET): VOLUME_CUBIC_METERS, ("water", UnitOfVolume.CUBIC_FEET): UnitOfVolume.CUBIC_METERS,
("water", VOLUME_GALLONS): VOLUME_LITERS, ("water", UnitOfVolume.GALLONS): UnitOfVolume.LITERS,
}, },
length=LENGTH_KILOMETERS, length=UnitOfLength.KILOMETERS,
mass=MASS_GRAMS, mass=UnitOfMass.GRAMS,
pressure=PRESSURE_PA, pressure=UnitOfPressure.PA,
temperature=TEMP_CELSIUS, temperature=UnitOfTemperature.CELSIUS,
volume=VOLUME_LITERS, volume=UnitOfVolume.LITERS,
wind_speed=SPEED_METERS_PER_SECOND, wind_speed=UnitOfSpeed.METERS_PER_SECOND,
) )
US_CUSTOMARY_SYSTEM = UnitSystem( US_CUSTOMARY_SYSTEM = UnitSystem(
_CONF_UNIT_SYSTEM_US_CUSTOMARY, _CONF_UNIT_SYSTEM_US_CUSTOMARY,
accumulated_precipitation=PRECIPITATION_INCHES, accumulated_precipitation=UnitOfLength.INCHES,
conversions={ conversions={
# Convert non-USCS distances # Convert non-USCS distances
("distance", LENGTH_CENTIMETERS): LENGTH_INCHES, ("distance", UnitOfLength.CENTIMETERS): UnitOfLength.INCHES,
("distance", LENGTH_KILOMETERS): LENGTH_MILES, ("distance", UnitOfLength.KILOMETERS): UnitOfLength.MILES,
("distance", LENGTH_METERS): LENGTH_FEET, ("distance", UnitOfLength.METERS): UnitOfLength.FEET,
("distance", LENGTH_MILLIMETERS): LENGTH_INCHES, ("distance", UnitOfLength.MILLIMETERS): UnitOfLength.INCHES,
# Convert non-USCS volumes of gas meters # 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 # Convert non-USCS speeds except knots to mph
("speed", SPEED_METERS_PER_SECOND): SPEED_MILES_PER_HOUR, ("speed", UnitOfSpeed.METERS_PER_SECOND): UnitOfSpeed.MILES_PER_HOUR,
("speed", SPEED_KILOMETERS_PER_HOUR): SPEED_MILES_PER_HOUR, ("speed", UnitOfSpeed.KILOMETERS_PER_HOUR): UnitOfSpeed.MILES_PER_HOUR,
# Convert non-USCS volumes # Convert non-USCS volumes
("volume", VOLUME_CUBIC_METERS): VOLUME_CUBIC_FEET, ("volume", UnitOfVolume.CUBIC_METERS): UnitOfVolume.CUBIC_FEET,
("volume", VOLUME_LITERS): VOLUME_GALLONS, ("volume", UnitOfVolume.LITERS): UnitOfVolume.GALLONS,
("volume", VOLUME_MILLILITERS): VOLUME_FLUID_OUNCE, ("volume", UnitOfVolume.MILLILITERS): UnitOfVolume.FLUID_OUNCES,
# Convert non-USCS volumes of water meters # Convert non-USCS volumes of water meters
("water", VOLUME_CUBIC_METERS): VOLUME_CUBIC_FEET, ("water", UnitOfVolume.CUBIC_METERS): UnitOfVolume.CUBIC_FEET,
("water", VOLUME_LITERS): VOLUME_GALLONS, ("water", UnitOfVolume.LITERS): UnitOfVolume.GALLONS,
}, },
length=LENGTH_MILES, length=UnitOfLength.MILES,
mass=MASS_POUNDS, mass=UnitOfMass.POUNDS,
pressure=PRESSURE_PSI, pressure=UnitOfPressure.PSI,
temperature=TEMP_FAHRENHEIT, temperature=UnitOfTemperature.FAHRENHEIT,
volume=VOLUME_GALLONS, volume=UnitOfVolume.GALLONS,
wind_speed=SPEED_MILES_PER_HOUR, wind_speed=UnitOfSpeed.MILES_PER_HOUR,
) )
IMPERIAL_SYSTEM = US_CUSTOMARY_SYSTEM IMPERIAL_SYSTEM = US_CUSTOMARY_SYSTEM

2
tests/components/flipr/test_sensor.py
View file

@ -69,7 +69,7 @@ async def test_sensors(hass: HomeAssistant) -> None:
state = hass.states.get("sensor.flipr_myfliprid_water_temp") state = hass.states.get("sensor.flipr_myfliprid_water_temp")
assert state assert state
assert state.attributes.get(ATTR_ICON) is None 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.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.state == "10.5" assert state.state == "10.5"

670
tests/util/test_unit_conversion.py
View file

@ -2,45 +2,14 @@
import pytest import pytest
from homeassistant.const import ( 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, UnitOfEnergy,
UnitOfLength,
UnitOfMass,
UnitOfPower,
UnitOfPressure,
UnitOfSpeed,
UnitOfTemperature,
UnitOfVolume,
UnitOfVolumetricFlux, UnitOfVolumetricFlux,
) )
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
@ -62,50 +31,50 @@ INVALID_SYMBOL = "bob"
@pytest.mark.parametrize( @pytest.mark.parametrize(
"converter,valid_unit", "converter,valid_unit",
[ [
(DistanceConverter, LENGTH_KILOMETERS), (DistanceConverter, UnitOfLength.KILOMETERS),
(DistanceConverter, LENGTH_METERS), (DistanceConverter, UnitOfLength.METERS),
(DistanceConverter, LENGTH_CENTIMETERS), (DistanceConverter, UnitOfLength.CENTIMETERS),
(DistanceConverter, LENGTH_MILLIMETERS), (DistanceConverter, UnitOfLength.MILLIMETERS),
(DistanceConverter, LENGTH_MILES), (DistanceConverter, UnitOfLength.MILES),
(DistanceConverter, LENGTH_YARD), (DistanceConverter, UnitOfLength.YARDS),
(DistanceConverter, LENGTH_FEET), (DistanceConverter, UnitOfLength.FEET),
(DistanceConverter, LENGTH_INCHES), (DistanceConverter, UnitOfLength.INCHES),
(EnergyConverter, UnitOfEnergy.WATT_HOUR), (EnergyConverter, UnitOfEnergy.WATT_HOUR),
(EnergyConverter, UnitOfEnergy.KILO_WATT_HOUR), (EnergyConverter, UnitOfEnergy.KILO_WATT_HOUR),
(EnergyConverter, UnitOfEnergy.MEGA_WATT_HOUR), (EnergyConverter, UnitOfEnergy.MEGA_WATT_HOUR),
(EnergyConverter, UnitOfEnergy.GIGA_JOULE), (EnergyConverter, UnitOfEnergy.GIGA_JOULE),
(MassConverter, MASS_GRAMS), (MassConverter, UnitOfMass.GRAMS),
(MassConverter, MASS_KILOGRAMS), (MassConverter, UnitOfMass.KILOGRAMS),
(MassConverter, MASS_MICROGRAMS), (MassConverter, UnitOfMass.MICROGRAMS),
(MassConverter, MASS_MILLIGRAMS), (MassConverter, UnitOfMass.MILLIGRAMS),
(MassConverter, MASS_OUNCES), (MassConverter, UnitOfMass.OUNCES),
(MassConverter, MASS_POUNDS), (MassConverter, UnitOfMass.POUNDS),
(PowerConverter, POWER_WATT), (PowerConverter, UnitOfPower.WATT),
(PowerConverter, POWER_KILO_WATT), (PowerConverter, UnitOfPower.KILO_WATT),
(PressureConverter, PRESSURE_PA), (PressureConverter, UnitOfPressure.PA),
(PressureConverter, PRESSURE_HPA), (PressureConverter, UnitOfPressure.HPA),
(PressureConverter, PRESSURE_MBAR), (PressureConverter, UnitOfPressure.MBAR),
(PressureConverter, PRESSURE_INHG), (PressureConverter, UnitOfPressure.INHG),
(PressureConverter, PRESSURE_KPA), (PressureConverter, UnitOfPressure.KPA),
(PressureConverter, PRESSURE_CBAR), (PressureConverter, UnitOfPressure.CBAR),
(PressureConverter, PRESSURE_MMHG), (PressureConverter, UnitOfPressure.MMHG),
(PressureConverter, PRESSURE_PSI), (PressureConverter, UnitOfPressure.PSI),
(SpeedConverter, UnitOfVolumetricFlux.INCHES_PER_DAY), (SpeedConverter, UnitOfVolumetricFlux.INCHES_PER_DAY),
(SpeedConverter, UnitOfVolumetricFlux.INCHES_PER_HOUR), (SpeedConverter, UnitOfVolumetricFlux.INCHES_PER_HOUR),
(SpeedConverter, UnitOfVolumetricFlux.MILLIMETERS_PER_DAY), (SpeedConverter, UnitOfVolumetricFlux.MILLIMETERS_PER_DAY),
(SpeedConverter, UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR), (SpeedConverter, UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR),
(SpeedConverter, SPEED_FEET_PER_SECOND), (SpeedConverter, UnitOfSpeed.FEET_PER_SECOND),
(SpeedConverter, SPEED_KILOMETERS_PER_HOUR), (SpeedConverter, UnitOfSpeed.KILOMETERS_PER_HOUR),
(SpeedConverter, SPEED_KNOTS), (SpeedConverter, UnitOfSpeed.KNOTS),
(SpeedConverter, SPEED_METERS_PER_SECOND), (SpeedConverter, UnitOfSpeed.METERS_PER_SECOND),
(SpeedConverter, SPEED_MILES_PER_HOUR), (SpeedConverter, UnitOfSpeed.MILES_PER_HOUR),
(TemperatureConverter, TEMP_CELSIUS), (TemperatureConverter, UnitOfTemperature.CELSIUS),
(TemperatureConverter, TEMP_FAHRENHEIT), (TemperatureConverter, UnitOfTemperature.FAHRENHEIT),
(TemperatureConverter, TEMP_KELVIN), (TemperatureConverter, UnitOfTemperature.KELVIN),
(VolumeConverter, VOLUME_LITERS), (VolumeConverter, UnitOfVolume.LITERS),
(VolumeConverter, VOLUME_MILLILITERS), (VolumeConverter, UnitOfVolume.MILLILITERS),
(VolumeConverter, VOLUME_GALLONS), (VolumeConverter, UnitOfVolume.GALLONS),
(VolumeConverter, VOLUME_FLUID_OUNCE), (VolumeConverter, UnitOfVolume.FLUID_OUNCES),
], ],
) )
def test_convert_same_unit(converter: type[BaseUnitConverter], valid_unit: str) -> None: 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( @pytest.mark.parametrize(
"converter,valid_unit", "converter,valid_unit",
[ [
(DistanceConverter, LENGTH_KILOMETERS), (DistanceConverter, UnitOfLength.KILOMETERS),
(EnergyConverter, UnitOfEnergy.KILO_WATT_HOUR), (EnergyConverter, UnitOfEnergy.KILO_WATT_HOUR),
(MassConverter, MASS_GRAMS), (MassConverter, UnitOfMass.GRAMS),
(PowerConverter, POWER_WATT), (PowerConverter, UnitOfPower.WATT),
(PressureConverter, PRESSURE_PA), (PressureConverter, UnitOfPressure.PA),
(SpeedConverter, SPEED_KILOMETERS_PER_HOUR), (SpeedConverter, UnitOfSpeed.KILOMETERS_PER_HOUR),
(TemperatureConverter, TEMP_CELSIUS), (TemperatureConverter, UnitOfTemperature.CELSIUS),
(TemperatureConverter, TEMP_FAHRENHEIT), (TemperatureConverter, UnitOfTemperature.FAHRENHEIT),
(TemperatureConverter, TEMP_KELVIN), (TemperatureConverter, UnitOfTemperature.KELVIN),
(VolumeConverter, VOLUME_LITERS), (VolumeConverter, UnitOfVolume.LITERS),
], ],
) )
def test_convert_invalid_unit( def test_convert_invalid_unit(
@ -142,14 +111,14 @@ def test_convert_invalid_unit(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"converter,from_unit,to_unit", "converter,from_unit,to_unit",
[ [
(DistanceConverter, LENGTH_KILOMETERS, LENGTH_METERS), (DistanceConverter, UnitOfLength.KILOMETERS, UnitOfLength.METERS),
(EnergyConverter, UnitOfEnergy.WATT_HOUR, UnitOfEnergy.KILO_WATT_HOUR), (EnergyConverter, UnitOfEnergy.WATT_HOUR, UnitOfEnergy.KILO_WATT_HOUR),
(MassConverter, MASS_GRAMS, MASS_KILOGRAMS), (MassConverter, UnitOfMass.GRAMS, UnitOfMass.KILOGRAMS),
(PowerConverter, POWER_WATT, POWER_KILO_WATT), (PowerConverter, UnitOfPower.WATT, UnitOfPower.KILO_WATT),
(PressureConverter, PRESSURE_HPA, PRESSURE_INHG), (PressureConverter, UnitOfPressure.HPA, UnitOfPressure.INHG),
(SpeedConverter, SPEED_KILOMETERS_PER_HOUR, SPEED_MILES_PER_HOUR), (SpeedConverter, UnitOfSpeed.KILOMETERS_PER_HOUR, UnitOfSpeed.MILES_PER_HOUR),
(TemperatureConverter, TEMP_CELSIUS, TEMP_FAHRENHEIT), (TemperatureConverter, UnitOfTemperature.CELSIUS, UnitOfTemperature.FAHRENHEIT),
(VolumeConverter, VOLUME_GALLONS, VOLUME_LITERS), (VolumeConverter, UnitOfVolume.GALLONS, UnitOfVolume.LITERS),
], ],
) )
def test_convert_nonnumeric_value( def test_convert_nonnumeric_value(
@ -163,18 +132,33 @@ def test_convert_nonnumeric_value(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"converter,from_unit,to_unit,expected", "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), (EnergyConverter, UnitOfEnergy.WATT_HOUR, UnitOfEnergy.KILO_WATT_HOUR, 1000),
(PowerConverter, POWER_WATT, POWER_KILO_WATT, 1000), (PowerConverter, UnitOfPower.WATT, UnitOfPower.KILO_WATT, 1000),
(PressureConverter, PRESSURE_HPA, PRESSURE_INHG, pytest.approx(33.86389)), (
PressureConverter,
UnitOfPressure.HPA,
UnitOfPressure.INHG,
pytest.approx(33.86389),
),
( (
SpeedConverter, SpeedConverter,
SPEED_KILOMETERS_PER_HOUR, UnitOfSpeed.KILOMETERS_PER_HOUR,
SPEED_MILES_PER_HOUR, UnitOfSpeed.MILES_PER_HOUR,
pytest.approx(1.609343), 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( def test_get_unit_ratio(
@ -187,62 +171,107 @@ def test_get_unit_ratio(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"value,from_unit,expected,to_unit", "value,from_unit,expected,to_unit",
[ [
(5, LENGTH_MILES, pytest.approx(8.04672), LENGTH_KILOMETERS), (5, UnitOfLength.MILES, pytest.approx(8.04672), UnitOfLength.KILOMETERS),
(5, LENGTH_MILES, pytest.approx(8046.72), LENGTH_METERS), (5, UnitOfLength.MILES, pytest.approx(8046.72), UnitOfLength.METERS),
(5, LENGTH_MILES, pytest.approx(804672.0), LENGTH_CENTIMETERS), (5, UnitOfLength.MILES, pytest.approx(804672.0), UnitOfLength.CENTIMETERS),
(5, LENGTH_MILES, pytest.approx(8046720.0), LENGTH_MILLIMETERS), (5, UnitOfLength.MILES, pytest.approx(8046720.0), UnitOfLength.MILLIMETERS),
(5, LENGTH_MILES, pytest.approx(8800.0), LENGTH_YARD), (5, UnitOfLength.MILES, pytest.approx(8800.0), UnitOfLength.YARDS),
(5, LENGTH_MILES, pytest.approx(26400.0008448), LENGTH_FEET), (5, UnitOfLength.MILES, pytest.approx(26400.0008448), UnitOfLength.FEET),
(5, LENGTH_MILES, pytest.approx(316800.171072), LENGTH_INCHES), (5, UnitOfLength.MILES, pytest.approx(316800.171072), UnitOfLength.INCHES),
(5, LENGTH_YARD, pytest.approx(0.0045720000000000005), LENGTH_KILOMETERS), (
(5, LENGTH_YARD, pytest.approx(4.572), LENGTH_METERS), 5,
(5, LENGTH_YARD, pytest.approx(457.2), LENGTH_CENTIMETERS), UnitOfLength.YARDS,
(5, LENGTH_YARD, pytest.approx(4572), LENGTH_MILLIMETERS), pytest.approx(0.0045720000000000005),
(5, LENGTH_YARD, pytest.approx(0.002840908212), LENGTH_MILES), UnitOfLength.KILOMETERS,
(5, LENGTH_YARD, pytest.approx(15.00000048), LENGTH_FEET), ),
(5, LENGTH_YARD, pytest.approx(180.0000972), LENGTH_INCHES), (5, UnitOfLength.YARDS, pytest.approx(4.572), UnitOfLength.METERS),
(5000, LENGTH_FEET, pytest.approx(1.524), LENGTH_KILOMETERS), (5, UnitOfLength.YARDS, pytest.approx(457.2), UnitOfLength.CENTIMETERS),
(5000, LENGTH_FEET, pytest.approx(1524), LENGTH_METERS), (5, UnitOfLength.YARDS, pytest.approx(4572), UnitOfLength.MILLIMETERS),
(5000, LENGTH_FEET, pytest.approx(152400.0), LENGTH_CENTIMETERS), (5, UnitOfLength.YARDS, pytest.approx(0.002840908212), UnitOfLength.MILES),
(5000, LENGTH_FEET, pytest.approx(1524000.0), LENGTH_MILLIMETERS), (5, UnitOfLength.YARDS, pytest.approx(15.00000048), UnitOfLength.FEET),
(5000, LENGTH_FEET, pytest.approx(0.9469694040000001), LENGTH_MILES), (5, UnitOfLength.YARDS, pytest.approx(180.0000972), UnitOfLength.INCHES),
(5000, LENGTH_FEET, pytest.approx(1666.66667), LENGTH_YARD), (5000, UnitOfLength.FEET, pytest.approx(1.524), UnitOfLength.KILOMETERS),
(5000, LENGTH_FEET, pytest.approx(60000.032400000004), LENGTH_INCHES), (5000, UnitOfLength.FEET, pytest.approx(1524), UnitOfLength.METERS),
(5000, LENGTH_INCHES, pytest.approx(0.127), LENGTH_KILOMETERS), (5000, UnitOfLength.FEET, pytest.approx(152400.0), UnitOfLength.CENTIMETERS),
(5000, LENGTH_INCHES, pytest.approx(127.0), LENGTH_METERS), (5000, UnitOfLength.FEET, pytest.approx(1524000.0), UnitOfLength.MILLIMETERS),
(5000, LENGTH_INCHES, pytest.approx(12700.0), LENGTH_CENTIMETERS), (
(5000, LENGTH_INCHES, pytest.approx(127000.0), LENGTH_MILLIMETERS), 5000,
(5000, LENGTH_INCHES, pytest.approx(0.078914117), LENGTH_MILES), UnitOfLength.FEET,
(5000, LENGTH_INCHES, pytest.approx(138.88889), LENGTH_YARD), pytest.approx(0.9469694040000001),
(5000, LENGTH_INCHES, pytest.approx(416.66668), LENGTH_FEET), UnitOfLength.MILES,
(5, LENGTH_KILOMETERS, pytest.approx(5000), LENGTH_METERS), ),
(5, LENGTH_KILOMETERS, pytest.approx(500000), LENGTH_CENTIMETERS), (5000, UnitOfLength.FEET, pytest.approx(1666.66667), UnitOfLength.YARDS),
(5, LENGTH_KILOMETERS, pytest.approx(5000000), LENGTH_MILLIMETERS), (
(5, LENGTH_KILOMETERS, pytest.approx(3.106855), LENGTH_MILES), 5000,
(5, LENGTH_KILOMETERS, pytest.approx(5468.066), LENGTH_YARD), UnitOfLength.FEET,
(5, LENGTH_KILOMETERS, pytest.approx(16404.2), LENGTH_FEET), pytest.approx(60000.032400000004),
(5, LENGTH_KILOMETERS, pytest.approx(196850.5), LENGTH_INCHES), UnitOfLength.INCHES,
(5000, LENGTH_METERS, pytest.approx(5), LENGTH_KILOMETERS), ),
(5000, LENGTH_METERS, pytest.approx(500000), LENGTH_CENTIMETERS), (5000, UnitOfLength.INCHES, pytest.approx(0.127), UnitOfLength.KILOMETERS),
(5000, LENGTH_METERS, pytest.approx(5000000), LENGTH_MILLIMETERS), (5000, UnitOfLength.INCHES, pytest.approx(127.0), UnitOfLength.METERS),
(5000, LENGTH_METERS, pytest.approx(3.106855), LENGTH_MILES), (5000, UnitOfLength.INCHES, pytest.approx(12700.0), UnitOfLength.CENTIMETERS),
(5000, LENGTH_METERS, pytest.approx(5468.066), LENGTH_YARD), (5000, UnitOfLength.INCHES, pytest.approx(127000.0), UnitOfLength.MILLIMETERS),
(5000, LENGTH_METERS, pytest.approx(16404.2), LENGTH_FEET), (5000, UnitOfLength.INCHES, pytest.approx(0.078914117), UnitOfLength.MILES),
(5000, LENGTH_METERS, pytest.approx(196850.5), LENGTH_INCHES), (5000, UnitOfLength.INCHES, pytest.approx(138.88889), UnitOfLength.YARDS),
(500000, LENGTH_CENTIMETERS, pytest.approx(5), LENGTH_KILOMETERS), (5000, UnitOfLength.INCHES, pytest.approx(416.66668), UnitOfLength.FEET),
(500000, LENGTH_CENTIMETERS, pytest.approx(5000), LENGTH_METERS), (5, UnitOfLength.KILOMETERS, pytest.approx(5000), UnitOfLength.METERS),
(500000, LENGTH_CENTIMETERS, pytest.approx(5000000), LENGTH_MILLIMETERS), (5, UnitOfLength.KILOMETERS, pytest.approx(500000), UnitOfLength.CENTIMETERS),
(500000, LENGTH_CENTIMETERS, pytest.approx(3.106855), LENGTH_MILES), (5, UnitOfLength.KILOMETERS, pytest.approx(5000000), UnitOfLength.MILLIMETERS),
(500000, LENGTH_CENTIMETERS, pytest.approx(5468.066), LENGTH_YARD), (5, UnitOfLength.KILOMETERS, pytest.approx(3.106855), UnitOfLength.MILES),
(500000, LENGTH_CENTIMETERS, pytest.approx(16404.2), LENGTH_FEET), (5, UnitOfLength.KILOMETERS, pytest.approx(5468.066), UnitOfLength.YARDS),
(500000, LENGTH_CENTIMETERS, pytest.approx(196850.5), LENGTH_INCHES), (5, UnitOfLength.KILOMETERS, pytest.approx(16404.2), UnitOfLength.FEET),
(5000000, LENGTH_MILLIMETERS, pytest.approx(5), LENGTH_KILOMETERS), (5, UnitOfLength.KILOMETERS, pytest.approx(196850.5), UnitOfLength.INCHES),
(5000000, LENGTH_MILLIMETERS, pytest.approx(5000), LENGTH_METERS), (5000, UnitOfLength.METERS, pytest.approx(5), UnitOfLength.KILOMETERS),
(5000000, LENGTH_MILLIMETERS, pytest.approx(500000), LENGTH_CENTIMETERS), (5000, UnitOfLength.METERS, pytest.approx(500000), UnitOfLength.CENTIMETERS),
(5000000, LENGTH_MILLIMETERS, pytest.approx(3.106855), LENGTH_MILES), (5000, UnitOfLength.METERS, pytest.approx(5000000), UnitOfLength.MILLIMETERS),
(5000000, LENGTH_MILLIMETERS, pytest.approx(5468.066), LENGTH_YARD), (5000, UnitOfLength.METERS, pytest.approx(3.106855), UnitOfLength.MILES),
(5000000, LENGTH_MILLIMETERS, pytest.approx(16404.2), LENGTH_FEET), (5000, UnitOfLength.METERS, pytest.approx(5468.066), UnitOfLength.YARDS),
(5000000, LENGTH_MILLIMETERS, pytest.approx(196850.5), LENGTH_INCHES), (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( def test_distance_convert(
@ -281,36 +310,41 @@ def test_energy_convert(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"value,from_unit,expected,to_unit", "value,from_unit,expected,to_unit",
[ [
(10, MASS_KILOGRAMS, 10000, MASS_GRAMS), (10, UnitOfMass.KILOGRAMS, 10000, UnitOfMass.GRAMS),
(10, MASS_KILOGRAMS, 10000000, MASS_MILLIGRAMS), (10, UnitOfMass.KILOGRAMS, 10000000, UnitOfMass.MILLIGRAMS),
(10, MASS_KILOGRAMS, 10000000000, MASS_MICROGRAMS), (10, UnitOfMass.KILOGRAMS, 10000000000, UnitOfMass.MICROGRAMS),
(10, MASS_KILOGRAMS, pytest.approx(352.73961), MASS_OUNCES), (10, UnitOfMass.KILOGRAMS, pytest.approx(352.73961), UnitOfMass.OUNCES),
(10, MASS_KILOGRAMS, pytest.approx(22.046226), MASS_POUNDS), (10, UnitOfMass.KILOGRAMS, pytest.approx(22.046226), UnitOfMass.POUNDS),
(10, MASS_GRAMS, 0.01, MASS_KILOGRAMS), (10, UnitOfMass.GRAMS, 0.01, UnitOfMass.KILOGRAMS),
(10, MASS_GRAMS, 10000, MASS_MILLIGRAMS), (10, UnitOfMass.GRAMS, 10000, UnitOfMass.MILLIGRAMS),
(10, MASS_GRAMS, 10000000, MASS_MICROGRAMS), (10, UnitOfMass.GRAMS, 10000000, UnitOfMass.MICROGRAMS),
(10, MASS_GRAMS, pytest.approx(0.35273961), MASS_OUNCES), (10, UnitOfMass.GRAMS, pytest.approx(0.35273961), UnitOfMass.OUNCES),
(10, MASS_GRAMS, pytest.approx(0.022046226), MASS_POUNDS), (10, UnitOfMass.GRAMS, pytest.approx(0.022046226), UnitOfMass.POUNDS),
(10, MASS_MILLIGRAMS, 0.00001, MASS_KILOGRAMS), (10, UnitOfMass.MILLIGRAMS, 0.00001, UnitOfMass.KILOGRAMS),
(10, MASS_MILLIGRAMS, 0.01, MASS_GRAMS), (10, UnitOfMass.MILLIGRAMS, 0.01, UnitOfMass.GRAMS),
(10, MASS_MILLIGRAMS, 10000, MASS_MICROGRAMS), (10, UnitOfMass.MILLIGRAMS, 10000, UnitOfMass.MICROGRAMS),
(10, MASS_MILLIGRAMS, pytest.approx(0.00035273961), MASS_OUNCES), (10, UnitOfMass.MILLIGRAMS, pytest.approx(0.00035273961), UnitOfMass.OUNCES),
(10, MASS_MILLIGRAMS, pytest.approx(0.000022046226), MASS_POUNDS), (10, UnitOfMass.MILLIGRAMS, pytest.approx(0.000022046226), UnitOfMass.POUNDS),
(10000, MASS_MICROGRAMS, 0.00001, MASS_KILOGRAMS), (10000, UnitOfMass.MICROGRAMS, 0.00001, UnitOfMass.KILOGRAMS),
(10000, MASS_MICROGRAMS, 0.01, MASS_GRAMS), (10000, UnitOfMass.MICROGRAMS, 0.01, UnitOfMass.GRAMS),
(10000, MASS_MICROGRAMS, 10, MASS_MILLIGRAMS), (10000, UnitOfMass.MICROGRAMS, 10, UnitOfMass.MILLIGRAMS),
(10000, MASS_MICROGRAMS, pytest.approx(0.00035273961), MASS_OUNCES), (10000, UnitOfMass.MICROGRAMS, pytest.approx(0.00035273961), UnitOfMass.OUNCES),
(10000, MASS_MICROGRAMS, pytest.approx(0.000022046226), MASS_POUNDS), (
(1, MASS_POUNDS, 0.45359237, MASS_KILOGRAMS), 10000,
(1, MASS_POUNDS, 453.59237, MASS_GRAMS), UnitOfMass.MICROGRAMS,
(1, MASS_POUNDS, 453592.37, MASS_MILLIGRAMS), pytest.approx(0.000022046226),
(1, MASS_POUNDS, 453592370, MASS_MICROGRAMS), UnitOfMass.POUNDS,
(1, MASS_POUNDS, 16, MASS_OUNCES), ),
(16, MASS_OUNCES, 0.45359237, MASS_KILOGRAMS), (1, UnitOfMass.POUNDS, 0.45359237, UnitOfMass.KILOGRAMS),
(16, MASS_OUNCES, 453.59237, MASS_GRAMS), (1, UnitOfMass.POUNDS, 453.59237, UnitOfMass.GRAMS),
(16, MASS_OUNCES, 453592.37, MASS_MILLIGRAMS), (1, UnitOfMass.POUNDS, 453592.37, UnitOfMass.MILLIGRAMS),
(16, MASS_OUNCES, 453592370, MASS_MICROGRAMS), (1, UnitOfMass.POUNDS, 453592370, UnitOfMass.MICROGRAMS),
(16, MASS_OUNCES, 1, MASS_POUNDS), (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( def test_mass_convert(
@ -326,8 +360,8 @@ def test_mass_convert(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"value,from_unit,expected,to_unit", "value,from_unit,expected,to_unit",
[ [
(10, POWER_KILO_WATT, 10000, POWER_WATT), (10, UnitOfPower.KILO_WATT, 10000, UnitOfPower.WATT),
(10, POWER_WATT, 0.01, POWER_KILO_WATT), (10, UnitOfPower.WATT, 0.01, UnitOfPower.KILO_WATT),
], ],
) )
def test_power_convert( def test_power_convert(
@ -343,32 +377,32 @@ def test_power_convert(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"value,from_unit,expected,to_unit", "value,from_unit,expected,to_unit",
[ [
(1000, PRESSURE_HPA, pytest.approx(14.5037743897), PRESSURE_PSI), (1000, UnitOfPressure.HPA, pytest.approx(14.5037743897), UnitOfPressure.PSI),
(1000, PRESSURE_HPA, pytest.approx(29.5299801647), PRESSURE_INHG), (1000, UnitOfPressure.HPA, pytest.approx(29.5299801647), UnitOfPressure.INHG),
(1000, PRESSURE_HPA, pytest.approx(100000), PRESSURE_PA), (1000, UnitOfPressure.HPA, pytest.approx(100000), UnitOfPressure.PA),
(1000, PRESSURE_HPA, pytest.approx(100), PRESSURE_KPA), (1000, UnitOfPressure.HPA, pytest.approx(100), UnitOfPressure.KPA),
(1000, PRESSURE_HPA, pytest.approx(1000), PRESSURE_MBAR), (1000, UnitOfPressure.HPA, pytest.approx(1000), UnitOfPressure.MBAR),
(1000, PRESSURE_HPA, pytest.approx(100), PRESSURE_CBAR), (1000, UnitOfPressure.HPA, pytest.approx(100), UnitOfPressure.CBAR),
(100, PRESSURE_KPA, pytest.approx(14.5037743897), PRESSURE_PSI), (100, UnitOfPressure.KPA, pytest.approx(14.5037743897), UnitOfPressure.PSI),
(100, PRESSURE_KPA, pytest.approx(29.5299801647), PRESSURE_INHG), (100, UnitOfPressure.KPA, pytest.approx(29.5299801647), UnitOfPressure.INHG),
(100, PRESSURE_KPA, pytest.approx(100000), PRESSURE_PA), (100, UnitOfPressure.KPA, pytest.approx(100000), UnitOfPressure.PA),
(100, PRESSURE_KPA, pytest.approx(1000), PRESSURE_HPA), (100, UnitOfPressure.KPA, pytest.approx(1000), UnitOfPressure.HPA),
(100, PRESSURE_KPA, pytest.approx(1000), PRESSURE_MBAR), (100, UnitOfPressure.KPA, pytest.approx(1000), UnitOfPressure.MBAR),
(100, PRESSURE_KPA, pytest.approx(100), PRESSURE_CBAR), (100, UnitOfPressure.KPA, pytest.approx(100), UnitOfPressure.CBAR),
(30, PRESSURE_INHG, pytest.approx(14.7346266155), PRESSURE_PSI), (30, UnitOfPressure.INHG, pytest.approx(14.7346266155), UnitOfPressure.PSI),
(30, PRESSURE_INHG, pytest.approx(101.59167), PRESSURE_KPA), (30, UnitOfPressure.INHG, pytest.approx(101.59167), UnitOfPressure.KPA),
(30, PRESSURE_INHG, pytest.approx(1015.9167), PRESSURE_HPA), (30, UnitOfPressure.INHG, pytest.approx(1015.9167), UnitOfPressure.HPA),
(30, PRESSURE_INHG, pytest.approx(101591.67), PRESSURE_PA), (30, UnitOfPressure.INHG, pytest.approx(101591.67), UnitOfPressure.PA),
(30, PRESSURE_INHG, pytest.approx(1015.9167), PRESSURE_MBAR), (30, UnitOfPressure.INHG, pytest.approx(1015.9167), UnitOfPressure.MBAR),
(30, PRESSURE_INHG, pytest.approx(101.59167), PRESSURE_CBAR), (30, UnitOfPressure.INHG, pytest.approx(101.59167), UnitOfPressure.CBAR),
(30, PRESSURE_INHG, pytest.approx(762), PRESSURE_MMHG), (30, UnitOfPressure.INHG, pytest.approx(762), UnitOfPressure.MMHG),
(30, PRESSURE_MMHG, pytest.approx(0.580103), PRESSURE_PSI), (30, UnitOfPressure.MMHG, pytest.approx(0.580103), UnitOfPressure.PSI),
(30, PRESSURE_MMHG, pytest.approx(3.99967), PRESSURE_KPA), (30, UnitOfPressure.MMHG, pytest.approx(3.99967), UnitOfPressure.KPA),
(30, PRESSURE_MMHG, pytest.approx(39.9967), PRESSURE_HPA), (30, UnitOfPressure.MMHG, pytest.approx(39.9967), UnitOfPressure.HPA),
(30, PRESSURE_MMHG, pytest.approx(3999.67), PRESSURE_PA), (30, UnitOfPressure.MMHG, pytest.approx(3999.67), UnitOfPressure.PA),
(30, PRESSURE_MMHG, pytest.approx(39.9967), PRESSURE_MBAR), (30, UnitOfPressure.MMHG, pytest.approx(39.9967), UnitOfPressure.MBAR),
(30, PRESSURE_MMHG, pytest.approx(3.99967), PRESSURE_CBAR), (30, UnitOfPressure.MMHG, pytest.approx(3.99967), UnitOfPressure.CBAR),
(30, PRESSURE_MMHG, pytest.approx(1.181102), PRESSURE_INHG), (30, UnitOfPressure.MMHG, pytest.approx(1.181102), UnitOfPressure.INHG),
], ],
) )
def test_pressure_convert( def test_pressure_convert(
@ -385,9 +419,14 @@ def test_pressure_convert(
"value,from_unit,expected,to_unit", "value,from_unit,expected,to_unit",
[ [
# 5 km/h / 1.609 km/mi = 3.10686 mi/h # 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 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 in/day * 25.4 mm/in = 127 mm/day
( (
5, 5,
@ -419,7 +458,7 @@ def test_pressure_convert(
# 5 m/s * 39.3701 in/m * 3600 s/hr = 708661 # 5 m/s * 39.3701 in/m * 3600 s/hr = 708661
( (
5, 5,
SPEED_METERS_PER_SECOND, UnitOfSpeed.METERS_PER_SECOND,
pytest.approx(708661.42), pytest.approx(708661.42),
UnitOfVolumetricFlux.INCHES_PER_HOUR, UnitOfVolumetricFlux.INCHES_PER_HOUR,
), ),
@ -428,12 +467,17 @@ def test_pressure_convert(
5000, 5000,
UnitOfVolumetricFlux.INCHES_PER_HOUR, UnitOfVolumetricFlux.INCHES_PER_HOUR,
pytest.approx(0.0352778), 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 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 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( def test_speed_convert(
@ -449,12 +493,32 @@ def test_speed_convert(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"value,from_unit,expected,to_unit", "value,from_unit,expected,to_unit",
[ [
(100, TEMP_CELSIUS, 212, TEMP_FAHRENHEIT), (100, UnitOfTemperature.CELSIUS, 212, UnitOfTemperature.FAHRENHEIT),
(100, TEMP_CELSIUS, 373.15, TEMP_KELVIN), (100, UnitOfTemperature.CELSIUS, 373.15, UnitOfTemperature.KELVIN),
(100, TEMP_FAHRENHEIT, pytest.approx(37.77777777777778), TEMP_CELSIUS), (
(100, TEMP_FAHRENHEIT, pytest.approx(310.92777777777775), TEMP_KELVIN), 100,
(100, TEMP_KELVIN, pytest.approx(-173.15), TEMP_CELSIUS), UnitOfTemperature.FAHRENHEIT,
(100, TEMP_KELVIN, pytest.approx(-279.66999999999996), TEMP_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( def test_temperature_convert(
@ -467,12 +531,22 @@ def test_temperature_convert(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"value,from_unit,expected,to_unit", "value,from_unit,expected,to_unit",
[ [
(100, TEMP_CELSIUS, 180, TEMP_FAHRENHEIT), (100, UnitOfTemperature.CELSIUS, 180, UnitOfTemperature.FAHRENHEIT),
(100, TEMP_CELSIUS, 100, TEMP_KELVIN), (100, UnitOfTemperature.CELSIUS, 100, UnitOfTemperature.KELVIN),
(100, TEMP_FAHRENHEIT, pytest.approx(55.55555555555556), TEMP_CELSIUS), (
(100, TEMP_FAHRENHEIT, pytest.approx(55.55555555555556), TEMP_KELVIN), 100,
(100, TEMP_KELVIN, 100, TEMP_CELSIUS), UnitOfTemperature.FAHRENHEIT,
(100, TEMP_KELVIN, 180, TEMP_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( def test_temperature_convert_with_interval(
@ -485,40 +559,110 @@ def test_temperature_convert_with_interval(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"value,from_unit,expected,to_unit", "value,from_unit,expected,to_unit",
[ [
(5, VOLUME_LITERS, pytest.approx(1.32086), VOLUME_GALLONS), (5, UnitOfVolume.LITERS, pytest.approx(1.32086), UnitOfVolume.GALLONS),
(5, VOLUME_GALLONS, pytest.approx(18.92706), VOLUME_LITERS), (5, UnitOfVolume.GALLONS, pytest.approx(18.92706), UnitOfVolume.LITERS),
(5, VOLUME_CUBIC_METERS, pytest.approx(176.5733335), VOLUME_CUBIC_FEET), (
(500, VOLUME_CUBIC_FEET, pytest.approx(14.1584233), VOLUME_CUBIC_METERS), 5,
(500, VOLUME_CUBIC_FEET, pytest.approx(14.1584233), VOLUME_CUBIC_METERS), UnitOfVolume.CUBIC_METERS,
(500, VOLUME_CUBIC_FEET, pytest.approx(478753.2467), VOLUME_FLUID_OUNCE), pytest.approx(176.5733335),
(500, VOLUME_CUBIC_FEET, pytest.approx(3740.25974), VOLUME_GALLONS), UnitOfVolume.CUBIC_FEET,
(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,
(500, VOLUME_CUBIC_METERS, pytest.approx(16907011.35), VOLUME_FLUID_OUNCE), UnitOfVolume.CUBIC_FEET,
(500, VOLUME_CUBIC_METERS, pytest.approx(132086.02617), VOLUME_GALLONS), pytest.approx(14.1584233),
(500, VOLUME_CUBIC_METERS, 500000, VOLUME_LITERS), UnitOfVolume.CUBIC_METERS,
(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,
(500, VOLUME_FLUID_OUNCE, 3.90625, VOLUME_GALLONS), UnitOfVolume.CUBIC_FEET,
(500, VOLUME_FLUID_OUNCE, pytest.approx(14.786764), VOLUME_LITERS), pytest.approx(14.1584233),
(500, VOLUME_FLUID_OUNCE, pytest.approx(14786.764), VOLUME_MILLILITERS), UnitOfVolume.CUBIC_METERS,
(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,
(500, VOLUME_GALLONS, pytest.approx(1892.70589), VOLUME_LITERS), UnitOfVolume.CUBIC_FEET,
(500, VOLUME_GALLONS, pytest.approx(1892705.89), VOLUME_MILLILITERS), pytest.approx(478753.2467),
(500, VOLUME_LITERS, pytest.approx(17.65733), VOLUME_CUBIC_FEET), UnitOfVolume.FLUID_OUNCES,
(500, VOLUME_LITERS, 0.5, VOLUME_CUBIC_METERS), ),
(500, VOLUME_LITERS, pytest.approx(16907.011), VOLUME_FLUID_OUNCE), (500, UnitOfVolume.CUBIC_FEET, pytest.approx(3740.25974), UnitOfVolume.GALLONS),
(500, VOLUME_LITERS, pytest.approx(132.086), VOLUME_GALLONS), (
(500, VOLUME_LITERS, 500000, VOLUME_MILLILITERS), 500,
(500, VOLUME_MILLILITERS, pytest.approx(0.01765733), VOLUME_CUBIC_FEET), UnitOfVolume.CUBIC_FEET,
(500, VOLUME_MILLILITERS, 0.0005, VOLUME_CUBIC_METERS), pytest.approx(14158.42329599),
(500, VOLUME_MILLILITERS, pytest.approx(16.907), VOLUME_FLUID_OUNCE), UnitOfVolume.LITERS,
(500, VOLUME_MILLILITERS, pytest.approx(0.132086), VOLUME_GALLONS), ),
(500, VOLUME_MILLILITERS, 0.5, VOLUME_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( def test_volume_convert(

256
tests/util/test_unit_system.py
View file

@ -7,33 +7,17 @@ from homeassistant.components.sensor import SensorDeviceClass
from homeassistant.const import ( from homeassistant.const import (
ACCUMULATED_PRECIPITATION, ACCUMULATED_PRECIPITATION,
LENGTH, LENGTH,
LENGTH_CENTIMETERS,
LENGTH_FEET,
LENGTH_INCHES,
LENGTH_KILOMETERS,
LENGTH_METERS,
LENGTH_MILES,
LENGTH_MILLIMETERS,
LENGTH_YARD,
MASS, MASS,
MASS_GRAMS,
PRESSURE, PRESSURE,
PRESSURE_PA,
SPEED_FEET_PER_SECOND,
SPEED_KILOMETERS_PER_HOUR,
SPEED_KNOTS,
SPEED_METERS_PER_SECOND,
SPEED_MILES_PER_HOUR,
TEMP_CELSIUS,
TEMPERATURE, TEMPERATURE,
VOLUME, VOLUME,
VOLUME_CUBIC_FEET,
VOLUME_CUBIC_METERS,
VOLUME_FLUID_OUNCE,
VOLUME_GALLONS,
VOLUME_LITERS,
VOLUME_MILLILITERS,
WIND_SPEED, WIND_SPEED,
UnitOfLength,
UnitOfMass,
UnitOfPressure,
UnitOfSpeed,
UnitOfTemperature,
UnitOfVolume,
) )
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.util.unit_system import ( from homeassistant.util.unit_system import (
@ -56,79 +40,79 @@ def test_invalid_units():
with pytest.raises(ValueError): with pytest.raises(ValueError):
UnitSystem( UnitSystem(
SYSTEM_NAME, SYSTEM_NAME,
accumulated_precipitation=LENGTH_MILLIMETERS, accumulated_precipitation=UnitOfLength.MILLIMETERS,
conversions={}, conversions={},
length=LENGTH_METERS, length=UnitOfLength.METERS,
mass=MASS_GRAMS, mass=UnitOfMass.GRAMS,
pressure=PRESSURE_PA, pressure=UnitOfPressure.PA,
temperature=INVALID_UNIT, temperature=INVALID_UNIT,
volume=VOLUME_LITERS, volume=UnitOfVolume.LITERS,
wind_speed=SPEED_METERS_PER_SECOND, wind_speed=UnitOfSpeed.METERS_PER_SECOND,
) )
with pytest.raises(ValueError): with pytest.raises(ValueError):
UnitSystem( UnitSystem(
SYSTEM_NAME, SYSTEM_NAME,
accumulated_precipitation=LENGTH_MILLIMETERS, accumulated_precipitation=UnitOfLength.MILLIMETERS,
conversions={}, conversions={},
length=INVALID_UNIT, length=INVALID_UNIT,
mass=MASS_GRAMS, mass=UnitOfMass.GRAMS,
pressure=PRESSURE_PA, pressure=UnitOfPressure.PA,
temperature=TEMP_CELSIUS, temperature=UnitOfTemperature.CELSIUS,
volume=VOLUME_LITERS, volume=UnitOfVolume.LITERS,
wind_speed=SPEED_METERS_PER_SECOND, wind_speed=UnitOfSpeed.METERS_PER_SECOND,
) )
with pytest.raises(ValueError): with pytest.raises(ValueError):
UnitSystem( UnitSystem(
SYSTEM_NAME, SYSTEM_NAME,
accumulated_precipitation=LENGTH_MILLIMETERS, accumulated_precipitation=UnitOfLength.MILLIMETERS,
conversions={}, conversions={},
length=LENGTH_METERS, length=UnitOfLength.METERS,
mass=MASS_GRAMS, mass=UnitOfMass.GRAMS,
pressure=PRESSURE_PA, pressure=UnitOfPressure.PA,
temperature=TEMP_CELSIUS, temperature=UnitOfTemperature.CELSIUS,
volume=VOLUME_LITERS, volume=UnitOfVolume.LITERS,
wind_speed=INVALID_UNIT, wind_speed=INVALID_UNIT,
) )
with pytest.raises(ValueError): with pytest.raises(ValueError):
UnitSystem( UnitSystem(
SYSTEM_NAME, SYSTEM_NAME,
accumulated_precipitation=LENGTH_MILLIMETERS, accumulated_precipitation=UnitOfLength.MILLIMETERS,
conversions={}, conversions={},
length=LENGTH_METERS, length=UnitOfLength.METERS,
mass=MASS_GRAMS, mass=UnitOfMass.GRAMS,
pressure=PRESSURE_PA, pressure=UnitOfPressure.PA,
temperature=TEMP_CELSIUS, temperature=UnitOfTemperature.CELSIUS,
volume=INVALID_UNIT, volume=INVALID_UNIT,
wind_speed=SPEED_METERS_PER_SECOND, wind_speed=UnitOfSpeed.METERS_PER_SECOND,
) )
with pytest.raises(ValueError): with pytest.raises(ValueError):
UnitSystem( UnitSystem(
SYSTEM_NAME, SYSTEM_NAME,
accumulated_precipitation=LENGTH_MILLIMETERS, accumulated_precipitation=UnitOfLength.MILLIMETERS,
conversions={}, conversions={},
length=LENGTH_METERS, length=UnitOfLength.METERS,
mass=INVALID_UNIT, mass=INVALID_UNIT,
pressure=PRESSURE_PA, pressure=UnitOfPressure.PA,
temperature=TEMP_CELSIUS, temperature=UnitOfTemperature.CELSIUS,
volume=VOLUME_LITERS, volume=UnitOfVolume.LITERS,
wind_speed=SPEED_METERS_PER_SECOND, wind_speed=UnitOfSpeed.METERS_PER_SECOND,
) )
with pytest.raises(ValueError): with pytest.raises(ValueError):
UnitSystem( UnitSystem(
SYSTEM_NAME, SYSTEM_NAME,
accumulated_precipitation=LENGTH_MILLIMETERS, accumulated_precipitation=UnitOfLength.MILLIMETERS,
conversions={}, conversions={},
length=LENGTH_METERS, length=UnitOfLength.METERS,
mass=MASS_GRAMS, mass=UnitOfMass.GRAMS,
pressure=INVALID_UNIT, pressure=INVALID_UNIT,
temperature=TEMP_CELSIUS, temperature=UnitOfTemperature.CELSIUS,
volume=VOLUME_LITERS, volume=UnitOfVolume.LITERS,
wind_speed=SPEED_METERS_PER_SECOND, wind_speed=UnitOfSpeed.METERS_PER_SECOND,
) )
with pytest.raises(ValueError): with pytest.raises(ValueError):
@ -136,41 +120,41 @@ def test_invalid_units():
SYSTEM_NAME, SYSTEM_NAME,
accumulated_precipitation=INVALID_UNIT, accumulated_precipitation=INVALID_UNIT,
conversions={}, conversions={},
length=LENGTH_METERS, length=UnitOfLength.METERS,
mass=MASS_GRAMS, mass=UnitOfMass.GRAMS,
pressure=PRESSURE_PA, pressure=UnitOfPressure.PA,
temperature=TEMP_CELSIUS, temperature=UnitOfTemperature.CELSIUS,
volume=VOLUME_LITERS, volume=UnitOfVolume.LITERS,
wind_speed=SPEED_METERS_PER_SECOND, wind_speed=UnitOfSpeed.METERS_PER_SECOND,
) )
def test_invalid_value(): def test_invalid_value():
"""Test no conversion happens if value is non-numeric.""" """Test no conversion happens if value is non-numeric."""
with pytest.raises(TypeError): with pytest.raises(TypeError):
METRIC_SYSTEM.length("25a", LENGTH_KILOMETERS) METRIC_SYSTEM.length("25a", UnitOfLength.KILOMETERS)
with pytest.raises(TypeError): with pytest.raises(TypeError):
METRIC_SYSTEM.temperature("50K", TEMP_CELSIUS) METRIC_SYSTEM.temperature("50K", UnitOfTemperature.CELSIUS)
with pytest.raises(TypeError): 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): with pytest.raises(TypeError):
METRIC_SYSTEM.volume("50L", VOLUME_LITERS) METRIC_SYSTEM.volume("50L", UnitOfVolume.LITERS)
with pytest.raises(TypeError): with pytest.raises(TypeError):
METRIC_SYSTEM.pressure("50Pa", PRESSURE_PA) METRIC_SYSTEM.pressure("50Pa", UnitOfPressure.PA)
with pytest.raises(TypeError): with pytest.raises(TypeError):
METRIC_SYSTEM.accumulated_precipitation("50mm", LENGTH_MILLIMETERS) METRIC_SYSTEM.accumulated_precipitation("50mm", UnitOfLength.MILLIMETERS)
def test_as_dict(): def test_as_dict():
"""Test that the as_dict() method returns the expected dictionary.""" """Test that the as_dict() method returns the expected dictionary."""
expected = { expected = {
LENGTH: LENGTH_KILOMETERS, LENGTH: UnitOfLength.KILOMETERS,
WIND_SPEED: SPEED_METERS_PER_SECOND, WIND_SPEED: UnitOfSpeed.METERS_PER_SECOND,
TEMPERATURE: TEMP_CELSIUS, TEMPERATURE: UnitOfTemperature.CELSIUS,
VOLUME: VOLUME_LITERS, VOLUME: UnitOfVolume.LITERS,
MASS: MASS_GRAMS, MASS: UnitOfMass.GRAMS,
PRESSURE: PRESSURE_PA, PRESSURE: UnitOfPressure.PA,
ACCUMULATED_PRECIPITATION: LENGTH_MILLIMETERS, ACCUMULATED_PRECIPITATION: UnitOfLength.MILLIMETERS,
} }
assert expected == METRIC_SYSTEM.as_dict() assert expected == METRIC_SYSTEM.as_dict()
@ -318,13 +302,13 @@ def test_accumulated_precipitation_to_imperial():
def test_properties(): def test_properties():
"""Test the unit properties are returned as expected.""" """Test the unit properties are returned as expected."""
assert METRIC_SYSTEM.length_unit == LENGTH_KILOMETERS assert METRIC_SYSTEM.length_unit == UnitOfLength.KILOMETERS
assert METRIC_SYSTEM.wind_speed_unit == SPEED_METERS_PER_SECOND assert METRIC_SYSTEM.wind_speed_unit == UnitOfSpeed.METERS_PER_SECOND
assert METRIC_SYSTEM.temperature_unit == TEMP_CELSIUS assert METRIC_SYSTEM.temperature_unit == UnitOfTemperature.CELSIUS
assert METRIC_SYSTEM.mass_unit == MASS_GRAMS assert METRIC_SYSTEM.mass_unit == UnitOfMass.GRAMS
assert METRIC_SYSTEM.volume_unit == VOLUME_LITERS assert METRIC_SYSTEM.volume_unit == UnitOfVolume.LITERS
assert METRIC_SYSTEM.pressure_unit == PRESSURE_PA assert METRIC_SYSTEM.pressure_unit == UnitOfPressure.PA
assert METRIC_SYSTEM.accumulated_precipitation_unit == LENGTH_MILLIMETERS assert METRIC_SYSTEM.accumulated_precipitation_unit == UnitOfLength.MILLIMETERS
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -397,36 +381,44 @@ def test_get_unit_system_invalid(key: str) -> None:
"device_class, original_unit, state_unit", "device_class, original_unit, state_unit",
( (
# Test distance conversion # Test distance conversion
(SensorDeviceClass.DISTANCE, LENGTH_FEET, LENGTH_METERS), (SensorDeviceClass.DISTANCE, UnitOfLength.FEET, UnitOfLength.METERS),
(SensorDeviceClass.DISTANCE, LENGTH_INCHES, LENGTH_MILLIMETERS), (SensorDeviceClass.DISTANCE, UnitOfLength.INCHES, UnitOfLength.MILLIMETERS),
(SensorDeviceClass.DISTANCE, LENGTH_MILES, LENGTH_KILOMETERS), (SensorDeviceClass.DISTANCE, UnitOfLength.MILES, UnitOfLength.KILOMETERS),
(SensorDeviceClass.DISTANCE, LENGTH_YARD, LENGTH_METERS), (SensorDeviceClass.DISTANCE, UnitOfLength.YARDS, UnitOfLength.METERS),
(SensorDeviceClass.DISTANCE, LENGTH_KILOMETERS, None), (SensorDeviceClass.DISTANCE, UnitOfLength.KILOMETERS, None),
(SensorDeviceClass.DISTANCE, "very_long", None), (SensorDeviceClass.DISTANCE, "very_long", None),
# Test gas meter conversion # Test gas meter conversion
(SensorDeviceClass.GAS, VOLUME_CUBIC_FEET, VOLUME_CUBIC_METERS), (SensorDeviceClass.GAS, UnitOfVolume.CUBIC_FEET, UnitOfVolume.CUBIC_METERS),
(SensorDeviceClass.GAS, VOLUME_CUBIC_METERS, None), (SensorDeviceClass.GAS, UnitOfVolume.CUBIC_METERS, None),
(SensorDeviceClass.GAS, "very_much", None), (SensorDeviceClass.GAS, "very_much", None),
# Test speed conversion # 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,
(SensorDeviceClass.SPEED, SPEED_KILOMETERS_PER_HOUR, None), UnitOfSpeed.FEET_PER_SECOND,
(SensorDeviceClass.SPEED, SPEED_KNOTS, None), UnitOfSpeed.KILOMETERS_PER_HOUR,
(SensorDeviceClass.SPEED, SPEED_METERS_PER_SECOND, None), ),
(
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), (SensorDeviceClass.SPEED, "very_fast", None),
# Test volume conversion # Test volume conversion
(SensorDeviceClass.VOLUME, VOLUME_CUBIC_FEET, VOLUME_CUBIC_METERS), (SensorDeviceClass.VOLUME, UnitOfVolume.CUBIC_FEET, UnitOfVolume.CUBIC_METERS),
(SensorDeviceClass.VOLUME, VOLUME_FLUID_OUNCE, VOLUME_MILLILITERS), (SensorDeviceClass.VOLUME, UnitOfVolume.FLUID_OUNCES, UnitOfVolume.MILLILITERS),
(SensorDeviceClass.VOLUME, VOLUME_GALLONS, VOLUME_LITERS), (SensorDeviceClass.VOLUME, UnitOfVolume.GALLONS, UnitOfVolume.LITERS),
(SensorDeviceClass.VOLUME, VOLUME_CUBIC_METERS, None), (SensorDeviceClass.VOLUME, UnitOfVolume.CUBIC_METERS, None),
(SensorDeviceClass.VOLUME, VOLUME_LITERS, None), (SensorDeviceClass.VOLUME, UnitOfVolume.LITERS, None),
(SensorDeviceClass.VOLUME, VOLUME_MILLILITERS, None), (SensorDeviceClass.VOLUME, UnitOfVolume.MILLILITERS, None),
(SensorDeviceClass.VOLUME, "very_much", None), (SensorDeviceClass.VOLUME, "very_much", None),
# Test water meter conversion # Test water meter conversion
(SensorDeviceClass.WATER, VOLUME_CUBIC_FEET, VOLUME_CUBIC_METERS), (SensorDeviceClass.WATER, UnitOfVolume.CUBIC_FEET, UnitOfVolume.CUBIC_METERS),
(SensorDeviceClass.WATER, VOLUME_GALLONS, VOLUME_LITERS), (SensorDeviceClass.WATER, UnitOfVolume.GALLONS, UnitOfVolume.LITERS),
(SensorDeviceClass.WATER, VOLUME_CUBIC_METERS, None), (SensorDeviceClass.WATER, UnitOfVolume.CUBIC_METERS, None),
(SensorDeviceClass.WATER, VOLUME_LITERS, None), (SensorDeviceClass.WATER, UnitOfVolume.LITERS, None),
(SensorDeviceClass.WATER, "very_much", None), (SensorDeviceClass.WATER, "very_much", None),
), ),
) )
@ -444,36 +436,44 @@ def test_get_metric_converted_unit_(
"device_class, original_unit, state_unit", "device_class, original_unit, state_unit",
( (
# Test distance conversion # Test distance conversion
(SensorDeviceClass.DISTANCE, LENGTH_CENTIMETERS, LENGTH_INCHES), (SensorDeviceClass.DISTANCE, UnitOfLength.CENTIMETERS, UnitOfLength.INCHES),
(SensorDeviceClass.DISTANCE, LENGTH_KILOMETERS, LENGTH_MILES), (SensorDeviceClass.DISTANCE, UnitOfLength.KILOMETERS, UnitOfLength.MILES),
(SensorDeviceClass.DISTANCE, LENGTH_METERS, LENGTH_FEET), (SensorDeviceClass.DISTANCE, UnitOfLength.METERS, UnitOfLength.FEET),
(SensorDeviceClass.DISTANCE, LENGTH_MILLIMETERS, LENGTH_INCHES), (SensorDeviceClass.DISTANCE, UnitOfLength.MILLIMETERS, UnitOfLength.INCHES),
(SensorDeviceClass.DISTANCE, LENGTH_MILES, None), (SensorDeviceClass.DISTANCE, UnitOfLength.MILES, None),
(SensorDeviceClass.DISTANCE, "very_long", None), (SensorDeviceClass.DISTANCE, "very_long", None),
# Test gas meter conversion # Test gas meter conversion
(SensorDeviceClass.GAS, VOLUME_CUBIC_METERS, VOLUME_CUBIC_FEET), (SensorDeviceClass.GAS, UnitOfVolume.CUBIC_METERS, UnitOfVolume.CUBIC_FEET),
(SensorDeviceClass.GAS, VOLUME_CUBIC_FEET, None), (SensorDeviceClass.GAS, UnitOfVolume.CUBIC_FEET, None),
(SensorDeviceClass.GAS, "very_much", None), (SensorDeviceClass.GAS, "very_much", None),
# Test speed conversion # 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,
(SensorDeviceClass.SPEED, SPEED_FEET_PER_SECOND, None), UnitOfSpeed.METERS_PER_SECOND,
(SensorDeviceClass.SPEED, SPEED_KNOTS, None), UnitOfSpeed.MILES_PER_HOUR,
(SensorDeviceClass.SPEED, SPEED_MILES_PER_HOUR, None), ),
(
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), (SensorDeviceClass.SPEED, "very_fast", None),
# Test volume conversion # Test volume conversion
(SensorDeviceClass.VOLUME, VOLUME_CUBIC_METERS, VOLUME_CUBIC_FEET), (SensorDeviceClass.VOLUME, UnitOfVolume.CUBIC_METERS, UnitOfVolume.CUBIC_FEET),
(SensorDeviceClass.VOLUME, VOLUME_LITERS, VOLUME_GALLONS), (SensorDeviceClass.VOLUME, UnitOfVolume.LITERS, UnitOfVolume.GALLONS),
(SensorDeviceClass.VOLUME, VOLUME_MILLILITERS, VOLUME_FLUID_OUNCE), (SensorDeviceClass.VOLUME, UnitOfVolume.MILLILITERS, UnitOfVolume.FLUID_OUNCES),
(SensorDeviceClass.VOLUME, VOLUME_CUBIC_FEET, None), (SensorDeviceClass.VOLUME, UnitOfVolume.CUBIC_FEET, None),
(SensorDeviceClass.VOLUME, VOLUME_FLUID_OUNCE, None), (SensorDeviceClass.VOLUME, UnitOfVolume.FLUID_OUNCES, None),
(SensorDeviceClass.VOLUME, VOLUME_GALLONS, None), (SensorDeviceClass.VOLUME, UnitOfVolume.GALLONS, None),
(SensorDeviceClass.VOLUME, "very_much", None), (SensorDeviceClass.VOLUME, "very_much", None),
# Test water meter conversion # Test water meter conversion
(SensorDeviceClass.WATER, VOLUME_CUBIC_METERS, VOLUME_CUBIC_FEET), (SensorDeviceClass.WATER, UnitOfVolume.CUBIC_METERS, UnitOfVolume.CUBIC_FEET),
(SensorDeviceClass.WATER, VOLUME_LITERS, VOLUME_GALLONS), (SensorDeviceClass.WATER, UnitOfVolume.LITERS, UnitOfVolume.GALLONS),
(SensorDeviceClass.WATER, VOLUME_CUBIC_FEET, None), (SensorDeviceClass.WATER, UnitOfVolume.CUBIC_FEET, None),
(SensorDeviceClass.WATER, VOLUME_GALLONS, None), (SensorDeviceClass.WATER, UnitOfVolume.GALLONS, None),
(SensorDeviceClass.WATER, "very_much", None), (SensorDeviceClass.WATER, "very_much", None),
), ),
) )