Black auto-update

Author: CoMPaTech

plugwise_usb/__init__.py

@@ -538,8 +538,7 @@ def _pass_message_to_node(self, message, mac, discover=True):
         return False
 
     def _watchdog_loop(self):
-        """Main worker loop to watch all other worker threads
-        """
+        """Main worker loop to watch all other worker threads"""
         time.sleep(5)
         circle_plus_retry_counter = 0
         while self._run_watchdog:

plugwise_usb/controller.py

@@ -327,7 +327,7 @@ def _post_message_action(self, seq_id, ack_response=None, request="unknown"):
                         request,
                         str(seq_id),
                     )
-                    #Still save it to try and get it back into sync
+                    # Still save it to try and get it back into sync
                     self.last_seq_id = seq_id
         if resend_request:
             self.resend(seq_id)

plugwise_usb/messages/responses.py

@@ -23,8 +23,7 @@
 
 
 class NodeResponse(PlugwiseMessage):
-    """Base class for response messages received by USB-Stick.
-    """
+    """Base class for response messages received by USB-Stick."""
 
     def __init__(self, format_size=None):
         super().__init__()
@@ -561,8 +560,7 @@ def __init__(self):
 
 
 def get_message_response(message_id, length, seq_id):
-    """Return message class based on sequence ID, Length of message or message ID.
-    """
+    """Return message class based on sequence ID, Length of message or message ID."""
     # First check for known sequence ID's
     if seq_id == b"FFFD":
         return NodeJoinAckResponse()

plugwise_usb/nodes/circle.py

@@ -221,28 +221,31 @@ def request_power_update(self, callback=None):
             if self._energy_last_collected_timestamp < _timestamp_utcnow.replace(
                 minute=0, second=0, microsecond=0
             ):
-                _LOGGER.info("Queue _last_log_address for %s at %s last_collected %s",
-                              str(self.mac),str(self._last_log_address),
-                             self._energy_last_collected_timestamp
+                _LOGGER.info(
+                    "Queue _last_log_address for %s at %s last_collected %s",
+                    str(self.mac),
+                    str(self._last_log_address),
+                    self._energy_last_collected_timestamp,
                 )
                 self._request_info(self.push_last_log_address)
 
             if len(self._energy_history_failed_address) > 0:
-                    _mem_address = self._energy_history_failed_address.pop(0)
-                    if self._energy_memory.get(_mem_address, 0) < 4:
-                        _LOGGER.info("Collect EnergyCounters for %s at %s",
-                                     str(self.mac),
-                                    str(_mem_address),
-                        )
-                        self.request_energy_counters(_mem_address)
-                        self._energy_ratelimit_collection_timestamp = _timestamp_utcnow
-                    else:
-                        _LOGGER.info(
-                            "Drop known request_energy_counters for %s at %s and clock sync",
-                            str(self.mac),
-                            str(_mem_address),
-                        )
-                        self.get_clock(self.sync_clock)
+                _mem_address = self._energy_history_failed_address.pop(0)
+                if self._energy_memory.get(_mem_address, 0) < 4:
+                    _LOGGER.info(
+                        "Collect EnergyCounters for %s at %s",
+                        str(self.mac),
+                        str(_mem_address),
+                    )
+                    self.request_energy_counters(_mem_address)
+                    self._energy_ratelimit_collection_timestamp = _timestamp_utcnow
+                else:
+                    _LOGGER.info(
+                        "Drop known request_energy_counters for %s at %s and clock sync",
+                        str(self.mac),
+                        str(_mem_address),
+                    )
+                    self.get_clock(self.sync_clock)
             if datetime.now().day != self._last_clock_sync_day:
                 self._last_clock_sync_day = datetime.now().day
                 self.get_clock(self.sync_clock)
@@ -252,8 +255,7 @@ def push_last_log_address(self):
             self._energy_history_failed_address.append(self._last_log_address)
 
     def message_for_circle(self, message):
-        """Process received message
-        """
+        """Process received message"""
         if isinstance(message, CirclePowerUsageResponse):
             if self.calibration:
                 self._response_power_usage(message)
@@ -387,8 +389,7 @@ def _response_calibration(self, message: CircleCalibrationResponse):
         self.calibration = True
 
     def pulses_to_kws(self, pulses, seconds=1):
-        """Converts the amount of pulses to kWs using the calaboration offsets
-        """
+        """Converts the amount of pulses to kWs using the calaboration offsets"""
         if pulses is None:
             return None
         if pulses == 0 or not self.calibration:
@@ -428,7 +429,7 @@ def _collect_energy_pulses(self, start_utc: datetime, end_utc: datetime):
                 )
             else:
                 _mem_address = self._energy_timestamp_memory_address(_log_timestamp)
-                if (_mem_address is not None and _mem_address >= 0):
+                if _mem_address is not None and _mem_address >= 0:
                     _LOGGER.info(
                         "_collect_energy_pulses for %s at %s | %s not found",
                         str(self.mac),
@@ -443,7 +444,6 @@ def _collect_energy_pulses(self, start_utc: datetime, end_utc: datetime):
                         str(_mem_address),
                     )
 
-
         # Validate all history values where present
         if len(self._energy_history_failed_address) == 0:
             return _energy_pulses
@@ -480,12 +480,11 @@ def _update_energy_today_now(self):
             and self._energy_pulses_current_hour is not None
         ):
             _pulses_today_now = (
-                self._energy_pulses_today_hourly
-                + self._energy_pulses_current_hour
+                self._energy_pulses_today_hourly + self._energy_pulses_current_hour
             )
 
         _utc_hour_timestamp = datetime.utcnow().replace(
-                minute=0, second=0, microsecond=0
+            minute=0, second=0, microsecond=0
         )
         _local_hour = datetime.now().hour
         _utc_midnight_timestamp = _utc_hour_timestamp - timedelta(hours=_local_hour)
@@ -500,9 +499,9 @@ def _update_energy_today_now(self):
                     _utc_hour_timestamp,
                 )
         elif (
-             self._energy_pulses_today_now is not None
-             and self._energy_pulses_today_now > _pulses_today_now
-             and self._energy_pulses_midnight_rollover < _local_midnight_timestamp
+            self._energy_pulses_today_now is not None
+            and self._energy_pulses_today_now > _pulses_today_now
+            and self._energy_pulses_midnight_rollover < _local_midnight_timestamp
         ):
             _LOGGER.info(
                 "_update_energy_today_now for %s midnight rollover started old=%s, new=%s",
@@ -518,9 +517,14 @@ def _update_energy_today_now(self):
             )
             self.do_callback(FEATURE_ENERGY_CONSUMPTION_TODAY["id"])
         elif (
-             self._energy_pulses_today_now is not None
-             and self._energy_pulses_today_now > _pulses_today_now
-             and int((self._energy_pulses_today_now-_pulses_today_now)/(self._energy_pulses_today_now+1)*100) > 1
+            self._energy_pulses_today_now is not None
+            and self._energy_pulses_today_now > _pulses_today_now
+            and int(
+                (self._energy_pulses_today_now - _pulses_today_now)
+                / (self._energy_pulses_today_now + 1)
+                * 100
+            )
+            > 1
         ):
             _LOGGER.info(
                 "_update_energy_today_now for %s hour rollover started old=%s, new=%s",
@@ -617,12 +621,14 @@ def _update_energy_today_hourly(self, start_today: datetime, end_today: datetime
     def request_energy_counters(self, log_address=None, callback=None):
         """Request power log of specified address"""
         _LOGGER.debug(
-            "request_energy_counters for %s of address %s", str(self.mac), str(log_address)
+            "request_energy_counters for %s of address %s",
+            str(self.mac),
+            str(log_address),
         )
         if not self._available:
             _LOGGER.debug(
-                    "Skip request_energy_counters for % is unavailable",
-                    str(self.mac),
+                "Skip request_energy_counters for % is unavailable",
+                str(self.mac),
             )
             return
         if log_address is None:
@@ -687,11 +693,12 @@ def _response_energy_counters(self, message: CircleEnergyCountersResponse):
                 message, "pulses%d" % (_slot,)
             ).value
 
-            _LOGGER.info("push _energy_memory for %s address %s slot %s stamp %s",
-                         str(self.mac),
-                         str(message.logaddr.value),
-                         str(_slot),
-                         str(_log_timestamp),
+            _LOGGER.info(
+                "push _energy_memory for %s address %s slot %s stamp %s",
+                str(self.mac),
+                str(message.logaddr.value),
+                str(_slot),
+                str(_log_timestamp),
             )
 
             # Store last populated _slot
@@ -710,9 +717,11 @@ def _response_energy_counters(self, message: CircleEnergyCountersResponse):
                 self._last_collected_address_timestamp = _log_timestamp
 
             # Trigger history rollover
-            _LOGGER.info('history_rollover %s %s %s',str(_log_timestamp),
-                         str(_utc_hour_timestamp),
-                         str(self._energy_last_rollover_timestamp),
+            _LOGGER.info(
+                "history_rollover %s %s %s",
+                str(_log_timestamp),
+                str(_utc_hour_timestamp),
+                str(self._energy_last_rollover_timestamp),
             )
             if (
                 _log_timestamp == _utc_hour_timestamp
@@ -739,7 +748,7 @@ def _response_energy_counters(self, message: CircleEnergyCountersResponse):
                 self._energy_consumption_today_reset = _local_midnight_timestamp
                 _midnight_rollover = True
         if self._energy_last_collected_timestamp == datetime.utcnow().replace(
-                minute=0, second=0, microsecond=0
+            minute=0, second=0, microsecond=0
         ):
             self._update_energy_previous_hour(_utc_hour_timestamp)
             self._update_energy_today_hourly(
@@ -751,24 +760,31 @@ def _response_energy_counters(self, message: CircleEnergyCountersResponse):
                 _utc_midnight_timestamp,
             )
         else:
-            _LOGGER.info("CircleEnergyCounter failed for %s at %s|%s count %s",
-                         str(self.mac),
-                         str(message.logaddr.value),
-                         str(self._last_log_address),
-                         str(self._energy_last_collected_count),
+            _LOGGER.info(
+                "CircleEnergyCounter failed for %s at %s|%s count %s",
+                str(self.mac),
+                str(message.logaddr.value),
+                str(self._last_log_address),
+                str(self._energy_last_collected_count),
             )
-            self._energy_last_collected_count +=1
+            self._energy_last_collected_count += 1
 
             if (
-                    message.logaddr.value == self._last_log_address
-                    and self._energy_last_collected_count > 3
+                message.logaddr.value == self._last_log_address
+                and self._energy_last_collected_count > 3
             ):
-                if self._energy_history_failed_address.count(self._last_log_address-1) == 0:
-                    self._energy_history_failed_address.append(self._last_log_address-1)
+                if (
+                    self._energy_history_failed_address.count(
+                        self._last_log_address - 1
+                    )
+                    == 0
+                ):
+                    self._energy_history_failed_address.append(
+                        self._last_log_address - 1
+                    )
                 _LOGGER.info("Resetting CircleEnergyCounter due to logaddress offset")
 
-
-        # Cleanup energy history for more than 48 hours 
+        # Cleanup energy history for more than 48 hours
         _48_hours_ago = datetime.utcnow().replace(
             minute=0, second=0, microsecond=0
         ) - timedelta(hours=48)
@@ -814,7 +830,6 @@ def set_clock(self, callback=None):
             callback,
         )
 
-
     def sync_clock(self, max_drift=0):
         """Resync clock of node if time has drifted more than MAX_TIME_DRIFT"""
         if self._clock_offset is not None:
@@ -832,7 +847,7 @@ def _energy_timestamp_memory_address(self, utc_timestamp: datetime):
         """Return memory address for given energy counter timestamp"""
         if self._last_collected_address is None:
             return None
-        #Should already be hour timestamp, but just to be sure.
+        # Should already be hour timestamp, but just to be sure.
         _utc_now_timestamp = self._last_collected_address_timestamp.replace(
             minute=0, second=0, microsecond=0
         )
@@ -855,12 +870,13 @@ def _energy_timestamp_memory_address(self, utc_timestamp: datetime):
                 _address -= 1
                 _slot = 4
             _hours += 1
-        _LOGGER.info("Calculated address %s at %s from %s at %s with %s|%s",
-                     _address,
-                     utc_timestamp,
-                     self._last_log_address,
-                     _utc_now_timestamp,
-                     _sslot,
-                     _hours_offset,
+        _LOGGER.info(
+            "Calculated address %s at %s from %s at %s with %s|%s",
+            _address,
+            utc_timestamp,
+            self._last_log_address,
+            _utc_now_timestamp,
+            _sslot,
+            _hours_offset,
         )
         return _address

plugwise_usb/nodes/circle_plus.py

@@ -26,8 +26,7 @@ def __init__(self, mac, address, message_sender):
         self.get_real_time_clock(self.sync_realtime_clock)
 
     def message_for_circle_plus(self, message):
-        """Process received message
-        """
+        """Process received message"""
         if isinstance(message, CirclePlusRealTimeClockResponse):
             self._response_realtime_clock(message)
         elif isinstance(message, CirclePlusScanResponse):

plugwise_usb/nodes/scan.py

@@ -45,8 +45,7 @@ def motion(self) -> bool:
         return self._motion_state
 
     def message_for_scan(self, message):
-        """Process received message
-        """
+        """Process received message"""
         if isinstance(message, NodeSwitchGroupResponse):
             _LOGGER.debug(
                 "Switch group %s to state %s received from %s",

plugwise_usb/nodes/sed.py

@@ -42,8 +42,7 @@ def __init__(self, mac, address, message_sender):
         self._battery_powered = True
 
     def message_for_sed(self, message):
-        """Process received message
-        """
+        """Process received message"""
         if isinstance(message, NodeAwakeResponse):
             self._process_awake_response(message)
         elif isinstance(message, NodeAckLargeResponse):

plugwise_usb/nodes/sense.py

@@ -44,8 +44,7 @@ def temperature(self) -> int:
         return self._temperature
 
     def message_for_sense(self, message):
-        """Process received message
-        """
+        """Process received message"""
         if isinstance(message, SenseReportResponse):
             self._process_sense_report(message)
         else:

plugwise_usb/nodes/switch.py

@@ -27,8 +27,7 @@ def switch(self) -> bool:
         return self._switch_state
 
     def message_for_switch(self, message):
-        """Process received message
-        """
+        """Process received message"""
         if isinstance(message, NodeSwitchGroupResponse):
             _LOGGER.debug(
                 "Switch group request %s received from %s for group id %s",

plugwise_usb/parser.py

@@ -35,17 +35,15 @@ def __init__(self, message_processor):
         self._message = None
 
     def feed(self, data):
-        """Add new incoming data to buffer and try to process
-        """
+        """Add new incoming data to buffer and try to process"""
         _LOGGER.debug("Feed data: %s", str(data))
         self._buffer += data
         if len(self._buffer) >= 8:
             if not self._parsing:
                 self.parse_data()
 
     def next_message(self, message):
-        """Process next packet if present
-        """
+        """Process next packet if present"""
         try:
             self.message_processor(message)
         # TODO: narrow exception
@@ -58,8 +56,7 @@ def next_message(self, message):
             _LOGGER.error(err, exc_info=True)
 
     def parse_data(self):
-        """Process next set of packet data
-        """
+        """Process next set of packet data"""
         _LOGGER.debug("Parse data: %s ", str(self._buffer))
         if not self._parsing:
             self._parsing = True