def pressure(self):
"""Return the current pressure."""
pressure_pa = None
if self.observation:
pressure_pa = self.observation.get("seaLevelPressure")
if pressure_pa is None:
return None
if self.is_metric:
pressure = convert_pressure(pressure_pa, PRESSURE_PA, PRESSURE_HPA)
pressure = round(pressure)
else:
pressure = convert_pressure(pressure_pa, PRESSURE_PA, PRESSURE_INHG)
pressure = round(pressure, 2)
return pressure
def pressure(self) -> int:
"""Return the pressure."""
pressure_hpa = self._current.pres
if self._is_metric or pressure_hpa is None:
return pressure_hpa
return round(convert_pressure(pressure_hpa, PRESSURE_HPA, PRESSURE_INHG), 2)
def pressure(self):
"""Return the pressure."""
pressure = self.data.get_pressure().get("press")
if self.hass.config.units.name == "imperial":
return round(
convert_pressure(pressure, PRESSURE_HPA, PRESSURE_INHG), 2)
return pressure
def pressure(self):
"""Return the pressure."""
pressure = self._ds_currently.get('pressure')
if 'us' in self._dark_sky.units:
return round(
convert_pressure(pressure, PRESSURE_HPA, PRESSURE_INHG), 2)
return pressure
def pressure(self):
"""Return the pressure."""
pressure = self._ds_currently.get("pressure")
if "us" in self._dark_sky.units:
return round(
convert_pressure(pressure, PRESSURE_HPA, PRESSURE_INHG), 2)
return pressure
def pressure(self):
"""Return the pressure."""
pressure_hpa = self._current_weather_data.get("pressure")
if self._is_metric or pressure_hpa is None:
return pressure_hpa
return round(
convert_pressure(pressure_hpa, PRESSURE_HPA, PRESSURE_INHG), 2)
def pressure(self):
"""Return the pressure."""
pressure_hpa = self.coordinator.data.current_weather_data.get(
ATTR_MAP[ATTR_WEATHER_PRESSURE])
if self._is_metric or pressure_hpa is None:
return pressure_hpa
return round(
convert_pressure(pressure_hpa, PRESSURE_HPA, PRESSURE_INHG), 2)
def pressure(self):
"""Return the current pressure."""
pressure_pa = None
if self._observation:
pressure_pa = self._observation.get('seaLevelPressure',
{}).get('value')
if pressure_pa is None and self._metar_obs and self._metar_obs.press:
pressure_hpa = self._metar_obs.press.value(units='HPA')
if pressure_hpa is None:
return None
pressure_pa = convert_pressure(pressure_hpa, PRESSURE_HPA,
PRESSURE_PA)
if pressure_pa is None:
return None
if self._is_metric:
pressure = convert_pressure(pressure_pa, PRESSURE_PA, PRESSURE_HPA)
pressure = round(pressure)
else:
pressure = convert_pressure(pressure_pa, PRESSURE_PA,
PRESSURE_INHG)
pressure = round(pressure, 2)
return pressure
def state(self):
"""Return the state of the sensor."""
if self._sensor_type == TYPE_SENSOR:
value = getattr(self._current, self._sensor)
if value is None:
return None
if self._device_class == DEVICE_TYPE_WIND:
if self._is_metric:
if self._wind_unit_metric == UNIT_WIND_KMH:
return round(value * 3.6, 1)
return round(value, 1)
return round(float(value * 2.23693629), 2)
if self._device_class == DEVICE_TYPE_PRESSURE:
if self._is_metric:
return value
return round(
convert_pressure(value, PRESSURE_HPA, PRESSURE_INHG), 2)
if (self._device_class == DEVICE_TYPE_RAIN
or self._device_class == DEVICE_TYPE_SNOW):
if self._is_metric:
return round(float(value), 1)
return round(float(value) / 25.4, 2)
if self._device_class == DEVICE_TYPE_DISTANCE:
if self._is_metric:
return value
return int(
float(
convert_distance(value, LENGTH_KILOMETERS,
LENGTH_MILES)))
if self._device_class == "UVI":
return round(float(value), 1)
if self._device_class == UNIT_WIND_KNOT:
return round(value, 1)
return value
if self._sensor_type == TYPE_ALERT:
return getattr(self._alerts, "alert_count")
return self._condition
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_distance(value, LENGTH_KILOMETERS, LENGTH_MILES))
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 state(self):
"""Return the state."""
value = self._nws.observation.get(self._type)
if value is None:
return None
if self._unit == SPEED_MILES_PER_HOUR:
return round(
convert_distance(value, LENGTH_KILOMETERS, LENGTH_MILES))
if self._unit == LENGTH_MILES:
return round(convert_distance(value, LENGTH_METERS, LENGTH_MILES))
if self._unit == PRESSURE_INHG:
return round(convert_pressure(value, PRESSURE_PA, PRESSURE_INHG),
2)
if self._unit == TEMP_CELSIUS:
return round(value, 1)
if self._unit == PERCENTAGE:
return round(value)
return value
async def test_pressure_conversion(
hass,
enable_custom_integrations,
unit_system,
):
"""Test pressure conversion."""
hass.config.units = unit_system
native_value = 30
native_unit = PRESSURE_INHG
entity0 = await create_entity(
hass, pressure=native_value, pressure_unit=native_unit
)
state = hass.states.get(entity0.entity_id)
forecast = state.attributes[ATTR_FORECAST][0]
expected = convert_pressure(native_value, native_unit, unit_system.pressure_unit)
assert float(state.attributes[ATTR_WEATHER_PRESSURE]) == approx(expected, rel=1e-2)
assert float(forecast[ATTR_FORECAST_PRESSURE]) == approx(expected, rel=1e-2)
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 async_update(self, *_):
"""Get the latest data"""
def try_again(err: str):
"""Retry"""
_LOGGER.error("Will try again shortly: %s", err)
async_call_later(self.hass, 2 * 60, self.async_update)
try:
websession = async_get_clientsession(self.hass)
with async_timeout.timeout(10, loop=self.hass.loop):
resp = await websession.get(self._url)
if resp.status != 200:
try_again('{} returned {}'.format(resp.url, resp.status))
return
text = await resp.text()
except (asyncio.TimeoutError, aiohttp.ClientError) as err:
try_again(err)
return
try:
self.data = text.split(' ')
if len(self.data) < 115:
raise ValueError('Could not parse the file')
except (ExpatError, IndexError) as err:
try_again(err)
return
if not self.data:
return
# Update all devices
tasks = []
for dev in self.devices:
new_state = None
if dev.type == 'symbol':
new_state = int(self.data[48])
elif dev.type == 'daily_rain':
rain = float(self.data[7])
if not self.hass.config.units.is_metric:
rain = rain * 0.0393700787
new_state = round(rain, 2)
elif dev.type == 'rain_rate':
rate = float(self.data[10])
if not self.hass.config.units.is_metric:
rate = rate * 0.0393700787
new_state = round(rate, 2)
elif dev.type == 'temp':
temperature = float(self.data[4])
if not self.hass.config.units.is_metric:
temperature = convert_temperature(temperature,
TEMP_CELSIUS,
TEMP_FAHRENHEIT)
new_state = round(temperature, 2)
elif dev.type == 'wind_speed':
speed = float(self.data[1])
if self.hass.config.units.is_metric:
new_state = speed * 1.85166
else:
new_state = speed * 1.1507794
new_state = round(speed, 2)
elif dev.type == 'wind_gust':
gust = float(self.data[2])
if self.hass.config.units.is_metric:
new_state = gust * 1.85166
else:
new_state = gust * 1.1507794
new_state = round(gust, 2)
elif dev.type == 'pressure':
pressure = float(self.data[6])
if not self.hass.config.units.is_metric:
pressure = round(
convert_pressure(pressure, PRESSURE_HPA,
PRESSURE_INHG), 2)
new_state = round(pressure, 2)
elif dev.type == 'wind_degrees':
new_state = float(self.data[3])
elif dev.type == 'wind_dir':
direction = float(self.data[3])
val = int((direction / 22.5) + .5)
arr = [
"N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", "S",
"SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"
]
new_state = arr[(val % 16)]
elif dev.type == 'humidity':
new_state = float(self.data[5])
elif dev.type == 'cloud_height':
height = float(self.data[73])
if not self.hass.config.units.is_metric:
height = convert_distance(height, LENGTH_METERS,
LENGTH_FEET)
new_state = round(height, 2)
elif dev.type == 'dewpoint':
temperature = float(self.data[72])
if not self.hass.config.units.is_metric:
temperature = convert_temperature(temperature,
TEMP_CELSIUS,
TEMP_FAHRENHEIT)
new_state = round(temperature, 2)
elif dev.type == 'heat_index':
temperature = float(self.data[112])
if not self.hass.config.units.is_metric:
temperature = convert_temperature(temperature,
TEMP_CELSIUS,
TEMP_FAHRENHEIT)
new_state = round(temperature, 2)
elif dev.type == 'humidex':
temperature = float(self.data[44])
if not self.hass.config.units.is_metric:
temperature = convert_temperature(temperature,
TEMP_CELSIUS,
TEMP_FAHRENHEIT)
new_state = round(temperature, 2)
elif dev.type == 'forecast':
val = int(self.data[15])
arr = [
"sunny", "clearnight", "cloudy", "cloudy2", "night cloudy",
"dry", "fog", "haze", "heavyrain", "mainlyfine", "mist",
"night fog", "night heavyrain", "night overcast",
"night rain", "night showers", "night snow", "night",
"thunder", "overcast", "partlycloudy", "rain", "rain2",
"showers2", "sleet", "sleetshowers", "snow", "snowmelt",
"snowshowers2", "sunny", "thundershowers",
"thundershowers2", "thunderstorms", "tornado", "windy",
"stopped", "rainning", "wind + rain"
]
new_state = arr[(val)] if val < len(arr) else "unknown"
_LOGGER.debug("%s %s", dev.type, new_state)
# pylint: disable=protected-access
if new_state != dev._state:
dev._state = new_state
tasks.append(dev.async_update_ha_state())
if tasks:
await asyncio.wait(tasks, loop=self.hass.loop)
async_call_later(self.hass, self._interval * 60, self.async_update)
"textDescription": "A long description",
"station": "ABC",
"timestamp": "2019-08-12T23:53:00+00:00",
"iconTime": "day",
"iconWeather": (("Fair/clear", None), ),
}
EXPECTED_OBSERVATION_IMPERIAL = {
ATTR_WEATHER_TEMPERATURE:
round(convert_temperature(10, TEMP_CELSIUS, TEMP_FAHRENHEIT)),
ATTR_WEATHER_WIND_BEARING:
180,
ATTR_WEATHER_WIND_SPEED:
round(convert_distance(10, LENGTH_METERS, LENGTH_MILES) * 3600),
ATTR_WEATHER_PRESSURE:
round(convert_pressure(100000, PRESSURE_PA, PRESSURE_INHG), 2),
ATTR_WEATHER_VISIBILITY:
round(convert_distance(10000, LENGTH_METERS, LENGTH_MILES)),
ATTR_WEATHER_HUMIDITY:
10,
}
EXPECTED_OBSERVATION_METRIC = {
ATTR_WEATHER_TEMPERATURE:
10,
ATTR_WEATHER_WIND_BEARING:
180,
ATTR_WEATHER_WIND_SPEED:
round(convert_distance(10, LENGTH_METERS, LENGTH_KILOMETERS) * 3600),
ATTR_WEATHER_PRESSURE:
round(convert_pressure(100000, PRESSURE_PA, PRESSURE_HPA)),
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"])
def imperial_pressure(pressure):
"""Convert pressure to imperial/US."""
return round(convert_pressure(pressure, PRESSURE_HPA, PRESSURE_INHG), 2)
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 = {
ATTR_WEATHER_TEMPERATURE: round(
convert_temperature(10, TEMP_CELSIUS, TEMP_FAHRENHEIT)
),
ATTR_WEATHER_WIND_BEARING: 180,
ATTR_WEATHER_WIND_SPEED: round(
convert_speed(10, SPEED_KILOMETERS_PER_HOUR, SPEED_MILES_PER_HOUR), 2
),
