pylint: fix pylint issues

Consider merging these comparisons with 'in' by *. Use a set instead if elements are hashable. (consider-using-in)
Unnecessary parens after '=' keyword (superfluous-parens)
Unused argument * (unused-argument)

Signed-off-by: Tatiana Leon <Tatiana.Leon@digi.com>

Author: tatianaleon

digi/xbee/devices.py

@@ -2048,8 +2048,7 @@ def _before_send_method(func):
         def dec_function(self, *args, **kwargs):
             if not self._comm_iface.is_interface_open:
                 raise XBeeException("XBee device's communication interface closed.")
-            if (self._operating_mode != OperatingMode.API_MODE
-                    and self._operating_mode != OperatingMode.ESCAPED_API_MODE):
+            if self._operating_mode not in (OperatingMode.API_MODE, OperatingMode.ESCAPED_API_MODE):
                 raise InvalidOperatingModeException(op_mode=self._operating_mode)
             return func(self, *args, **kwargs)
         return dec_function
@@ -2063,8 +2062,8 @@ def _after_send_method(func):
         @wraps(func)
         def dec_function(*args, **kwargs):
             response = func(*args, **kwargs)
-            if (response.transmit_status != TransmitStatus.SUCCESS
-                    and response.transmit_status != TransmitStatus.SELF_ADDRESSED):
+            if response.transmit_status not in (TransmitStatus.SUCCESS,
+                                                TransmitStatus.SELF_ADDRESSED):
                 raise TransmitException(transmit_status=response.transmit_status)
             return response
         return dec_function
@@ -7831,7 +7830,7 @@ def __get_signal_quality(wifi_version, signal_strength):
             elif signal_strength >= -50:
                 quality = 100
             else:
-                quality = (2 * (signal_strength + 100))
+                quality = 2 * (signal_strength + 100)
         else:
             quality = 2 * signal_strength
 
@@ -10419,14 +10418,14 @@ def __discover_next_node_neighbors(self, nodes_queue, active_processes, node_tim
 
         return code
 
-    def _check_not_discovered_nodes(self, devices_list, nodes_queue):
+    def _check_not_discovered_nodes(self, devices_list, _nodes_queue):
         """
         Checks not discovered nodes in the current scan, and add them to the
         FIFO if necessary.
 
         Args:
             devices_list (List): List of nodes to check.
-            nodes_queue (:class:`queue.Queue`): FIFO where the nodes to
+            _nodes_queue (:class:`queue.Queue`): FIFO where the nodes to
                 discover their neighbors are stored.
         """
         # Check for nodes in the network not discovered in this scan and ensure
@@ -10451,16 +10450,16 @@ def _check_not_discovered_nodes(self, devices_list, nodes_queue):
                 self._log.debug("     - Reachable: %s (scan %d)",
                                 n_item._reachable, self.__scan_counter)
 
-    def _discover_neighbors(self, requester, nodes_queue, active_processes, node_timeout):
+    def _discover_neighbors(self, _requester, _nodes_queue, _active_processes, _node_timeout):
         """
         Starts the process to discover the neighbors of the given node.
 
         Args:
-            requester(:class:`.AbstractXBeeDevice`): XBee to discover its neighbors.
-            nodes_queue (:class:`queue.Queue`): FIFO where the nodes to
+            _requester(:class:`.AbstractXBeeDevice`): XBee to discover its neighbors.
+            _nodes_queue (:class:`queue.Queue`): FIFO where the nodes to
                 discover their neighbors are stored.
-            active_processes (List): List of active discovery processes.
-            node_timeout (Float): Timeout to discover neighbors (seconds).
+            _active_processes (List): List of active discovery processes.
+            _node_timeout (Float): Timeout to discover neighbors (seconds).
 
         Returns:
             :class:`.NetworkDiscoveryStatus`: Resulting status of the process.
@@ -11126,8 +11125,8 @@ def __purge_network_connections(self, force=False):
         connections_to_remove = []
         with self.__conn_lock:
             for conn in self.__connections:
-                if (conn.scan_counter_a2b != self.__scan_counter
-                        and conn.scan_counter_b2a != self.__scan_counter):
+                if self.__scan_counter not in (conn.scan_counter_a2b,
+                                               conn.scan_counter_b2a):
                     conn.lq_a2b = LinkQuality.UNKNOWN
                     conn.lq_b2a = LinkQuality.UNKNOWN
                     connections_to_remove.append(conn)
@@ -11601,8 +11600,8 @@ def __process_discovered_neighbor_data(self, requester, routes, neighbor, nodes_
                 connection = Connection(node, requester, lq_a2b=neighbor.lq,
                                         lq_b2a=LinkQuality.UNKNOWN, status_a2b=RouteStatus.ACTIVE,
                                         status_b2a=RouteStatus.UNKNOWN)
-            elif (neighbor.relationship == NeighborRelationship.CHILD
-                  or neighbor.relationship == NeighborRelationship.UNDETERMINED):
+            elif neighbor.relationship in (NeighborRelationship.CHILD,
+                                           NeighborRelationship.UNDETERMINED):
                 connection = Connection(requester, node, lq_a2b=neighbor.lq,
                                         lq_b2a=LinkQuality.UNKNOWN, status_a2b=RouteStatus.ACTIVE,
                                         status_b2a=RouteStatus.UNKNOWN)

digi/xbee/firmware.py

@@ -5596,8 +5596,8 @@ def _finish_firmware_update(self):
                                 and self._remote.get_protocol() == XBeeProtocol.DIGI_MESH
                                 and self._target_fw_version <= 0x3004)
                 raw_802_error = (st_frame.transmit_status == TransmitStatus.NO_ACK
-                                and self._remote.get_protocol() == XBeeProtocol.RAW_802_15_4
-                                and self._target_fw_version <= 0x2002)
+                                 and self._remote.get_protocol() == XBeeProtocol.RAW_802_15_4
+                                 and self._target_fw_version <= 0x2002)
                 zb_addr_error = (st_frame.transmit_status == TransmitStatus.ADDRESS_NOT_FOUND
                                  and self._remote.get_protocol() == XBeeProtocol.ZIGBEE
                                  and self._target_fw_version <= 0x1009)
@@ -7305,7 +7305,7 @@ def update_remote_firmware(remote, xml_fw_file, firmware_file=None, bootloader_f
     finally:
         configurer.restore_after_update(
             restore_settings=not update_process.check_protocol_changed_by_fw(orig_protocol))
-        finished = (remote._active_update_type == NodeUpdateType.FIRMWARE)
+        finished = remote._active_update_type == NodeUpdateType.FIRMWARE
         if finished or msg != "Success":
             update_process._notify_progress(msg, 100, finished=finished)
 
@@ -7370,7 +7370,7 @@ def update_remote_filesystem(remote, ota_fs_file, max_block_size=0, timeout=None
         raise exc
     finally:
         configurer.restore_after_update()
-        finished = (remote._active_update_type == NodeUpdateType.FILESYSTEM)
+        finished = remote._active_update_type == NodeUpdateType.FILESYSTEM
         if finished or msg != "Success":
             update_process._notify_progress(msg, 100, finished=finished)
 

digi/xbee/packets/bluetooth.py

@@ -107,19 +107,19 @@ def __init__(self, start_command, scan_duration, scan_window,
         if scan_duration is None:
             raise ValueError("The scan duration cannot be None")
 
-        if not (self.INDEFINITE_SCAN_DURATION <= scan_duration <= self.__SCAN_DURATION_MAXIMUM):
+        if not self.INDEFINITE_SCAN_DURATION <= scan_duration <= self.__SCAN_DURATION_MAXIMUM:
             raise ValueError(f"scan_duration must be between {self.INDEFINITE_SCAN_DURATION} and {self.__SCAN_DURATION_MAXIMUM}")
 
         if scan_window is None:
             raise ValueError("The scan window cannot be None")
 
-        if not (self.__SCAN_WINDOW_MINIMUM <= scan_window <= self.__SCAN_WINDOW_MAXIMUM):
+        if not self.__SCAN_WINDOW_MINIMUM <= scan_window <= self.__SCAN_WINDOW_MAXIMUM:
             raise ValueError(f"scan_window must be between {self.__SCAN_WINDOW_MINIMUM} and {self.__SCAN_WINDOW_MAXIMUM}")
 
         if scan_interval is None:
             raise ValueError("The scan interval cannot be None")
 
-        if not (self.__SCAN_INTERVAL_MINIMUM <= scan_interval <= self.__SCAN_INTERVAL_MAXIMUM):
+        if not self.__SCAN_INTERVAL_MINIMUM <= scan_interval <= self.__SCAN_INTERVAL_MAXIMUM:
             raise ValueError(f"scan_interval must be between {self.__SCAN_INTERVAL_MINIMUM} and {self.__SCAN_INTERVAL_MAXIMUM}")
 
         if scan_interval < scan_window: