def test_length_to_imperial(self):
"""Test length conversion to imperial system."""
assert 100 == \
IMPERIAL_SYSTEM.length(100,
IMPERIAL_SYSTEM.length_unit)
assert 3.106855 == \
IMPERIAL_SYSTEM.length(5, METRIC_SYSTEM.length_unit)
def test_pressure_to_imperial(self):
"""Test pressure conversion to imperial system."""
assert 77 == \
IMPERIAL_SYSTEM.pressure(77, IMPERIAL_SYSTEM.pressure_unit)
self.assertAlmostEqual(
IMPERIAL_SYSTEM.pressure(101352.932, METRIC_SYSTEM.pressure_unit),
14.7, places=4)
def test_length_to_imperial(self):
"""Test length conversion to imperial system."""
assert 100 == \
IMPERIAL_SYSTEM.length(100,
IMPERIAL_SYSTEM.length_unit)
assert 3.106855 == \
IMPERIAL_SYSTEM.length(5, METRIC_SYSTEM.length_unit)
def test_accumulated_precipitation_to_imperial():
"""Test accumulated_precipitation conversion to imperial system."""
assert (IMPERIAL_SYSTEM.accumulated_precipitation(
10, IMPERIAL_SYSTEM.accumulated_precipitation_unit) == 10)
assert IMPERIAL_SYSTEM.accumulated_precipitation(
254, METRIC_SYSTEM.accumulated_precipitation_unit) == pytest.approx(
10, abs=1e-4)
def test_temperature_to_imperial(self):
"""Test temperature conversion to imperial system."""
self.assertEqual(
77,
IMPERIAL_SYSTEM.temperature(77, IMPERIAL_SYSTEM.temperature_unit))
self.assertEqual(
77,
IMPERIAL_SYSTEM.temperature(25, METRIC_SYSTEM.temperature_unit))
def test_temperature_to_imperial(self):
"""Test temperature conversion to imperial system."""
self.assertEqual(
77,
IMPERIAL_SYSTEM.temperature(77, IMPERIAL_SYSTEM.temperature_unit))
self.assertEqual(
77, IMPERIAL_SYSTEM.temperature(25,
METRIC_SYSTEM.temperature_unit))
def test_pressure_to_imperial(self):
"""Test pressure conversion to imperial system."""
assert 77 == \
IMPERIAL_SYSTEM.pressure(77, IMPERIAL_SYSTEM.pressure_unit)
self.assertAlmostEqual(IMPERIAL_SYSTEM.pressure(
101352.932, METRIC_SYSTEM.pressure_unit),
14.7,
places=4)
def test_length_to_imperial(self):
"""Test length conversion to imperial system."""
self.assertEqual(
100,
IMPERIAL_SYSTEM.length(100,
IMPERIAL_SYSTEM.length_unit)
)
self.assertEqual(
3.106855,
IMPERIAL_SYSTEM.length(5, METRIC_SYSTEM.length_unit)
)
def _update_from_feed(self, feed_entry):
"""Update the internal state from the provided feed entry."""
event_name = feed_entry.event_name
if not event_name:
# Earthquakes usually don't have an event name.
event_name = f"{feed_entry.country} ({feed_entry.event_id})"
self._title = f"{feed_entry.event_type}: {event_name}"
# Convert distance if not metric system.
if self.hass.config.units.name == CONF_UNIT_SYSTEM_IMPERIAL:
self._distance = IMPERIAL_SYSTEM.length(
feed_entry.distance_to_home, LENGTH_KILOMETERS)
else:
self._distance = feed_entry.distance_to_home
self._latitude = feed_entry.coordinates[0]
self._longitude = feed_entry.coordinates[1]
self._attribution = feed_entry.attribution
self._alert_level = feed_entry.alert_level
self._country = feed_entry.country
self._description = feed_entry.title
self._duration_in_week = feed_entry.duration_in_week
self._event_type_short = feed_entry.event_type_short
self._event_type = feed_entry.event_type
self._from_date = feed_entry.from_date
self._to_date = feed_entry.to_date
self._population = feed_entry.population
self._severity = feed_entry.severity
self._vulnerability = feed_entry.vulnerability
# Round vulnerability value if presented as float.
if isinstance(self._vulnerability, float):
self._vulnerability = round(self._vulnerability, 1)
self._version = feed_entry.version
def state(self) -> Optional[int]:
"""Return the state of this entity."""
if self.data.batteryAutonomy is None:
return None
if not self.hass.config.units.is_metric:
return IMPERIAL_SYSTEM.length(self.data.batteryAutonomy,
METRIC_SYSTEM.length_unit)
return self.data.batteryAutonomy
def state(self) -> Optional[int]:
"""Return the state of this entity."""
if self.data.batteryAutonomy is None:
return None
if self.vehicle.distances_in_miles:
return round(
IMPERIAL_SYSTEM.length(self.data.batteryAutonomy,
METRIC_SYSTEM.length_unit))
return self.data.batteryAutonomy
def state(self) -> Optional[int]:
"""Return the state of this entity."""
if self.data.fuelQuantity is None:
return None
if not self.hass.config.units.is_metric:
return round(
IMPERIAL_SYSTEM.volume(self.data.fuelQuantity,
METRIC_SYSTEM.volume_unit))
return round(self.data.fuelQuantity)
def state(self) -> Optional[int]:
"""Return the state of this entity."""
if self.data.totalMileage is None:
return None
if not self.hass.config.units.is_metric:
return round(
IMPERIAL_SYSTEM.length(self.data.totalMileage,
METRIC_SYSTEM.length_unit))
return round(self.data.totalMileage)
def state(self):
"""Return the state of this entity."""
data = self.coordinator.data
if "totalMileage" in data:
mileage = data["totalMileage"]
if not self.hass.config.units.is_metric:
mileage = IMPERIAL_SYSTEM.length(mileage,
METRIC_SYSTEM.length_unit)
return round(mileage)
LOGGER.debug("totalMileage not available in coordinator data %s", data)
def state(self):
"""Return the state of this entity."""
data = self.coordinator.data
if "batteryAutonomy" in data:
autonomy = data["batteryAutonomy"]
if not self.hass.config.units.is_metric:
autonomy = IMPERIAL_SYSTEM.length(autonomy,
METRIC_SYSTEM.length_unit)
return autonomy
LOGGER.debug("batteryAutonomy not available in coordinator data %s",
data)
def state(self):
"""Battery range in miles or kms."""
if self._ac_on:
ret = self.car.data[DATA_RANGE_AC]
else:
ret = self.car.data[DATA_RANGE_AC_OFF]
if (not self.car.hass.config.units.is_metric or self.car.force_miles):
ret = IMPERIAL_SYSTEM.length(ret, METRIC_SYSTEM.length_unit)
return round(ret)
def state(self):
"""Battery range in miles or kms."""
if self._ac_on:
ret = self.car.data[DATA_RANGE_AC]
else:
ret = self.car.data[DATA_RANGE_AC_OFF]
if (not self.car.hass.config.units.is_metric or
self.car.force_miles):
ret = IMPERIAL_SYSTEM.length(ret, METRIC_SYSTEM.length_unit)
return round(ret)
def state(self):
ret = 0
if self.ac_on is True:
ret = self.car.data[LeafCore.DATA_RANGE_AC]
else:
ret = self.car.data[LeafCore.DATA_RANGE_AC_OFF]
if (self.car.hass.config.units.is_metric is False
or self.car.force_miles is True):
ret = IMPERIAL_SYSTEM.length(ret, METRIC_SYSTEM.length_unit)
return round(ret, 0)
def native_value(self) -> float | None:
"""Battery range in miles or kms."""
if self._ac_on:
ret = self.car.data[DATA_RANGE_AC]
else:
ret = self.car.data[DATA_RANGE_AC_OFF]
if ret is None:
return None
if not self.car.hass.config.units.is_metric or self.car.force_miles:
ret = IMPERIAL_SYSTEM.length(ret, METRIC_SYSTEM.length_unit)
return round(ret)
def set_temperature(self, **kwargs):
mode = kwargs.get(ATTR_HVAC_MODE)
if mode != None:
self.set_hvac_mode(mode)
temp = kwargs.get(ATTR_TEMPERATURE)
if self._device.units.temperature_unit != TEMP_FAHRENHEIT:
if self._device.force_fahrenheit:
# undo HA's conversion
temp = METRIC_SYSTEM.temperature(temp, TEMP_FAHRENHEIT)
else:
temp = IMPERIAL_SYSTEM.temperature(
temp, self._device.units.temperature_unit)
self._device.dps(DPS_TARGET, int(temp + 0.5))
def _update_from_feed(self, feed_entry):
"""Update the internal state from the provided feed entry."""
self._title = feed_entry.title
# Convert distance if not metric system.
if self.hass.config.units.name == CONF_UNIT_SYSTEM_IMPERIAL:
self._distance = IMPERIAL_SYSTEM.length(
feed_entry.distance_to_home, LENGTH_KILOMETERS)
else:
self._distance = feed_entry.distance_to_home
self._latitude = feed_entry.coordinates[0]
self._longitude = feed_entry.coordinates[1]
self._attribution = feed_entry.attribution
self._depth = feed_entry.depth
self._locality = feed_entry.locality
self._magnitude = feed_entry.magnitude
self._mmi = feed_entry.mmi
self._quality = feed_entry.quality
self._time = feed_entry.time
def _update_from_feed(self, feed_entry, last_update, last_update_successful):
"""Update the internal state from the provided feed entry."""
self._title = feed_entry.title
# Convert distance if not metric system.
if self._unit_system == CONF_UNIT_SYSTEM_IMPERIAL:
self._distance = round(
IMPERIAL_SYSTEM.length(feed_entry.distance_to_home, LENGTH_KILOMETERS),
1,
)
else:
self._distance = round(feed_entry.distance_to_home, 1)
self._latitude = round(feed_entry.coordinates[0], 5)
self._longitude = round(feed_entry.coordinates[1], 5)
self._attribution = feed_entry.attribution
self._alert_level = feed_entry.alert_level
self._activity = feed_entry.activity
self._hazards = feed_entry.hazards
self._feed_last_update = dt.as_utc(last_update) if last_update else None
self._feed_last_update_successful = (
dt.as_utc(last_update_successful) if last_update_successful else None
)
def test_wind_speed_to_imperial():
"""Test wind_speed conversion to imperial system."""
assert IMPERIAL_SYSTEM.wind_speed(100,
IMPERIAL_SYSTEM.wind_speed_unit) == 100
assert IMPERIAL_SYSTEM.wind_speed(
1000, METRIC_SYSTEM.wind_speed_unit) == pytest.approx(2237, abs=0.1)
def test_length_to_imperial(self):
"""Test length conversion to imperial system."""
self.assertEqual(
100, IMPERIAL_SYSTEM.length(100, IMPERIAL_SYSTEM.length_unit))
self.assertEqual(3.106855,
IMPERIAL_SYSTEM.length(5, METRIC_SYSTEM.length_unit))
class GdacsEvent(GeolocationEvent):
"""This represents an external event with GDACS feed data."""
def __init__(self, feed_manager, integration_id, external_id):
"""Initialize entity with data from feed entry."""
self._feed_manager = feed_manager
self._integration_id = integration_id
self._external_id = external_id
self._title = None
self._distance = None
self._latitude = None
self._longitude = None
self._attribution = None
self._alert_level = None
self._country = None
self._description = None
self._duration_in_week = None
self._event_type_short = None
self._event_type = None
self._from_date = None
self._to_date = None
self._population = None
self._severity = None
self._vulnerability = None
self._version = None
self._remove_signal_delete = None
self._remove_signal_update = None
async def async_added_to_hass(self):
"""Call when entity is added to hass."""
self._remove_signal_delete = async_dispatcher_connect(
self.hass, f"gdacs_delete_{self._external_id}",
self._delete_callback)
self._remove_signal_update = async_dispatcher_connect(
self.hass, f"gdacs_update_{self._external_id}",
self._update_callback)
async def async_will_remove_from_hass(self) -> None:
"""Call when entity will be removed from hass."""
self._remove_signal_delete()
self._remove_signal_update()
# Remove from entity registry.
entity_registry = er.async_get(self.hass)
if self.entity_id in entity_registry.entities:
entity_registry.async_remove(self.entity_id)
@callback
def _delete_callback(self):
"""Remove this entity."""
self.hass.async_create_task(self.async_remove(force_remove=True))
@callback
def _update_callback(self):
"""Call update method."""
self.async_schedule_update_ha_state(True)
@property
def should_poll(self):
"""No polling needed for GDACS feed location events."""
return False
async def async_update(self):
"""Update this entity from the data held in the feed manager."""
_LOGGER.debug("Updating %s", self._external_id)
feed_entry = self._feed_manager.get_entry(self._external_id)
if feed_entry:
self._update_from_feed(feed_entry)
def _update_from_feed(self, feed_entry):
"""Update the internal state from the provided feed entry."""
if not (event_name := feed_entry.event_name):
# Earthquakes usually don't have an event name.
event_name = f"{feed_entry.country} ({feed_entry.event_id})"
self._title = f"{feed_entry.event_type}: {event_name}"
# Convert distance if not metric system.
if self.hass.config.units.name == CONF_UNIT_SYSTEM_IMPERIAL:
self._distance = IMPERIAL_SYSTEM.length(
feed_entry.distance_to_home, LENGTH_KILOMETERS)
else:
self._distance = feed_entry.distance_to_home
self._latitude = feed_entry.coordinates[0]
self._longitude = feed_entry.coordinates[1]
self._attribution = feed_entry.attribution
self._alert_level = feed_entry.alert_level
self._country = feed_entry.country
self._description = feed_entry.title
self._duration_in_week = feed_entry.duration_in_week
self._event_type_short = feed_entry.event_type_short
self._event_type = feed_entry.event_type
self._from_date = feed_entry.from_date
self._to_date = feed_entry.to_date
self._population = feed_entry.population
self._severity = feed_entry.severity
self._vulnerability = feed_entry.vulnerability
# Round vulnerability value if presented as float.
if isinstance(self._vulnerability, float):
self._vulnerability = round(self._vulnerability, 1)
self._version = feed_entry.version
def update(self):
"""Update WazeRouteCalculator Sensor."""
_LOGGER.debug(
"Getting update for origin: %s destination: %s",
self.origin,
self.destination,
)
if self.origin is not None and self.destination is not None:
# Grab options on every update
incl_filter = self.config_entry.options.get(CONF_INCL_FILTER)
excl_filter = self.config_entry.options.get(CONF_EXCL_FILTER)
realtime = self.config_entry.options[CONF_REALTIME]
vehicle_type = self.config_entry.options[CONF_VEHICLE_TYPE]
vehicle_type = "" if vehicle_type.upper(
) == "CAR" else vehicle_type.upper()
avoid_toll_roads = self.config_entry.options[CONF_AVOID_TOLL_ROADS]
avoid_subscription_roads = self.config_entry.options[
CONF_AVOID_SUBSCRIPTION_ROADS]
avoid_ferries = self.config_entry.options[CONF_AVOID_FERRIES]
units = self.config_entry.options[CONF_UNITS]
try:
params = WazeRouteCalculator(
self.origin,
self.destination,
self.region,
vehicle_type,
avoid_toll_roads,
avoid_subscription_roads,
avoid_ferries,
)
routes = params.calc_all_routes_info(real_time=realtime)
if incl_filter is not None:
routes = {
k: v
for k, v in routes.items()
if incl_filter.lower() in k.lower()
}
if excl_filter is not None:
routes = {
k: v
for k, v in routes.items()
if excl_filter.lower() not in k.lower()
}
if routes:
route = list(routes)[0]
else:
_LOGGER.warning("No routes found")
return
self.duration, distance = routes[route]
if units == CONF_UNIT_SYSTEM_IMPERIAL:
# Convert to miles.
self.distance = IMPERIAL_SYSTEM.length(
distance, LENGTH_KILOMETERS)
else:
self.distance = distance
self.route = route
except WRCError as exp:
_LOGGER.warning("Error on retrieving data: %s", exp)
return
except KeyError:
_LOGGER.error("Error retrieving data from server")
return
def _update(self) -> HERERoutingData | None:
"""Get the latest data from the HERE Routing API."""
try:
origin, destination, arrival, departure = self._prepare_parameters(
)
_LOGGER.debug(
"Requesting route for origin: %s, destination: %s, route_mode: %s, mode: %s, traffic_mode: %s, arrival: %s, departure: %s",
origin,
destination,
RouteMode[self.config.route_mode],
RouteMode[self.config.travel_mode],
RouteMode[TRAFFIC_MODE_ENABLED],
arrival,
departure,
)
response: RoutingResponse = self._api.public_transport_timetable(
origin,
destination,
True,
[
RouteMode[self.config.route_mode],
RouteMode[self.config.travel_mode],
RouteMode[TRAFFIC_MODE_ENABLED],
],
arrival=arrival,
departure=departure,
)
_LOGGER.debug("Raw response is: %s", response.response)
attribution: str | None = None
if "sourceAttribution" in response.response:
attribution = build_hass_attribution(
response.response.get("sourceAttribution"))
route: list = response.response["route"]
summary: dict = route[0]["summary"]
waypoint: list = route[0]["waypoint"]
distance: float = summary["distance"]
traffic_time: float = summary["baseTime"]
if self.config.travel_mode in TRAVEL_MODES_VEHICLE:
traffic_time = summary["trafficTime"]
if self.config.units == CONF_UNIT_SYSTEM_IMPERIAL:
# Convert to miles.
distance = IMPERIAL_SYSTEM.length(distance, LENGTH_METERS)
else:
# Convert to kilometers
distance = distance / 1000
return HERERoutingData({
ATTR_ATTRIBUTION:
attribution,
ATTR_DURATION:
round(summary["baseTime"] / 60), # type: ignore[misc]
ATTR_DURATION_IN_TRAFFIC:
round(traffic_time / 60),
ATTR_DISTANCE:
distance,
ATTR_ROUTE:
response.route_short,
ATTR_ORIGIN:
",".join(origin),
ATTR_DESTINATION:
",".join(destination),
ATTR_ORIGIN_NAME:
waypoint[0]["mappedRoadName"],
ATTR_DESTINATION_NAME:
waypoint[1]["mappedRoadName"],
})
except InvalidCoordinatesException as ex:
_LOGGER.error("Could not call HERE api: %s", ex)
return None
def test_pressure_to_imperial():
"""Test pressure conversion to imperial system."""
assert IMPERIAL_SYSTEM.pressure(77, IMPERIAL_SYSTEM.pressure_unit) == 77
assert IMPERIAL_SYSTEM.pressure(
101352.932, METRIC_SYSTEM.pressure_unit) == pytest.approx(14.7,
abs=1e-4)
def test_length_to_imperial():
"""Test length conversion to imperial system."""
assert IMPERIAL_SYSTEM.length(100, IMPERIAL_SYSTEM.length_unit) == 100
assert IMPERIAL_SYSTEM.length(5, METRIC_SYSTEM.length_unit) == 3.106855
def test_temperature_to_imperial():
"""Test temperature conversion to imperial system."""
assert IMPERIAL_SYSTEM.temperature(77,
IMPERIAL_SYSTEM.temperature_unit) == 77
assert IMPERIAL_SYSTEM.temperature(25,
METRIC_SYSTEM.temperature_unit) == 77
