plugwise 0.27.6__tar.gz → 0.27.7__tar.gz

{plugwise-0.27.6 → plugwise-0.27.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plugwise
-Version: 0.27.6
+Version: 0.27.7
 Summary: Plugwise Smile (Adam/Anna/P1), Stretch and USB (Stick) module for Python 3.
 Home-page: https://github.com/plugwise/python-plugwise
 Author: Plugwise device owners
@@ -37,6 +37,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Home Automation
 Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown

{plugwise-0.27.6 → plugwise-0.27.7}/plugwise/connections/socket.py

@@ -39,15 +39,14 @@ class SocketConnection(StickConnection):
                 err,
             )
             raise PortError(err)
-        else:
-            self._reader_start("socket_reader_thread")
-            self._writer_start("socket_writer_thread")
-            self._is_connected = True
-            _LOGGER.debug(
-                "Successfully connected to host '%s' at port %s",
-                self._socket_host,
-                str(self._socket_port),
-            )
+        self._reader_start("socket_reader_thread")
+        self._writer_start("socket_writer_thread")
+        self._is_connected = True
+        _LOGGER.debug(
+            "Successfully connected to host '%s' at port %s",
+            self._socket_host,
+            str(self._socket_port),
+        )
 
     def _close_connection(self):
         """Close the socket."""
@@ -76,8 +75,7 @@ class SocketConnection(StickConnection):
                 )
                 self._is_connected = False
                 raise PortError(err)
-            else:
-                return socket_data
+            return socket_data
         return None
 
     def _write_data(self, data):

{plugwise-0.27.6 → plugwise-0.27.7}/plugwise/controller.py

@@ -49,6 +49,7 @@ class StickMessageController:
         self.connection = None
         self.discovery_finished = False
         self.expected_responses = {}
+        self.lock_expected_responses = threading.Lock()
         self.init_callback = None
         self.last_seq_id = None
         self.message_processor = message_processor
@@ -151,66 +152,67 @@ class StickMessageController:
     def resend(self, seq_id):
         """Resend message."""
         _mac = "<unknown>"
-        if not self.expected_responses.get(seq_id):
-            _LOGGER.warning(
-                "Cannot resend unknown request %s",
-                str(seq_id),
-            )
-        else:
-            if self.expected_responses[seq_id][0].mac:
-                _mac = self.expected_responses[seq_id][0].mac.decode(UTF8_DECODE)
-            _request = self.expected_responses[seq_id][0].__class__.__name__
+        with self.lock_expected_responses:
+            if not self.expected_responses.get(seq_id):
+                _LOGGER.warning(
+                    "Cannot resend unknown request %s",
+                    str(seq_id),
+                )
+            else:
+                if self.expected_responses[seq_id][0].mac:
+                    _mac = self.expected_responses[seq_id][0].mac.decode(UTF8_DECODE)
+                _request = self.expected_responses[seq_id][0].__class__.__name__
 
-            if self.expected_responses[seq_id][2] == -1:
-                _LOGGER.debug("Drop single %s to %s ", _request, _mac)
-            elif self.expected_responses[seq_id][2] <= MESSAGE_RETRY:
-                if (
-                    isinstance(self.expected_responses[seq_id][0], NodeInfoRequest)
-                    and not self.discovery_finished
-                ):
-                    # Time out for node which is not discovered yet
-                    # to speedup the initial discover phase skip retries and mark node as not discovered.
-                    _LOGGER.debug(
-                        "Skip retry %s to %s to speedup discover process",
-                        _request,
-                        _mac,
-                    )
-                    if self.expected_responses[seq_id][1]:
-                        self.expected_responses[seq_id][1]()
+                if self.expected_responses[seq_id][2] == -1:
+                    _LOGGER.debug("Drop single %s to %s ", _request, _mac)
+                elif self.expected_responses[seq_id][2] <= MESSAGE_RETRY:
+                    if (
+                        isinstance(self.expected_responses[seq_id][0], NodeInfoRequest)
+                        and not self.discovery_finished
+                    ):
+                        # Time out for node which is not discovered yet
+                        # to speedup the initial discover phase skip retries and mark node as not discovered.
+                        _LOGGER.debug(
+                            "Skip retry %s to %s to speedup discover process",
+                            _request,
+                            _mac,
+                        )
+                        if self.expected_responses[seq_id][1]:
+                            self.expected_responses[seq_id][1]()
+                    else:
+                        _LOGGER.info(
+                            "Resend %s for %s, retry %s of %s",
+                            _request,
+                            _mac,
+                            str(self.expected_responses[seq_id][2] + 1),
+                            str(MESSAGE_RETRY + 1),
+                        )
+                        self.send(
+                            self.expected_responses[seq_id][0],
+                            self.expected_responses[seq_id][1],
+                            self.expected_responses[seq_id][2] + 1,
+                        )
                 else:
-                    _LOGGER.info(
-                        "Resend %s for %s, retry %s of %s",
+                    _LOGGER.warning(
+                        "Drop %s to %s because max retries %s reached",
                         _request,
                         _mac,
-                        str(self.expected_responses[seq_id][2] + 1),
                         str(MESSAGE_RETRY + 1),
                     )
-                    self.send(
-                        self.expected_responses[seq_id][0],
-                        self.expected_responses[seq_id][1],
-                        self.expected_responses[seq_id][2] + 1,
-                    )
-            else:
-                _LOGGER.warning(
-                    "Drop %s to %s because max retries %s reached",
-                    _request,
-                    _mac,
-                    str(MESSAGE_RETRY + 1),
-                )
-                # Report node as unavailable for missing NodePingRequest
-                if isinstance(self.expected_responses[seq_id][0], NodePingRequest):
-                    self.node_state(_mac, False)
-                else:
-                    _LOGGER.debug(
-                        "Do a single ping request to %s to validate if node is reachable",
-                        _mac,
-                    )
-                    self.send(
-                        NodePingRequest(self.expected_responses[seq_id][0].mac),
-                        None,
-                        MESSAGE_RETRY + 1,
-                    )
-            del self.expected_responses[seq_id]
+                    # Report node as unavailable for missing NodePingRequest
+                    if isinstance(self.expected_responses[seq_id][0], NodePingRequest):
+                        self.node_state(_mac, False)
+                    else:
+                        _LOGGER.debug(
+                            "Do a single ping request to %s to validate if node is reachable",
+                            _mac,
+                        )
+                        self.send(
+                            NodePingRequest(self.expected_responses[seq_id][0].mac),
+                            None,
+                            MESSAGE_RETRY + 1,
+                        )
+                del self.expected_responses[seq_id]
 
     def _send_message_loop(self):
         """Daemon to send messages waiting in queue."""
@@ -225,28 +227,26 @@ class StickMessageController:
                 # Calc next seq_id based last received ack message
                 # if previous seq_id is unknown use fake b"0000"
                 seq_id = inc_seq_id(self.last_seq_id)
-                self.expected_responses[seq_id] = request_set
-                mac = "None"
-                if hasattr(self.expected_responses[seq_id][0], "mac"):
-                    mac = self.expected_responses[seq_id][0].mac
-                if self.expected_responses[seq_id][2] == 0:
-                    _LOGGER.info(
-                        "Send %s to %s using seq_id %s",
-                        self.expected_responses[seq_id][0].__class__.__name__,
-                        mac,
-                        str(seq_id),
-                    )
-                else:
-                    _LOGGER.info(
-                        "Resend %s to %s using seq_id %s, retry %s",
-                        self.expected_responses[seq_id][0].__class__.__name__,
-                        mac,
-                        str(seq_id),
-                        str(self.expected_responses[seq_id][2]),
-                    )
-                self.expected_responses[seq_id][3] = datetime.now()
-                # Send request
-                self.connection.send(self.expected_responses[seq_id][0])
+                with self.lock_expected_responses:
+                    self.expected_responses[seq_id] = request_set
+                    if self.expected_responses[seq_id][2] == 0:
+                        _LOGGER.info(
+                            "Send %s to %s using seq_id %s",
+                            self.expected_responses[seq_id][0].__class__.__name__,
+                            self.expected_responses[seq_id][0].mac,
+                            str(seq_id),
+                        )
+                    else:
+                        _LOGGER.info(
+                            "Resend %s to %s using seq_id %s, retry %s",
+                            self.expected_responses[seq_id][0].__class__.__name__,
+                            self.expected_responses[seq_id][0].mac,
+                            str(seq_id),
+                            str(self.expected_responses[seq_id][2]),
+                        )
+                    self.expected_responses[seq_id][3] = datetime.now()
+                    # Send request
+                    self.connection.send(self.expected_responses[seq_id][0])
                 time.sleep(SLEEP_TIME)
                 timeout_counter = 0
                 # Wait max 1 second for acknowledge response from USB-stick
@@ -289,63 +289,71 @@ class StickMessageController:
                 )
 
     def _post_message_action(self, seq_id, ack_response=None, request="unknown"):
-        """Execute action if request has been successful.."""
-        if seq_id in self.expected_responses:
-            if ack_response in (*REQUEST_SUCCESS, None):
-                if self.expected_responses[seq_id][1]:
-                    _LOGGER.debug(
-                        "Execute action %s of request with seq_id %s",
-                        self.expected_responses[seq_id][1].__name__,
-                        str(seq_id),
-                    )
-                    try:
-                        self.expected_responses[seq_id][1]()
-                    # TODO: narrow exception
-                    except Exception as err:  # pylint: disable=broad-except
-                        _LOGGER.error(
-                            "Execution of  %s for request with seq_id %s failed: %s",
+        """Execute action if request has been successful."""
+        resend_request = False
+        with self.lock_expected_responses:
+            if seq_id in self.expected_responses:
+                if ack_response in (*REQUEST_SUCCESS, None):
+                    if self.expected_responses[seq_id][1]:
+                        _LOGGER.debug(
+                            "Execute action %s of request with seq_id %s",
                             self.expected_responses[seq_id][1].__name__,
                             str(seq_id),
-                            err,
                         )
-                del self.expected_responses[seq_id]
-            elif ack_response in REQUEST_FAILED:
-                self.resend(seq_id)
-        else:
-            if not self.last_seq_id:
-                if b"0000" in self.expected_responses:
-                    self.expected_responses[seq_id] = self.expected_responses[b"0000"]
-                    del self.expected_responses[b"0000"]
-                self.last_seq_id = seq_id
+                        try:
+                            self.expected_responses[seq_id][1]()
+                        # TODO: narrow exception
+                        except Exception as err:  # pylint: disable=broad-except
+                            _LOGGER.error(
+                                "Execution of  %s for request with seq_id %s failed: %s",
+                                self.expected_responses[seq_id][1].__name__,
+                                str(seq_id),
+                                err,
+                            )
+                    del self.expected_responses[seq_id]
+                elif ack_response in REQUEST_FAILED:
+                    resend_request = True
             else:
-                _LOGGER.info(
-                    "Drop unexpected %s%s using seq_id %s",
-                    STATUS_RESPONSES.get(ack_response, "") + " ",
-                    request,
-                    str(seq_id),
-                )
+                if not self.last_seq_id:
+                    if b"0000" in self.expected_responses:
+                        self.expected_responses[seq_id] = self.expected_responses[
+                            b"0000"
+                        ]
+                        del self.expected_responses[b"0000"]
+                    self.last_seq_id = seq_id
+                else:
+                    _LOGGER.info(
+                        "Drop unexpected %s%s using seq_id %s",
+                        STATUS_RESPONSES.get(ack_response, "") + " ",
+                        request,
+                        str(seq_id),
+                    )
+        if resend_request:
+            self.resend(seq_id)
 
     def _receive_timeout_loop(self):
         """Daemon to time out open requests without any (n)ack response message."""
         while self._receive_timeout_thread_state:
-            for seq_id in list(self.expected_responses.keys()):
-                if self.expected_responses[seq_id][3] is not None:
-                    if self.expected_responses[seq_id][3] < (
-                        datetime.now() - timedelta(seconds=MESSAGE_TIME_OUT)
-                    ):
-                        _mac = "<unknown>"
-                        if self.expected_responses[seq_id][0].mac:
-                            _mac = self.expected_responses[seq_id][0].mac.decode(
-                                UTF8_DECODE
+            resend_list = []
+            with self.lock_expected_responses:
+                for seq_id in list(self.expected_responses.keys()):
+                    if self.expected_responses[seq_id][3] is not None:
+                        if self.expected_responses[seq_id][3] < (
+                            datetime.now() - timedelta(seconds=MESSAGE_TIME_OUT)
+                        ):
+                            _mac = "<unknown>"
+                            if self.expected_responses[seq_id][0].mac:
+                                _mac = self.expected_responses[seq_id][0].mac
+                            _LOGGER.info(
+                                "No response within %s seconds timeout for %s to %s with sequence ID %s",
+                                str(MESSAGE_TIME_OUT),
+                                self.expected_responses[seq_id][0].__class__.__name__,
+                                _mac,
+                                str(seq_id),
                             )
-                        _LOGGER.info(
-                            "No response within %s seconds timeout for %s to %s with sequence ID %s",
-                            str(MESSAGE_TIME_OUT),
-                            self.expected_responses[seq_id][0].__class__.__name__,
-                            _mac,
-                            str(seq_id),
-                        )
-                        self.resend(seq_id)
+                            resend_list.append(seq_id)
+            for seq_id in resend_list:
+                self.resend(seq_id)
             receive_timeout_checker = 0
             while (
                 receive_timeout_checker < MESSAGE_TIME_OUT
@@ -366,25 +374,26 @@ class StickMessageController:
                     str(message.seq_id),
                 )
             else:
-                if self.expected_responses.get(message.seq_id):
-                    _LOGGER.warning(
-                        "Received unmanaged (%s) %s in response to %s with seq_id %s",
-                        str(status),
-                        message.__class__.__name__,
-                        str(
-                            self.expected_responses[message.seq_id][
-                                1
-                            ].__class__.__name__
-                        ),
-                        str(message.seq_id),
-                    )
-                else:
-                    _LOGGER.warning(
-                        "Received unmanaged (%s) %s for unknown request with seq_id %s",
-                        str(status),
-                        message.__class__.__name__,
-                        str(message.seq_id),
-                    )
+                with self.lock_expected_responses:
+                    if self.expected_responses.get(message.seq_id):
+                        _LOGGER.warning(
+                            "Received unmanaged (%s) %s in response to %s with seq_id %s",
+                            str(status),
+                            message.__class__.__name__,
+                            str(
+                                self.expected_responses[message.seq_id][
+                                    1
+                                ].__class__.__name__
+                            ),
+                            str(message.seq_id),
+                        )
+                    else:
+                        _LOGGER.warning(
+                            "Received unmanaged (%s) %s for unknown request with seq_id %s",
+                            str(status),
+                            message.__class__.__name__,
+                            str(message.seq_id),
+                        )
         else:
             _LOGGER.info(
                 "Received %s from %s with sequence id %s",

{plugwise-0.27.6 → plugwise-0.27.7}/plugwise/helper.py

@@ -225,7 +225,6 @@ class SmileComm:
     ):
         """Set the constructor for this class."""
         if not websession:
-
             aio_timeout = ClientTimeout(total=timeout)
 
             async def _create_session() -> ClientSession:
@@ -303,7 +302,9 @@ class SmileComm:
                     data=data,
                     auth=self._auth,
                 )
-        except ClientError as err:  # ClientError is an ancestor class of ServerTimeoutError
+        except (
+            ClientError
+        ) as err:  # ClientError is an ancestor class of ServerTimeoutError
             if retry < 1:
                 LOGGER.warning(
                     "Failed sending %s %s to Plugwise Smile, error: %s",
@@ -1014,7 +1015,6 @@ class SmileHelper:
         if (
             appliance := self._appliances.find(f'./appliance[@id="{d_id}"]')
         ) is not None:
-
             self._appliance_measurements(appliance, data, measurements)
             self._get_lock_state(appliance, data)
 
@@ -1082,7 +1082,6 @@ class SmileHelper:
         appl_class = appliance_details["dev_class"]
         appl_d_loc = appliance_details["location"]
         if loc_id == appl_d_loc and appl_class in thermo_matching:
-
             # Pre-elect new master
             if thermo_matching[appl_class] > self._thermo_locs[loc_id]["master_prio"]:
                 # Demote former master

{plugwise-0.27.6 → plugwise-0.27.7}/plugwise/nodes/circle.py

@@ -66,7 +66,9 @@ class PlugwiseCircle(PlugwiseNode):
         self._energy_consumption_today_reset = datetime.now().replace(
             hour=0, minute=0, second=0, microsecond=0
         )
+        self._energy_memory = {}
         self._energy_history_collecting = False
+        self._energy_history_collecting_timestamp = datetime.now()
         self._energy_history = {}
         self._energy_last_collected_timestamp = datetime(2000, 1, 1)
         self._energy_last_rollover_timestamp = datetime(2000, 1, 1)
@@ -613,7 +615,16 @@ class PlugwiseCircle(PlugwiseNode):
         if log_address is None:
             log_address = self._last_log_address
         if log_address is not None:
-            if len(self._energy_history) > 48 or self._energy_history_collecting:
+            if self._energy_history_collecting and (
+                self._energy_history_collecting_timestamp
+                < datetime.now() - timedelta(minutes=15)
+            ):
+                _LOGGER.debug(
+                    "Skip request_energy_counters for %s of address %s",
+                    self.mac,
+                    str(log_address),
+                )
+            elif len(self._energy_history) > 48:
                 # Energy history already collected
                 if (
                     log_address == self._last_log_address
@@ -624,31 +635,53 @@ class PlugwiseCircle(PlugwiseNode):
                     self._request_info(self.request_energy_counters)
                 else:
                     # Request new energy counters
-                    self.message_sender(
-                        CircleEnergyCountersRequest(self._mac, log_address),
-                        None,
-                        0,
-                        PRIORITY_LOW,
-                    )
+                    if self._energy_memory.get(log_address, 0) < 4:
+                        self.message_sender(
+                            CircleEnergyCountersRequest(self._mac, log_address),
+                            None,
+                            0,
+                            PRIORITY_LOW,
+                        )
+                    else:
+                        _LOGGER.info(
+                            "Drop known request_energy_counters for %s of address %s",
+                            self.mac,
+                            str(log_address),
+                        )
             else:
                 # Collect energy counters of today and yesterday
                 # Each request contains will return 4 hours, except last request
 
                 # TODO: validate range of log_addresses
                 self._energy_history_collecting = True
+                self._energy_history_collecting_timestamp = datetime.now()
                 for req_log_address in range(log_address - 13, log_address):
+                    if self._energy_memory.get(req_log_address, 0) < 4:
+                        self.message_sender(
+                            CircleEnergyCountersRequest(self._mac, req_log_address),
+                            None,
+                            0,
+                            PRIORITY_LOW,
+                        )
+                    else:
+                        _LOGGER.info(
+                            "Drop known request_energy_counters at collecting for %s of address %s",
+                            self.mac,
+                            str(log_address),
+                        )
+                if self._energy_memory.get(log_address, 0) < 4:
                     self.message_sender(
-                        CircleEnergyCountersRequest(self._mac, req_log_address),
-                        None,
+                        CircleEnergyCountersRequest(self._mac, log_address),
+                        callback,
                         0,
                         PRIORITY_LOW,
                     )
-                self.message_sender(
-                    CircleEnergyCountersRequest(self._mac, log_address),
-                    callback,
-                    0,
-                    PRIORITY_LOW,
-                )
+                else:
+                    _LOGGER.info(
+                        "Drop known request_energy_counters at collecting end for %s of address %s",
+                        self.mac,
+                        str(log_address),
+                    )
 
     def _response_energy_counters(self, message: CircleEnergyCountersResponse):
         """
@@ -677,6 +710,10 @@ class PlugwiseCircle(PlugwiseNode):
                 _log_timestamp := getattr(message, "logdate%d" % (_slot,)).value
             ) is None:
                 break
+            # Register collected history memory
+            if _slot > self._energy_memory.get(message.logaddr.value, 0):
+                self._energy_memory[message.logaddr.value] = _slot
+
             self._energy_history[_log_timestamp] = getattr(
                 message, "pulses%d" % (_slot,)
             ).value

{plugwise-0.27.6 → plugwise-0.27.7}/plugwise/nodes/sed.py

@@ -81,7 +81,8 @@ class NodeSED(PlugwiseNode):
             SED_AWAKE_STARTUP,
             SED_AWAKE_BUTTON,
         ]:
-            for request_message, callback in self._sed_requests.items():
+            for pending_request in self._sed_requests.values():
+                request_message, callback = pending_request
                 _LOGGER.info(
                     "Send queued %s message to SED node %s",
                     request_message.__class__.__name__,

{plugwise-0.27.6 → plugwise-0.27.7}/plugwise.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plugwise
-Version: 0.27.6
+Version: 0.27.7
 Summary: Plugwise Smile (Adam/Anna/P1), Stretch and USB (Stick) module for Python 3.
 Home-page: https://github.com/plugwise/python-plugwise
 Author: Plugwise device owners
@@ -37,6 +37,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Home Automation
 Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown

{plugwise-0.27.6 → plugwise-0.27.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name            = "plugwise"
-version         = "0.27.6"
+version         = "0.27.7"
 license         = {file = "LICENSE"}
 description     = "Plugwise Smile (Adam/Anna/P1), Stretch and USB (Stick) module for Python 3."
 readme          = "README.md"
@@ -16,6 +16,7 @@ classifiers     = [
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
     "Topic :: Home Automation",
 ]
 authors = [
@@ -50,7 +51,7 @@ include-package-data = true
 include = ["plugwise*"]
 
 [tool.black]
-target-version = ["py39", "py310"]
+target-version = ["py39", "py310", "py311"]
 exclude = 'generated'
 
 [tool.isort]
@@ -166,9 +167,8 @@ expected-line-ending-format = "LF"
 
 [tool.pylint.EXCEPTIONS]
 overgeneral-exceptions = [
-    "BaseException",
-    "Exception",
-    "HomeAssistantError",
+    "builtins.BaseException",
+    "builtins.Exception",
 ]
 
 [tool.pytest.ini_options]
@@ -187,7 +187,7 @@ norecursedirs = [
 ]
 
 [tool.mypy]
-python_version = "3.10"
+python_version = "3.11"
 show_error_codes = true
 follow_imports = "silent"
 ignore_missing_imports = true