Reset codacy part

Author: CoMPaTech

.github/workflows/verify.yml

@@ -227,6 +227,11 @@ jobs:
           coverage xml
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v1
+      - name: Run codacy-coverage-reporter
+        uses: codacy/codacy-coverage-reporter-action@master
+        with:
+          project-token: ${{ secrets.CODACY_PROJECT_TOKEN }}
+          coverage-reports: coverage.xml
 
   test-publishing:
     name: Build and publish Python 🐍 distributions 📦 to TestPyPI

plugwise/connections/serial.py

@@ -8,9 +8,10 @@
 import serial
 
 from plugwise.connections.connection import StickConnection
-from plugwise.constants import BAUD_RATE, BYTE_SIZE, PARITY, SLEEP_TIME, STOPBITS
+from plugwise.constants import BAUD_RATE, BYTE_SIZE, STOPBITS
 from plugwise.exceptions import PortError
-from plugwise.message import PlugwiseMessage
+
+#  from plugwise.message import PlugwiseMessage
 
 _LOGGER = logging.getLogger(__name__)
 

plugwise/node.py

@@ -33,7 +33,7 @@
 
 
 class PlugwiseNode:
-    """ Base class for a Plugwise node """
+    """Base class for a Plugwise node."""
 
     def __init__(self, mac, address, stick):
         mac = mac.upper()
@@ -65,7 +65,7 @@ def __init__(self, mac, address, stick):
         self._features = None
 
     def get_node_type(self) -> str:
-        """Return hardware model"""
+        """Return hardware model."""
         if self._hardware_version:
             hw_model = HW_MODELS.get(self._hardware_version[4:10], None)
             if hw_model:
@@ -83,27 +83,27 @@ def get_node_type(self) -> str:
         return "Unknown"
 
     def is_sed(self) -> bool:
-        """ Return True if node SED (battery powered)"""
+        """Return True if node SED (battery powered)."""
         return False
 
     def get_categories(self) -> tuple:
-        """ Return Home Assistant categories supported by plugwise node """
+        """Return Home Assistant categories supported by plugwise node."""
         return self.categories
 
     def get_sensors(self) -> tuple:
-        """ Return sensors supported by plugwise node """
+        """Return sensors supported by plugwise node."""
         return self.sensors
 
     def get_switches(self) -> tuple:
-        """ Return switches supported by plugwise node """
+        """Return switches supported by plugwise node."""
         return self.switches
 
     def get_available(self) -> bool:
-        """ Return current network state of plugwise node """
+        """Return current network state of plugwise node."""
         return self._available
 
     def set_available(self, state, request_info=False):
-        """ Set current network state of plugwise node """
+        """Set current network state of plugwise node."""
         if state is True:
             if self._available is False:
                 self._available = True
@@ -124,72 +124,70 @@ def set_available(self, state, request_info=False):
                 self.do_callback(SENSOR_AVAILABLE["id"])
 
     def get_mac(self) -> str:
-        """Return mac address"""
+        """Return mac address."""
         return self.mac.decode(UTF8_DECODE)
 
     def get_name(self) -> str:
-        """Return unique name"""
+        """Return unique name."""
         return self.get_node_type() + " (" + str(self._address) + ")"
 
     def get_hardware_version(self) -> str:
-        """Return hardware version"""
+        """Return hardware version."""
         if self._hardware_version is not None:
             return self._hardware_version
         return "Unknown"
 
     def get_firmware_version(self) -> str:
-        """Return firmware version"""
+        """Return firmware version."""
         if self._firmware_version is not None:
             return str(self._firmware_version)
         return "Unknown"
 
     def get_last_update(self) -> datetime:
-        """Return  version"""
+        """Return  version."""
         return self.last_update
 
     def get_in_RSSI(self) -> int:
-        """Return inbound RSSI level"""
+        """Return inbound RSSI level."""
         if self.in_RSSI is not None:
             return self.in_RSSI
         return 0
 
     def get_out_RSSI(self) -> int:
-        """Return outbound RSSI level"""
+        """Return outbound RSSI level."""
         if self.out_RSSI is not None:
             return self.out_RSSI
         return 0
 
     def get_ping(self) -> int:
-        """Return ping roundtrip"""
+        """Return ping roundtrip."""
         if self.ping_ms is not None:
             return self.ping_ms
         return 0
 
     def _request_info(self, callback=None):
-        """ Request info from node"""
+        """Request info from node"""
         self.stick.send(
             NodeInfoRequest(self.mac),
             callback,
         )
 
     def _request_features(self, callback=None):
-        """ Request supported features for this node"""
+        """Request supported features for this node."""
         self.stick.send(
             NodeFeaturesRequest(self.mac),
             callback,
         )
 
     def ping(self, callback=None):
-        """ Ping node"""
+        """Ping node."""
         self.stick.send(
             NodePingRequest(self.mac),
             callback,
         )
 
     def on_message(self, message):
-        """
-        Process received message
-        """
+        """Process received message."""
         assert isinstance(message, PlugwiseMessage)
         if message.mac == self.mac:
             if message.timestamp is not None:
@@ -220,7 +218,7 @@ def _on_message(self, message):
         pass
 
     def subscribe_callback(self, callback, sensor) -> bool:
-        """ Subscribe callback to execute when state change happens """
+        """Subscribe callback to execute when state change happens."""
         if sensor in self.sensors:
             if sensor not in self._callbacks:
                 self._callbacks[sensor] = []
@@ -229,12 +227,12 @@ def subscribe_callback(self, callback, sensor) -> bool:
         return False
 
     def unsubscribe_callback(self, callback, sensor):
-        """ Unsubscribe callback to execute when state change happens """
+        """Unsubscribe callback to execute when state change happens."""
         if sensor in self._callbacks:
             self._callbacks[sensor].remove(callback)
 
     def do_callback(self, sensor):
-        """ Execute callbacks registered for specified callback type """
+        """Execute callbacks registered for specified callback type."""
         if sensor in self._callbacks:
             for callback in self._callbacks[sensor]:
                 try:
@@ -246,7 +244,7 @@ def do_callback(self, sensor):
                     )
 
     def _process_ping_response(self, message):
-        """ Process ping response message"""
+        """Process ping response message."""
         self.set_available(True, True)
         if self.in_RSSI != message.in_RSSI.value:
             self.in_RSSI = message.in_RSSI.value
@@ -259,7 +257,7 @@ def _process_ping_response(self, message):
             self.do_callback(SENSOR_PING["id"])
 
     def _process_info_response(self, message):
-        """ Process info response message"""
+        """Process info response message."""
         _LOGGER.debug("Response info message for node %s", self.get_mac())
         self.set_available(True)
         if message.relay_state.serialize() == b"01":
@@ -284,7 +282,7 @@ def _process_info_response(self, message):
         _LOGGER.debug("Firmware version = %s", str(self._firmware_version))
 
     def _process_features_response(self, message):
-        """ Process features message """
+        """Process features message."""
         _LOGGER.info(
             "Node %s supports features %s", self.get_mac(), str(message.features.value)
         )

plugwise/stick.py

@@ -584,7 +584,7 @@ def send(self, request, callback=None, retry_counter=0):
         )
 
     def _send_message_loop(self):
-        """ daemon to send messages waiting in queue """
+        """Daemon to send messages waiting in queue."""
         while self._run_send_message_thread:
             try:
                 request_set = self._send_message_queue.get(block=True, timeout=1)
@@ -671,7 +671,7 @@ def _send_message_loop(self):
         _LOGGER.debug("Send message loop stopped")
 
     def _receive_timeout_loop(self):
-        """ daemon to time out requests without any (n)ack response message """
+        """Daemon to time out requests without any (n)ack response message."""
         while self._run_receive_timeout_thread:
             for seq_id in list(self.expected_responses.keys()):
                 if self.expected_responses[seq_id][4] is not None: