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_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 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)