def test_convert_same_unit(self):
"""Test conversion from any unit to same unit."""
assert 5 == distance_util.convert(5, LENGTH_KILOMETERS,
LENGTH_KILOMETERS)
assert 2 == distance_util.convert(2, LENGTH_METERS,
LENGTH_METERS)
assert 10 == distance_util.convert(10, LENGTH_MILES, LENGTH_MILES)
assert 9 == distance_util.convert(9, LENGTH_FEET, LENGTH_FEET)
def test_convert_from_miles():
"""Test conversion from miles to other units."""
miles = 5
assert distance_util.convert(miles, LENGTH_MILES,
LENGTH_KILOMETERS) == 8.04672
assert distance_util.convert(miles, LENGTH_MILES, LENGTH_METERS) == 8046.72
assert distance_util.convert(miles, LENGTH_MILES,
LENGTH_FEET) == 26400.0008448
def test_convert_from_meters(self):
"""Test conversion from meters to other units."""
m = 5000
assert distance_util.convert(m, LENGTH_METERS, LENGTH_FEET) == \
16404.2
assert distance_util.convert(m, LENGTH_METERS, LENGTH_KILOMETERS) == \
5
assert distance_util.convert(m, LENGTH_METERS, LENGTH_MILES) == \
3.106855
def test_convert_invalid_unit(self):
"""Test exception is thrown for invalid units."""
with self.assertRaises(ValueError):
distance_util.convert(5, INVALID_SYMBOL,
VALID_SYMBOL)
with self.assertRaises(ValueError):
distance_util.convert(5, VALID_SYMBOL,
INVALID_SYMBOL)
def test_convert_from_meters(self):
"""Test conversion from meters to other units."""
m = 5000
self.assertEqual(distance_util.convert(m, LENGTH_METERS, LENGTH_FEET),
16404.2)
self.assertEqual(
distance_util.convert(m, LENGTH_METERS, LENGTH_KILOMETERS), 5)
self.assertEqual(distance_util.convert(m, LENGTH_METERS, LENGTH_MILES),
3.106855)
def test_convert_same_unit(self):
"""Test conversion from any unit to same unit."""
self.assertEqual(
5, distance_util.convert(5, LENGTH_KILOMETERS, LENGTH_KILOMETERS))
self.assertEqual(
2, distance_util.convert(2, LENGTH_METERS, LENGTH_METERS))
self.assertEqual(10,
distance_util.convert(10, LENGTH_MILES, LENGTH_MILES))
self.assertEqual(9, distance_util.convert(9, LENGTH_FEET, LENGTH_FEET))
def test_convert_from_feet(self):
"""Test conversion from feet to other units."""
feet = 5000
assert distance_util.convert(feet, LENGTH_FEET, LENGTH_KILOMETERS) == \
1.524
assert distance_util.convert(feet, LENGTH_FEET, LENGTH_METERS) == \
1524
assert distance_util.convert(feet, LENGTH_FEET, LENGTH_MILES) == \
0.9469694040000001
def test_convert_from_feet(self):
"""Test conversion from feet to other units."""
feet = 5000
self.assertEqual(
distance_util.convert(feet, LENGTH_FEET, LENGTH_KILOMETERS), 1.524)
self.assertEqual(
distance_util.convert(feet, LENGTH_FEET, LENGTH_METERS), 1524)
self.assertEqual(
distance_util.convert(feet, LENGTH_FEET, LENGTH_MILES),
0.9469694040000001)
def test_convert_from_meters(self):
"""Test conversion from meters to other units."""
m = 5000
self.assertEqual(distance_util.convert(m, LENGTH_METERS, LENGTH_FEET),
16404.2)
self.assertEqual(
distance_util.convert(m, LENGTH_METERS, LENGTH_KILOMETERS),
5)
self.assertEqual(distance_util.convert(m, LENGTH_METERS, LENGTH_MILES),
3.106855)
def test_convert_from_miles(self):
"""Test conversion from miles to other units."""
miles = 5
assert distance_util.convert(
miles, LENGTH_MILES, LENGTH_KILOMETERS
) == 8.04672
assert distance_util.convert(miles, LENGTH_MILES, LENGTH_METERS) == \
8046.72
assert distance_util.convert(miles, LENGTH_MILES, LENGTH_FEET) == \
26400.0008448
def test_convert_from_miles(self):
"""Test conversion from miles to other units."""
miles = 5
self.assertEqual(
distance_util.convert(miles, LENGTH_MILES, LENGTH_KILOMETERS),
8.04672)
self.assertEqual(
distance_util.convert(miles, LENGTH_MILES, LENGTH_METERS), 8046.72)
self.assertEqual(
distance_util.convert(miles, LENGTH_MILES, LENGTH_FEET),
26400.0008448)
def test_convert_same_unit(self):
"""Test conversion from any unit to same unit."""
self.assertEqual(5,
distance_util.convert(5, LENGTH_KILOMETERS,
LENGTH_KILOMETERS))
self.assertEqual(2,
distance_util.convert(2, LENGTH_METERS,
LENGTH_METERS))
self.assertEqual(10,
distance_util.convert(10, LENGTH_MILES, LENGTH_MILES))
self.assertEqual(9,
distance_util.convert(9, LENGTH_FEET, LENGTH_FEET))
def test_convert_from_miles(self):
"""Test conversion from miles to other units."""
miles = 5
self.assertEqual(
distance_util.convert(miles, LENGTH_MILES, LENGTH_KILOMETERS),
8.04672)
self.assertEqual(
distance_util.convert(miles, LENGTH_MILES, LENGTH_METERS),
8046.72)
self.assertEqual(
distance_util.convert(miles, LENGTH_MILES, LENGTH_FEET),
26400.0008448)
def test_convert_from_feet(self):
"""Test conversion from feet to other units."""
feet = 5000
self.assertEqual(
distance_util.convert(feet, LENGTH_FEET, LENGTH_KILOMETERS),
1.524)
self.assertEqual(
distance_util.convert(feet, LENGTH_FEET, LENGTH_METERS),
1524)
self.assertEqual(
distance_util.convert(feet, LENGTH_FEET, LENGTH_MILES),
0.9469694040000001)
def extra_state_attributes(self):
attrs = {}
attrs["Fuel Type"] = self._fuel
if self._vehicle.engine_type in [FUEL_TYPE_ICE, FUEL_TYPE_HYBRID]:
attrs["Fuel Level"] = (
self._vehicle.status.get("FUEL_LEVEL_PERC", "0") + PERCENTAGE)
if self._engine_type in [FUEL_TYPE_BATTERY, FUEL_TYPE_HYBRID]:
attrs["Battery Level"] = (
self._vehicle.status_ev.get("EV_STATE_OF_CHARGE", "0") +
PERCENTAGE)
# If hybrid
if self._engine_type == FUEL_TYPE_HYBRID:
attrs["Fuel Range"] = round(
distance.convert(
int(self._vehicle.status.get("DISTANCE_TO_EMPTY_FUEL")),
LENGTH_KILOMETERS,
self._units,
))
attrs["Battery Range"] = (
self._vehicle.status_ev.get("EV_RANGE_ON_BATTERY_KM", "0")
if self._units == LENGTH_KILOMETERS else
self._vehicle.status_ev.get("EV_RANGE_ON_BATTERY_MILES", "0"))
return attrs
def length(self, length: float, from_unit: str) -> float:
"""Convert the given length to this unit system."""
if not isinstance(length, Number):
raise TypeError('{} is not a numeric value.'.format(str(length)))
return distance_util.convert(length, from_unit,
self.length_unit)
def accumulated_precipitation(self, precip: float | None, from_unit: str) -> float:
"""Convert the given length to this unit system."""
if not isinstance(precip, Number):
raise TypeError(f"{precip!s} is not a numeric value.")
# type ignore: https://github.com/python/mypy/issues/7207
return distance_util.convert( # type: ignore
precip, from_unit, self.accumulated_precipitation_unit
)
async def async_setup_platform(
hass: HomeAssistant,
config: ConfigType,
async_add_entities: AddEntitiesCallback,
discovery_info: DiscoveryInfoType | None = None,
) -> None:
"""Set up the CityBikes platform."""
if PLATFORM not in hass.data:
hass.data[PLATFORM] = {MONITORED_NETWORKS: {}}
latitude = config.get(CONF_LATITUDE, hass.config.latitude)
longitude = config.get(CONF_LONGITUDE, hass.config.longitude)
network_id = config.get(CONF_NETWORK)
stations_list = set(config.get(CONF_STATIONS_LIST, []))
radius = config.get(CONF_RADIUS, 0)
name = config[CONF_NAME]
if not hass.config.units.is_metric:
radius = distance.convert(radius, LENGTH_FEET, LENGTH_METERS)
# Create a single instance of CityBikesNetworks.
networks = hass.data.setdefault(CITYBIKES_NETWORKS,
CityBikesNetworks(hass))
if not network_id:
network_id = await networks.get_closest_network_id(latitude, longitude)
if network_id not in hass.data[PLATFORM][MONITORED_NETWORKS]:
network = CityBikesNetwork(hass, network_id)
hass.data[PLATFORM][MONITORED_NETWORKS][network_id] = network
hass.async_create_task(network.async_refresh())
async_track_time_interval(hass, network.async_refresh, SCAN_INTERVAL)
else:
network = hass.data[PLATFORM][MONITORED_NETWORKS][network_id]
await network.ready.wait()
devices = []
for station in network.stations:
dist = location.distance(latitude, longitude, station[ATTR_LATITUDE],
station[ATTR_LONGITUDE])
station_id = station[ATTR_ID]
station_uid = str(station.get(ATTR_EXTRA, {}).get(ATTR_UID, ""))
if radius > dist or stations_list.intersection(
(station_id, station_uid)):
if name:
uid = "_".join([network.network_id, name, station_id])
else:
uid = "_".join([network.network_id, station_id])
entity_id = async_generate_entity_id(ENTITY_ID_FORMAT,
uid,
hass=hass)
devices.append(CityBikesStation(network, station_id, entity_id))
async_add_entities(devices, True)
def __init__(self, hass, name, latitude, longitude, radius):
"""Initialize the sensor."""
self._session = requests.Session()
self._latitude = latitude
self._longitude = longitude
self._radius = util_distance.convert(
radius, LENGTH_KILOMETERS, LENGTH_METERS)
self._state = 0
self._hass = hass
self._name = name
self._previously_tracked = None
def state(self):
"""Return the state of the sensor."""
if self.device_retrieval_status == "NOT_RECEIVED":
return "NOT_RECEIVED"
if self._unit == LENGTH_KILOMETERS and \
not self._hass.config.units.is_metric:
return round(
distance.convert(self._state, LENGTH_KILOMETERS, LENGTH_MILES))
else:
return self._state
def __init__(self, hass, name, latitude, longitude, radius, include,
exclude):
"""Initialize the Crime Reports sensor."""
self._hass = hass
self._name = name
self._include = include
self._exclude = exclude
radius_kilometers = convert(radius, LENGTH_METERS, LENGTH_KILOMETERS)
self._crimereports = crimereports.CrimeReports((latitude, longitude),
radius_kilometers)
self._attributes = None
self._state = None
self._previous_incidents = set()
def state(self):
if self._id == "lastUpdated":
return dt_util.as_local(self.vehicle.last_updated).isoformat()
value = self.vehicle.get_child_value(self._key)
if value is None:
value = NOT_APPLICABLE
if self._source_unit != self._unit:
value = int(
distance_util.convert(value, self._source_unit, self._unit))
return value
def state(self):
if self._vehicle.last_trip and self._vehicle.last_trip.get(
"tripDetails"):
return round(
distance.convert(
int(
self._vehicle.last_trip.get("tripDetails",
"{}").get("distance")),
LENGTH_METERS,
self._units,
))
else:
return 0
async def async_setup_platform(hass, config, async_add_entities,
discovery_info=None):
"""Set up the CityBikes platform."""
if PLATFORM not in hass.data:
hass.data[PLATFORM] = {MONITORED_NETWORKS: {}}
latitude = config.get(CONF_LATITUDE, hass.config.latitude)
longitude = config.get(CONF_LONGITUDE, hass.config.longitude)
network_id = config.get(CONF_NETWORK)
stations_list = set(config.get(CONF_STATIONS_LIST, []))
radius = config.get(CONF_RADIUS, 0)
name = config[CONF_NAME]
if not hass.config.units.is_metric:
radius = distance.convert(radius, LENGTH_FEET, LENGTH_METERS)
# Create a single instance of CityBikesNetworks.
networks = hass.data.setdefault(
CITYBIKES_NETWORKS, CityBikesNetworks(hass))
if not network_id:
network_id = await networks.get_closest_network_id(latitude, longitude)
if network_id not in hass.data[PLATFORM][MONITORED_NETWORKS]:
network = CityBikesNetwork(hass, network_id)
hass.data[PLATFORM][MONITORED_NETWORKS][network_id] = network
hass.async_create_task(network.async_refresh())
async_track_time_interval(hass, network.async_refresh, SCAN_INTERVAL)
else:
network = hass.data[PLATFORM][MONITORED_NETWORKS][network_id]
await network.ready.wait()
devices = []
for station in network.stations:
dist = location.distance(
latitude, longitude, station[ATTR_LATITUDE],
station[ATTR_LONGITUDE])
station_id = station[ATTR_ID]
station_uid = str(station.get(ATTR_EXTRA, {}).get(ATTR_UID, ''))
if radius > dist or stations_list.intersection(
(station_id, station_uid)):
if name:
uid = "_".join([network.network_id, name, station_id])
else:
uid = "_".join([network.network_id, station_id])
entity_id = async_generate_entity_id(
ENTITY_ID_FORMAT, uid, hass=hass)
devices.append(CityBikesStation(network, station_id, entity_id))
async_add_entities(devices, True)
def __init__(self, hass, name, latitude, longitude, radius,
include, exclude):
"""Initialize the Crime Reports sensor."""
import crimereports
self._hass = hass
self._name = name
self._include = include
self._exclude = exclude
radius_kilometers = convert(radius, LENGTH_METERS, LENGTH_KILOMETERS)
self._crimereports = crimereports.CrimeReports(
(latitude, longitude), radius_kilometers)
self._attributes = None
self._state = None
self._previous_incidents = set()
def state(self) -> float | None:
"""Return the state of the sensor."""
if self.tesla_device.type == "temperature sensor":
if self.type == "outside":
return self.tesla_device.get_outside_temp()
return self.tesla_device.get_inside_temp()
if self.tesla_device.type in ("range sensor", "mileage sensor"):
units = self.tesla_device.measurement
if units == "LENGTH_MILES":
return self.tesla_device.get_value()
return round(
convert(self.tesla_device.get_value(), LENGTH_MILES, LENGTH_KILOMETERS),
2,
)
if self.tesla_device.type == "charging rate sensor":
return self.tesla_device.charging_rate
return self.tesla_device.get_value()
def extra_state_attributes(self):
attrs = {}
if self._vehicle.last_trip:
t = self._vehicle.last_trip.get("tripDetails")
if t:
attrs["start"] = self.to_local_datetime(t.get("startTime"))
attrs["origin_latitude"] = t.get("startPosition").get(
"latitude")
attrs["origin_longitude"] = t.get("startPosition").get(
"longitude")
attrs["origin"] = t.get("startPosition").get("address")
attrs["end"] = self.to_local_datetime(t.get("endTime"))
attrs["destination_latitude"] = t.get("endPosition").get(
"latitude")
attrs["destination_longitude"] = t.get("endPosition").get(
"longitude")
attrs["destination"] = t.get("endPosition").get("address")
if t.get("totalEcoScore"):
attrs["eco_score"] = t.get("totalEcoScore").get("score", 0)
attrs["average_speed"] = round(
distance.convert(
int(t.get("averageSpeed", 0)),
LENGTH_KILOMETERS,
self._units,
))
if self._fuel == FUEL_TYPE_BATTERY:
avg_consumption = t.get("averageEnergyConsumption", 0)
if not avg_consumption:
avg_consumption = 0
attrs["average_consumption"] = round(avg_consumption, 1)
else:
if self._units == LENGTH_KILOMETERS:
attrs["average_consumption"] = round(
t.get("averageFuelConsumption", 0), 1)
else:
attrs["average_consumption"] = round(
int(t.get("averageFuelConsumption", 0)) * 2.35215,
1)
return attrs
def async_setup_platform(hass, config, async_add_devices,
discovery_info=None):
"""Set up the CityBikes platform."""
if DOMAIN not in hass.data:
hass.data[DOMAIN] = {MONITORED_NETWORKS: {}}
latitude = config.get(CONF_LATITUDE, hass.config.latitude)
longitude = config.get(CONF_LONGITUDE, hass.config.longitude)
network_id = config.get(CONF_NETWORK)
stations_list = set(config.get(CONF_STATIONS_LIST, []))
radius = config.get(CONF_RADIUS, 0)
name = config.get(CONF_NAME)
if not hass.config.units.is_metric:
radius = distance.convert(radius, LENGTH_FEET, LENGTH_METERS)
if not network_id:
network_id = yield from CityBikesNetwork.get_closest_network_id(
hass, latitude, longitude)
if network_id not in hass.data[DOMAIN][MONITORED_NETWORKS]:
network = CityBikesNetwork(hass, network_id)
hass.data[DOMAIN][MONITORED_NETWORKS][network_id] = network
hass.async_add_job(network.async_refresh)
async_track_time_interval(hass, network.async_refresh,
SCAN_INTERVAL)
else:
network = hass.data[DOMAIN][MONITORED_NETWORKS][network_id]
yield from network.ready.wait()
devices = []
for station in network.stations:
dist = location.distance(latitude, longitude,
station[ATTR_LATITUDE],
station[ATTR_LONGITUDE])
station_id = station[ATTR_ID]
station_uid = str(station.get(ATTR_EXTRA, {}).get(ATTR_UID, ''))
if radius > dist or stations_list.intersection((station_id,
station_uid)):
devices.append(CityBikesStation(network, station_id, name))
async_add_devices(devices, True)
def test_convert_nonnumeric_value(self):
"""Test exception is thrown for nonnumeric type."""
with self.assertRaises(TypeError):
distance_util.convert('a', LENGTH_KILOMETERS, LENGTH_METERS)
def check_proximity_state_change(self, entity, old_state, new_state):
"""Function to perform the proximity checking."""
entity_name = new_state.name
devices_to_calculate = False
devices_in_zone = ''
zone_state = self.hass.states.get(self.proximity_zone)
proximity_latitude = zone_state.attributes.get('latitude')
proximity_longitude = zone_state.attributes.get('longitude')
# Check for devices in the monitored zone.
for device in self.proximity_devices:
device_state = self.hass.states.get(device)
if device_state.state not in self.ignored_zones:
devices_to_calculate = True
# Check the location of all devices.
if (device_state.state).lower() == (self.friendly_name).lower():
device_friendly = device_state.name
if devices_in_zone != '':
devices_in_zone = devices_in_zone + ', '
devices_in_zone = devices_in_zone + device_friendly
# No-one to track so reset the entity.
if not devices_to_calculate:
self.dist_to = 'not set'
self.dir_of_travel = 'not set'
self.nearest = 'not set'
self.update_ha_state()
return
# At least one device is in the monitored zone so update the entity.
if devices_in_zone != '':
self.dist_to = 0
self.dir_of_travel = 'arrived'
self.nearest = devices_in_zone
self.update_ha_state()
return
# We can't check proximity because latitude and longitude don't exist.
if 'latitude' not in new_state.attributes:
return
# Collect distances to the zone for all devices.
distances_to_zone = {}
for device in self.proximity_devices:
# Ignore devices in an ignored zone.
device_state = self.hass.states.get(device)
if device_state.state in self.ignored_zones:
continue
# Ignore devices if proximity cannot be calculated.
if 'latitude' not in device_state.attributes:
continue
# Calculate the distance to the proximity zone.
dist_to_zone = distance(proximity_latitude,
proximity_longitude,
device_state.attributes['latitude'],
device_state.attributes['longitude'])
# Add the device and distance to a dictionary.
distances_to_zone[device] = round(
convert(dist_to_zone, 'm', self.unit_of_measurement), 1)
# Loop through each of the distances collected and work out the
# closest.
closest_device = None # type: str
dist_to_zone = None # type: float
for device in distances_to_zone:
if not dist_to_zone or distances_to_zone[device] < dist_to_zone:
closest_device = device
dist_to_zone = distances_to_zone[device]
# If the closest device is one of the other devices.
if closest_device != entity:
self.dist_to = round(distances_to_zone[closest_device])
self.dir_of_travel = 'unknown'
device_state = self.hass.states.get(closest_device)
self.nearest = device_state.name
self.update_ha_state()
return
# Stop if we cannot calculate the direction of travel (i.e. we don't
# have a previous state and a current LAT and LONG).
if old_state is None or 'latitude' not in old_state.attributes:
self.dist_to = round(distances_to_zone[entity])
self.dir_of_travel = 'unknown'
self.nearest = entity_name
self.update_ha_state()
return
# Reset the variables
distance_travelled = 0
# Calculate the distance travelled.
old_distance = distance(proximity_latitude, proximity_longitude,
old_state.attributes['latitude'],
old_state.attributes['longitude'])
new_distance = distance(proximity_latitude, proximity_longitude,
new_state.attributes['latitude'],
new_state.attributes['longitude'])
distance_travelled = round(new_distance - old_distance, 1)
# Check for tolerance
if distance_travelled < self.tolerance * -1:
direction_of_travel = 'towards'
elif distance_travelled > self.tolerance:
direction_of_travel = 'away_from'
else:
direction_of_travel = 'stationary'
# Update the proximity entity
self.dist_to = round(dist_to_zone)
self.dir_of_travel = direction_of_travel
self.nearest = entity_name
self.update_ha_state()
_LOGGER.debug('proximity.%s update entity: distance=%s: direction=%s: '
'device=%s', self.friendly_name, round(dist_to_zone),
direction_of_travel, entity_name)
_LOGGER.info('%s: proximity calculation complete', entity_name)
