def __init__(self, device, config, device_info, hass, main_mi_type): GenericMiotDevice.__init__(self, device, config, device_info, hass, main_mi_type) self._current_position = None self._target_position = None self._action = None self._throttle1 = Throttle(timedelta(seconds=1))(self._async_update) self._throttle10 = Throttle(timedelta(seconds=10))(self._async_update) self.async_update = self._throttle10
def __init__(self, device, config, device_info, hass): GenericMiotDevice.__init__(self, device, config, device_info, hass) self._current_position = None self._target_position = None self._action = None # self._hass = hass # self._cloud = config.get(CONF_CLOUD) self._throttle1 = Throttle(timedelta(seconds=1))(self._async_update) self._throttle10 = Throttle(timedelta(seconds=10))(self._async_update) self.async_update = self._throttle10
def __init__(self, name, interval, exceptions=None, inc_counter=1): self.__name = name self.__update_timestamp = datetime.today() self.__service_counter = 0 self.__inc_counter = inc_counter self.__interval = interval self.__exceptions = exceptions self.__throttle_user_update = Throttle(interval)(self._user_update) self.__throttle_update = Throttle(timedelta(seconds=300))( self.__update_controller)
def __init__(self, session, interval): """Set up the headline sensor.""" self._session = session self._state = None self._data = {} # TODO: decorate with throttle instead self.update = Throttle(interval)(self._update)
def __init__(self, sensor_class: str, measurement_unit: str, device_method_or_property: str, device: BaseDevice, channel: int = 0): # Make sure the given device supports exposes the device_method_or_property passed as arg if not hasattr(device, device_method_or_property): _LOGGER.error( f"The device {device.uuid} ({device.name}) does not expose property {device_method_or_property}" ) raise ValueError( f"The device {device} does not expose property {device_method_or_property}" ) self._device = device self._channel_id = channel self._sensor_class = sensor_class self._device_method_or_property = device_method_or_property self._measurement_unit = measurement_unit # Each Meross Device might expose m_sensor_async_updateore than 1 sensor. In this case, we cannot rely only on the # uuid value to uniquely identify a sensor wrapper. self._id = calculate_sensor_id(uuid=device.internal_id, type=sensor_class, measurement_unit=measurement_unit, channel=channel) self._entity_name = "{} ({}) - {} ({}, {})".format( device.name, device.type, f"{sensor_class} sensor", measurement_unit, channel) # by default, set the scan_interval to the default value self.async_update = Throttle(SCAN_INTERVAL)(self._sensor_async_update)
def __init__(self, hass, istat, scan_interval, warnings): self._hass = hass self._istat = istat self._warnings = warnings self.dpc_output = None self.newlink = None self.async_update = Throttle(scan_interval)(self.async_update)
def __init__(self, miner_address, local_currency, update_frequency, id_name, name_override): self.data = None self.miner_address = miner_address self.local_currency = local_currency self.update = Throttle(update_frequency)(self._update) if name_override: self._name = SENSOR_PREFIX + name_override else: self._name = SENSOR_PREFIX + (id_name + " " if len(id_name) > 0 else "") + miner_address self._icon = "mdi:ethereum" self._state = None self._active_workers = None self._current_hashrate = None self._invalid_shares = None self._last_update = None self._reported_hashrate = None self._stale_shares = None self._unpaid = None self._valid_shares = None self._unit_of_measurement = "\u200b" self._start_block = None self._end_block = None self._amount = None self._txhash = None self._paid_on = None self._average_hashrate_24h = None self._single_coin_in_local_currency = None self._unpaid_in_local_currency = None self._coins_per_minute = None self._current_hashrate_mh_sec = None
def __init__(self, device, scan_interval, thermostat_id, zone): """Initialize the thermostat.""" self._device = device self._thermostat_id = thermostat_id self._zone = zone self._scan_interval = scan_interval self.update = Throttle(scan_interval)(self._update)
def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Aria2c sensors.""" name = config.get(CONF_NAME) host = config.get(CONF_HOST) port = config.get(CONF_PORT) token = config.get(CONF_TOKEN) try: aria2c_api = Aria2cHomeassistant( host, port=port, token=token) aria2c_api.getVer() except ConnectionError as error: _LOGGER.error( "Connection to Aria2c API failed on %s:%s with message %s", host, port, error.original ) return False # pylint: disable=global-statement global _THROTTLED_REFRESH _THROTTLED_REFRESH = Throttle(timedelta(seconds=1))( aria2c_api.getVer) dev = [] for variable in config[CONF_MONITORED_VARIABLES]: dev.append(Aria2cSensor(variable, aria2c_api, name)) add_devices(dev)
def __init__(self, api_key, latitude, longitude, units, realtime_fields, forecast_fields, forecast_mode, forecast_observations, interval): """Initialize the data object.""" self._api_key = api_key self.latitude = latitude self.longitude = longitude self.units = units self.realtime_fields = realtime_fields self.forecast_fields = forecast_fields self.forecast_mode = forecast_mode self.forecast_observations = forecast_observations self.realtime_data = None self.forecast_data = None self.unit_system = None self.data_currently = None self.data_minutely = None self.data_hourly = None self.data_daily = None self.data_alerts = None self._headers = { 'Content-Type': 'application/json', # 'Content-Type': 'application/json; charset=utf-8', 'apikey': api_key, # 'X-Real-Ip': ip } self._params = 'lat=' + str(latitude) + '&lon=' + str( longitude) + '&unit_system=' + units # Apply throttling to methods using configured interval self.update = Throttle(interval)(self._update)
def __init__(self, token, scan_interval): """Initialise of the TeslaFi device.""" _LOGGER.debug("Initialising TeslaFi API") self._baseurl = 'https://www.teslafi.com' self._api_actual = '/feed.php?token=' + token self._api_last = '/feed.php?command=lastGood&token=' + token self._api_command = '&command=' self._scan_interval = scan_interval self._id = None self._vehicle_id = None self._display_name = None self._vin = None self._was_online = True self._update() self.update = Throttle(self._scan_interval)(self._update) if self.is_online(): dataId = self._data else: dataId = self._last_data self._id = dataId['id'] self._vehicle_id = dataId['vehicle_id'] self._display_name = dataId['display_name'].replace(" ", "").lower() self._vin = dataId['vin'] _LOGGER.debug("TeslaFi API Initialized")
def __init__(self, device, variable, variable_info, api, interval): """Initialize the Real Time Sensor.""" super().__init__(device, variable, variable_info) self.site_id = self._device['id'] self.api = api self.result = None self.update = Throttle(interval)(self.update)
def __init__(self, session, name, interval): """Initialize the sensor.""" self._session = session self._name = name self._attributes = None self._state = None self.update = Throttle(interval)(self._update)
def __init__(self, hass, config): """Initialize the data object.""" self._hass = hass self._entity_id = config.get(CONF_ENTITY_ID) self._data = None self.update = Throttle(timedelta(seconds=5))(self.update)
def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Transmission sensors.""" import transmissionrpc from transmissionrpc.error import TransmissionError name = config.get(CONF_NAME) host = config.get(CONF_HOST) username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) port = config.get(CONF_PORT) transmission_api = transmissionrpc.Client(host, port=port, user=username, password=password) try: transmission_api.session_stats() except TransmissionError: _LOGGER.exception("Connection to Transmission API failed") return False # pylint: disable=global-statement global _THROTTLED_REFRESH _THROTTLED_REFRESH = Throttle(timedelta(seconds=1))( transmission_api.session_stats) dev = [] for variable in config[CONF_MONITORED_VARIABLES]: dev.append(TransmissionSensor(variable, transmission_api, name)) add_devices(dev)
def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the SABnzbd sensors.""" from pysabnzbd import SabnzbdApi, SabnzbdApiException host = config.get(CONF_HOST) port = config.get(CONF_PORT) name = config.get(CONF_NAME) api_key = config.get(CONF_API_KEY) monitored_types = config.get(CONF_MONITORED_VARIABLES) base_url = "http://{}:{}/".format(host, port) sab_api = SabnzbdApi(base_url, api_key) try: sab_api.check_available() except SabnzbdApiException: _LOGGER.exception("Connection to SABnzbd API failed") return False # pylint: disable=global-statement global _THROTTLED_REFRESH _THROTTLED_REFRESH = Throttle(MIN_TIME_BETWEEN_UPDATES)( sab_api.refresh_queue) devices = [] for variable in monitored_types: devices.append(SabnzbdSensor(variable, sab_api, name)) add_devices(devices)
def __init__(self, hass, min_colortemp, max_colortemp, sunrise_offset, sunset_offset, sunrise_time, sunset_time, latitude, longitude, elevation, interval, transition): self.hass = hass self.data = {} self.data['min_colortemp'] = min_colortemp self.data['max_colortemp'] = max_colortemp self.data['sunrise_offset'] = sunrise_offset self.data['sunset_offset'] = sunset_offset self.data['sunrise_time'] = sunrise_time self.data['sunset_time'] = sunset_time self.data['latitude'] = latitude self.data['longitude'] = longitude self.data['elevation'] = elevation self.data['interval'] = interval self.data['transition'] = transition self.data['percent'] = self.calc_percent() self.data['colortemp'] = self.calc_colortemp() self.data['rgb_color'] = self.calc_rgb() self.data['xy_color'] = self.calc_xy() self.data['hs_color'] = self.calc_hs() self.update = Throttle(timedelta(seconds=interval))(self._update) if self.data['sunrise_time'] is not None: track_time_change(self.hass, self._update, hour=int(self.data['sunrise_time'].strftime("%H")), minute=int(self.data['sunrise_time'].strftime("%M")), second=int(self.data['sunrise_time'].strftime("%S"))) else: track_sunrise(self.hass, self._update, self.data['sunrise_offset']) if self.data['sunset_time'] is not None: track_time_change(self.hass, self._update, hour=int(self.data['sunset_time'].strftime("%H")), minute=int(self.data['sunset_time'].strftime("%M")), second=int(self.data['sunset_time'].strftime("%S"))) else: track_sunset(self.hass, self._update, self.data['sunset_offset'])
def __init__(self, client, uuid, throttle): """Initialize the data object.""" self._client = client self._uuid = uuid self.data = {} self.attrs = {} self.async_update = Throttle(throttle)(self._async_update)
def __init__(self, hass, api, host): """Initialize the data object.""" self.api = api self.hass = hass self.host = host self.update = Throttle(SCAN_INTERVAL)(self._update) self.data = {}
def setup_platform(hass, config, add_devices, discovery_info=None): """ Sets up the SABnzbd sensors. """ from pysabnzbd import SabnzbdApi, SabnzbdApiException api_key = config.get("api_key") base_url = config.get("base_url") name = config.get("name", "SABnzbd") if not base_url: _LOGGER.error('Missing config variable base_url') return False if not api_key: _LOGGER.error('Missing config variable api_key') return False sab_api = SabnzbdApi(base_url, api_key) try: sab_api.check_available() except SabnzbdApiException: _LOGGER.exception("Connection to SABnzbd API failed.") return False # pylint: disable=global-statement global _THROTTLED_REFRESH _THROTTLED_REFRESH = Throttle(timedelta(seconds=1))(sab_api.refresh_queue) dev = [] for variable in config['monitored_variables']: if variable['type'] not in SENSOR_TYPES: _LOGGER.error('Sensor type: "%s" does not exist', variable['type']) else: dev.append(SabnzbdSensor(variable['type'], sab_api, name)) add_devices(dev)
def __init__(self, name, carrier, interval): """Initialize the sensor.""" self._carrier = carrier self._name = name self._attributes = None self._state = None self.update = Throttle(interval)(self._update)
def __init__(self, hass, config): """Initialize the data object.""" self._host = config.get(CONF_HOST) self._port = config.get(CONF_PORT) self._folder = config.get(CONF_FOLDER) self._user = config.get(CONF_USERNAME) self._pwd = config.get(CONF_PASSWORD) self._img_out_path = config.get(CONF_PATH) self._gif_duration = config.get(CONF_DURATION) self._image_security = config.get(CONF_IMAGE_SECURITY) self._scan_interval = timedelta(minutes=config.get(CONF_SCAN_INTERVAL)) self._fedex_delivered = None self._fedex_delivering = None self._fedex_packages = None self._ups_packages = None self._ups_delivering = None self._ups_delivered = None self._usps_packages = None self._usps_delivering = None self._usps_delivered = None self._usps_mail = None self._packages_delivered = None self._packages_transit = None self._amazon_packages = None self._amazon_items = None self._image_name = None _LOGGER.debug("Config scan interval: %s", self._scan_interval) self.update = Throttle(self._scan_interval)(self.update)
def setup(hass, config): """Set up the Verisure component.""" import verisure global HUB HUB = VerisureHub(config[DOMAIN], verisure) HUB.update_overview = Throttle( config[DOMAIN][CONF_SCAN_INTERVAL])(HUB.update_overview) if not HUB.login(): return False hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, lambda event: HUB.logout()) HUB.update_overview() for component in ('sensor', 'switch', 'alarm_control_panel', 'lock', 'camera', 'binary_sensor'): discovery.load_platform(hass, component, DOMAIN, {}, config) def capture_smartcam(service): """Capture a new picture from a smartcam.""" device_id = service.data.get(ATTR_DEVICE_SERIAL) HUB.smartcam_capture(device_id) _LOGGER.debug("Capturing new image from %s", ATTR_DEVICE_SERIAL) hass.services.register(DOMAIN, SERVICE_CAPTURE_SMARTCAM, capture_smartcam, schema=CAPTURE_IMAGE_SCHEMA) return True
def __init__(self, hass, coordinator: LockManagerCoordinator): """Initialize the data object.""" self._hass = hass self._errors = 0 self._enabled = False self.update = Throttle(timedelta(seconds=30))(self.update) self._coordinator = coordinator
def __init__(self, host, scan_interval): """Initialize the inverter.""" self._host = host self._scan_interval = scan_interval self.result = None # Throttle the update method. self.update = Throttle(self._scan_interval)(self._update)
def __init__(self, session, interval): """Initialize the sensor.""" import myusps self._session = session self._profile = myusps.get_profile(session) self._packages = None self.update = Throttle(interval)(self._update) self.update()
def __init__(self, api, device, billing_type, interval): """Initialize the Billing API wrapper class.""" self.api = api self.site_id = device['id'] self.timezone = device['timezone'] self.type = billing_type self.result = None self.update = Throttle(interval)(self.update)
def __init__(self, zoneid, event_urgency, event_severity, latitude, longitude, interval): self._zoneid = zoneid self.latitude = latitude self.longitude = longitude self._event_urgency = event_urgency self._event_severity = event_severity self.update = Throttle(interval)(self._update)
def __init__(self, api_key, spot_id, units): """Initialize the data object.""" self._msw = magicseaweed.MSW_Forecast(api_key, spot_id, None, units) self.currently = None self.hourly = {} # Apply throttling to methods using configured interval self.update = Throttle(MIN_TIME_BETWEEN_UPDATES)(self._update)
def __init__(self, x, y, radius, api_key, scan_interval): self._x = x self._y = y self._radius = radius self._api_key = api_key self.szukaj_burzy_output = None self.ostrzezenia_pogodowe_output = None self.async_update = Throttle(scan_interval)(self._async_update)