def wind_speed(self) -> float | None:
"""Return the wind speed."""
speed_km_h = self.coordinator.data.current_weather_data.get(
ATTR_MAP[ATTR_WEATHER_WIND_SPEED])
if self._is_metric or speed_km_h is None:
return speed_km_h
speed_mi_h = convert_speed(speed_km_h, SPEED_KILOMETERS_PER_HOUR,
SPEED_MILES_PER_HOUR)
return int(round(speed_mi_h))
def wind_speed(self):
"""Return the wind speed."""
speed_m_s = self.coordinator.data.current_weather_data.get(
"wind_speed")
if self._is_metric or speed_m_s is None:
return speed_m_s
speed_mi_h = convert_speed(speed_m_s, SPEED_METERS_PER_SECOND,
SPEED_MILES_PER_HOUR)
return int(round(speed_mi_h))
def wind_speed(self):
"""Return the current windspeed."""
wind_km_hr = None
if self.observation:
wind_km_hr = self.observation.get("windSpeed")
if wind_km_hr is None:
return None
if self.is_metric:
wind = wind_km_hr
else:
wind = convert_speed(wind_km_hr, SPEED_KILOMETERS_PER_HOUR,
SPEED_MILES_PER_HOUR)
return round(wind)
def native_value(self):
"""Return the state."""
value = self._nws.observation.get(self.entity_description.key)
if value is None:
return None
# Set alias to unit property -> prevent unnecessary hasattr calls
unit_of_measurement = self.native_unit_of_measurement
if unit_of_measurement == SPEED_MILES_PER_HOUR:
return round(
convert_speed(value, SPEED_KILOMETERS_PER_HOUR,
SPEED_MILES_PER_HOUR))
if unit_of_measurement == LENGTH_MILES:
return round(convert_distance(value, LENGTH_METERS, LENGTH_MILES))
if unit_of_measurement == PRESSURE_INHG:
return round(convert_pressure(value, PRESSURE_PA, PRESSURE_INHG),
2)
if unit_of_measurement == TEMP_CELSIUS:
return round(value, 1)
if unit_of_measurement == PERCENTAGE:
return round(value)
return value
def forecast(self):
"""Return forecast."""
if self._forecast is None:
return None
forecast = []
for forecast_entry in self._forecast:
data = {
ATTR_FORECAST_DETAILED_DESCRIPTION:
forecast_entry.get("detailedForecast"),
ATTR_FORECAST_TEMP:
forecast_entry.get("temperature"),
ATTR_FORECAST_TIME:
forecast_entry.get("startTime"),
}
if self.mode == DAYNIGHT:
data[ATTR_FORECAST_DAYTIME] = forecast_entry.get("isDaytime")
time = forecast_entry.get("iconTime")
weather = forecast_entry.get("iconWeather")
if time and weather:
cond, precip = convert_condition(time, weather)
else:
cond, precip = None, None
data[ATTR_FORECAST_CONDITION] = cond
data[ATTR_FORECAST_PRECIPITATION_PROBABILITY] = precip
data[ATTR_FORECAST_WIND_BEARING] = forecast_entry.get(
"windBearing")
wind_speed = forecast_entry.get("windSpeedAvg")
if wind_speed is not None:
if self.is_metric:
data[ATTR_FORECAST_WIND_SPEED] = round(
convert_speed(wind_speed, SPEED_MILES_PER_HOUR,
SPEED_KILOMETERS_PER_HOUR))
else:
data[ATTR_FORECAST_WIND_SPEED] = round(wind_speed)
else:
data[ATTR_FORECAST_WIND_SPEED] = None
forecast.append(data)
return forecast
async def test_wind_speed_conversion(
hass,
enable_custom_integrations,
unit_system,
):
"""Test wind speed conversion."""
hass.config.units = unit_system
native_value = 10
native_unit = SPEED_METERS_PER_SECOND
entity0 = await create_entity(
hass, wind_speed=native_value, wind_speed_unit=native_unit
)
state = hass.states.get(entity0.entity_id)
forecast = state.attributes[ATTR_FORECAST][0]
expected = convert_speed(native_value, native_unit, unit_system.wind_speed_unit)
assert float(state.attributes[ATTR_WEATHER_WIND_SPEED]) == approx(
expected, rel=1e-2
)
assert float(forecast[ATTR_FORECAST_WIND_SPEED]) == approx(expected, rel=1e-2)
async def test_wind_speed(
hass: HomeAssistant,
enable_custom_integrations,
native_unit: str,
state_unit: str,
unit_system,
):
"""Test wind speed."""
hass.config.units = unit_system
native_value = 10
state_value = convert_speed(native_value, native_unit, state_unit)
entity0 = await create_entity(hass,
native_wind_speed=native_value,
native_wind_speed_unit=native_unit)
state = hass.states.get(entity0.entity_id)
forecast = state.attributes[ATTR_FORECAST][0]
expected = state_value
assert float(state.attributes[ATTR_WEATHER_WIND_SPEED]) == approx(expected,
rel=1e-2)
assert float(forecast[ATTR_FORECAST_WIND_SPEED]) == approx(expected,
rel=1e-2)
"windSpeed": "10",
"windGust": "20",
"windDirection": "180",
"barometricPressure": "100000",
"seaLevelPressure": "100000",
"visibility": "10000",
}
SENSOR_EXPECTED_OBSERVATION_IMPERIAL = {
"dewpoint": str(round(convert_temperature(5, TEMP_CELSIUS, TEMP_FAHRENHEIT))),
"temperature": str(round(convert_temperature(10, TEMP_CELSIUS, TEMP_FAHRENHEIT))),
"windChill": str(round(convert_temperature(5, TEMP_CELSIUS, TEMP_FAHRENHEIT))),
"heatIndex": str(round(convert_temperature(15, TEMP_CELSIUS, TEMP_FAHRENHEIT))),
"relativeHumidity": "10",
"windSpeed": str(
round(convert_speed(10, SPEED_KILOMETERS_PER_HOUR, SPEED_MILES_PER_HOUR))
),
"windGust": str(
round(convert_speed(20, SPEED_KILOMETERS_PER_HOUR, SPEED_MILES_PER_HOUR))
),
"windDirection": "180",
"barometricPressure": str(
round(convert_pressure(100000, PRESSURE_PA, PRESSURE_INHG), 2)
),
"seaLevelPressure": str(
round(convert_pressure(100000, PRESSURE_PA, PRESSURE_INHG), 2)
),
"visibility": str(round(convert_distance(10000, LENGTH_METERS, LENGTH_MILES))),
}
WEATHER_EXPECTED_OBSERVATION_IMPERIAL = {
async def test_backwards_compatibility_convert_values(
hass: HomeAssistant, enable_custom_integrations) -> None:
"""Test backward compatibility for converting values."""
wind_speed_value = 5
wind_speed_unit = SPEED_METERS_PER_SECOND
pressure_value = 110000
pressure_unit = PRESSURE_PA
temperature_value = 20
temperature_unit = TEMP_CELSIUS
visibility_value = 11
visibility_unit = LENGTH_KILOMETERS
precipitation_value = 1
precipitation_unit = LENGTH_MILLIMETERS
hass.config.units = IMPERIAL_SYSTEM
platform: WeatherPlatform = getattr(hass.components, "test.weather")
platform.init(empty=True)
platform.ENTITIES.append(
platform.MockWeatherMockForecastCompat(
name="Test",
condition=ATTR_CONDITION_SUNNY,
temperature=temperature_value,
temperature_unit=temperature_unit,
wind_speed=wind_speed_value,
wind_speed_unit=wind_speed_unit,
pressure=pressure_value,
pressure_unit=pressure_unit,
visibility=visibility_value,
visibility_unit=visibility_unit,
precipitation=precipitation_value,
precipitation_unit=precipitation_unit,
unique_id="very_unique",
))
entity0 = platform.ENTITIES[0]
assert await async_setup_component(hass, "weather",
{"weather": {
"platform": "test"
}})
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
expected_wind_speed = round(
convert_speed(wind_speed_value, wind_speed_unit, SPEED_MILES_PER_HOUR),
ROUNDING_PRECISION,
)
expected_temperature = convert_temperature(temperature_value,
temperature_unit,
TEMP_FAHRENHEIT)
expected_pressure = round(
convert_pressure(pressure_value, pressure_unit, PRESSURE_INHG),
ROUNDING_PRECISION,
)
expected_visibility = round(
convert_distance(visibility_value, visibility_unit, LENGTH_MILES),
ROUNDING_PRECISION,
)
expected_precipitation = round(
convert_distance(precipitation_value, precipitation_unit,
LENGTH_INCHES),
ROUNDING_PRECISION,
)
assert state.attributes == {
ATTR_FORECAST: [{
ATTR_FORECAST_PRECIPITATION:
approx(expected_precipitation, rel=0.1),
ATTR_FORECAST_PRESSURE:
approx(expected_pressure, rel=0.1),
ATTR_FORECAST_TEMP:
approx(expected_temperature, rel=0.1),
ATTR_FORECAST_TEMP_LOW:
approx(expected_temperature, rel=0.1),
ATTR_FORECAST_WIND_BEARING:
None,
ATTR_FORECAST_WIND_SPEED:
approx(expected_wind_speed, rel=0.1),
}],
ATTR_FRIENDLY_NAME:
"Test",
ATTR_WEATHER_PRECIPITATION_UNIT:
LENGTH_INCHES,
ATTR_WEATHER_PRESSURE:
approx(expected_pressure, rel=0.1),
ATTR_WEATHER_PRESSURE_UNIT:
PRESSURE_INHG,
ATTR_WEATHER_TEMPERATURE:
approx(expected_temperature, rel=0.1),
ATTR_WEATHER_TEMPERATURE_UNIT:
TEMP_FAHRENHEIT,
ATTR_WEATHER_VISIBILITY:
approx(expected_visibility, rel=0.1),
ATTR_WEATHER_VISIBILITY_UNIT:
LENGTH_MILES,
ATTR_WEATHER_WIND_SPEED:
approx(expected_wind_speed, rel=0.1),
ATTR_WEATHER_WIND_SPEED_UNIT:
SPEED_MILES_PER_HOUR,
}
async def test_custom_units(hass: HomeAssistant,
enable_custom_integrations) -> None:
"""Test custom unit."""
wind_speed_value = 5
wind_speed_unit = SPEED_METERS_PER_SECOND
pressure_value = 110
pressure_unit = PRESSURE_HPA
temperature_value = 20
temperature_unit = TEMP_CELSIUS
visibility_value = 11
visibility_unit = LENGTH_KILOMETERS
precipitation_value = 1.1
precipitation_unit = LENGTH_MILLIMETERS
set_options = {
"wind_speed_unit": SPEED_MILES_PER_HOUR,
"precipitation_unit": LENGTH_INCHES,
"pressure_unit": PRESSURE_INHG,
"temperature_unit": TEMP_FAHRENHEIT,
"visibility_unit": LENGTH_MILES,
}
entity_registry = er.async_get(hass)
entry = entity_registry.async_get_or_create("weather", "test",
"very_unique")
entity_registry.async_update_entity_options(entry.entity_id, "weather",
set_options)
await hass.async_block_till_done()
platform: WeatherPlatform = getattr(hass.components, "test.weather")
platform.init(empty=True)
platform.ENTITIES.append(
platform.MockWeatherMockForecast(
name="Test",
condition=ATTR_CONDITION_SUNNY,
native_temperature=temperature_value,
native_temperature_unit=temperature_unit,
native_wind_speed=wind_speed_value,
native_wind_speed_unit=wind_speed_unit,
native_pressure=pressure_value,
native_pressure_unit=pressure_unit,
native_visibility=visibility_value,
native_visibility_unit=visibility_unit,
native_precipitation=precipitation_value,
native_precipitation_unit=precipitation_unit,
unique_id="very_unique",
))
entity0 = platform.ENTITIES[0]
assert await async_setup_component(hass, "weather",
{"weather": {
"platform": "test"
}})
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
forecast = state.attributes[ATTR_FORECAST][0]
expected_wind_speed = round(
convert_speed(wind_speed_value, wind_speed_unit, SPEED_MILES_PER_HOUR),
ROUNDING_PRECISION,
)
expected_temperature = convert_temperature(temperature_value,
temperature_unit,
TEMP_FAHRENHEIT)
expected_pressure = round(
convert_pressure(pressure_value, pressure_unit, PRESSURE_INHG),
ROUNDING_PRECISION,
)
expected_visibility = round(
convert_distance(visibility_value, visibility_unit, LENGTH_MILES),
ROUNDING_PRECISION,
)
expected_precipitation = round(
convert_distance(precipitation_value, precipitation_unit,
LENGTH_INCHES),
ROUNDING_PRECISION,
)
assert float(state.attributes[ATTR_WEATHER_WIND_SPEED]) == approx(
expected_wind_speed)
assert float(state.attributes[ATTR_WEATHER_TEMPERATURE]) == approx(
expected_temperature, rel=0.1)
assert float(
state.attributes[ATTR_WEATHER_PRESSURE]) == approx(expected_pressure)
assert float(state.attributes[ATTR_WEATHER_VISIBILITY]) == approx(
expected_visibility)
assert float(forecast[ATTR_FORECAST_PRECIPITATION]) == approx(
expected_precipitation, rel=1e-2)
assert (state.attributes[ATTR_WEATHER_PRECIPITATION_UNIT] ==
set_options["precipitation_unit"])
assert state.attributes[ATTR_WEATHER_PRESSURE_UNIT] == set_options[
"pressure_unit"]
assert (state.attributes[ATTR_WEATHER_TEMPERATURE_UNIT] ==
set_options["temperature_unit"])
assert (state.attributes[ATTR_WEATHER_VISIBILITY_UNIT] ==
set_options["visibility_unit"])
assert (state.attributes[ATTR_WEATHER_WIND_SPEED_UNIT] ==
set_options["wind_speed_unit"])