pylint: fix several pylint issues

Unused variable 'server_status' (unused-variable)
Consider explicitly re-raising using the 'from' keyword (raise-missing-from)
Use lazy % formatting in logging functions (logging-not-lazy)
Possible unbalanced tuple unpacking with sequence defined at line 1629: left side has 3 label(s), right side has 2 value(s) (unbalanced-tuple-unpacking)
Unnecessary "else" after "continue" (no-else-continue)
Either all return statements in a function should return an expression, or none of them should. (inconsistent-return-statements)
Consider using [] instead of list() (use-list-literal)
Method 'name' was expected to be 'method', found it instead as 'property' (invalid-overridden-method)
Consider merging these comparisons with "in" to 'node in (conn.node_a, conn.node_b)' (consider-using-in)
Unused private member `AbstractXBeeDevice.__is_api_packet(xbee_packet)` (unused-private-member)
Method could be a function (no-self-use)
Unused private member `IPDevice.__DEFAULT_PROTOCOL` (unused-private-member)
Unused private member `XBeeDevice.__TIMEOUT_ENTER_COMMAND_MODE` (unused-private-member)
Unused private member `XBeeDevice.__COMMAND_MODE_CHAR` (unused-private-member)
Unused private member `XBeeDevice.__COMMAND_MODE_OK` (unused-private-member)
Unused private member `XBee64BitAddress.__DEVICE_ID_SEPARATOR` (unused-private-member)
Unused private member `XBee64BitAddress.__DEVICE_ID_MAC_SEPARATOR` (unused-private-member)
Unnecessary parens after 'not' keyword (superfluous-parens)

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

Author: tatianaleon

digi/xbee/devices.py

@@ -416,7 +416,8 @@ def __send_parameter(self, parameter, parameter_value=None, apply=None):
 
         return response.response
 
-    def _check_at_cmd_response_is_valid(self, response):
+    @staticmethod
+    def _check_at_cmd_response_is_valid(response):
         """
         Checks if the provided `ATCommandResponse` is valid throwing an
         :class:`.ATCommandException` in case it is not.
@@ -1222,7 +1223,7 @@ def get_io_configuration(self, io_line):
             mode = IOMode(value[0])
         except ValueError:
             raise OperationNotSupportedException(
-                "Received configuration IO mode '%s' is invalid." % utils.hex_to_string(value))
+                "Received configuration IO mode '%s' is invalid." % utils.hex_to_string(value)) from None
         return mode
 
     def get_io_sampling_rate(self):
@@ -1340,7 +1341,7 @@ def io_sample_callback(received_packet):
         try:
             return IOSample(sample_payload)
         except Exception as exc:
-            raise XBeeException("Could not create the IO sample.", exc)
+            raise XBeeException("Could not create the IO sample.", exc) from None
 
     def get_adc_value(self, io_line):
         """
@@ -2033,22 +2034,6 @@ def _get_packet_by_id(self, frame_id):
 
         return packet
 
-    @staticmethod
-    def __is_api_packet(xbee_packet):
-        """
-        Determines whether the provided XBee packet is an API packet.
-
-        Returns:
-            Boolean: `True` if the provided XBee packet is an API packet (its
-                frame type is in :class:`.ApiFrameType` enum), `False` otherwise.
-        """
-        aft = xbee_packet.get_frame_type()
-        try:
-            ApiFrameType.get(aft)
-        except ValueError:
-            return False
-        return True
-
     def _add_packet_received_callback(self, callback):
         """
         Adds a callback for the event :class:`.PacketReceived`.
@@ -2305,14 +2290,6 @@ class XBeeDevice(AbstractXBeeDevice):
     supports API modes, not AT (transparent) mode).
     """
 
-    __TIMEOUT_ENTER_COMMAND_MODE = 1.5  # seconds
-    """
-    Timeout to wait after entering in command mode in seconds.
-
-    It is used to determine the operating mode of the module (this library only
-    supports API modes, not transparent mode).
-    """
-
     __TIMEOUT_RESET = 5  # seconds
     """
     Timeout to wait when resetting the module.
@@ -2323,16 +2300,6 @@ class XBeeDevice(AbstractXBeeDevice):
     Timeout to read packets.
     """
 
-    __COMMAND_MODE_CHAR = "+"
-    """
-    Character you have to send to enter AT command mode
-    """
-
-    __COMMAND_MODE_OK = "OK\r"
-    """
-    Response received if the attempt to enter in AT command mode goes well.
-    """
-
     def __init__(self, port=None, baud_rate=None, data_bits=serial.EIGHTBITS,
                  stop_bits=serial.STOPBITS_ONE, parity=serial.PARITY_NONE,
                  flow_control=FlowControl.NONE,
@@ -2460,7 +2427,7 @@ def open(self, force_settings=False):
                            "forcing settings using recovery: %s", str(exc))
             if self._serial_port is None:
                 raise XBeeException("Can not open the port by forcing the settings, "
-                                    "it is only supported for Serial")
+                                    "it is only supported for Serial") from None
             self._autodetect_device()
             self.open(force_settings=False)
 
@@ -2475,7 +2442,7 @@ def _do_open(self):
                 the operating mode.
             XBeeException: If the XBee is already opened.
         """
-        xbee_info = self._comm_iface.get_local_xbee_info() if self._comm_iface else None
+        xbee_info = self._comm_iface.get_local_xbee_info() if self._comm_iface else ()
         if xbee_info:
             self._operating_mode = OperatingMode.get(xbee_info[0])
             self._hardware_version = HardwareVersion.get(xbee_info[1])
@@ -6196,8 +6163,6 @@ class IPDevice(XBeeDevice):
 
     __DEFAULT_SOURCE_PORT = 9750
 
-    __DEFAULT_PROTOCOL = IPProtocol.TCP
-
     __OPERATION_EXCEPTION = "Operation not supported in this module."
 
     def __init__(self, port=None, baud_rate=None, data_bits=serial.EIGHTBITS,
@@ -7731,12 +7696,7 @@ def __get_signal_quality(wifi_version, signal_strength):
             quality = 2 * signal_strength
 
         # Check limits.
-        if quality > 100:
-            quality = 100
-        if quality < 0:
-            quality = 0
-
-        return quality
+        return max(min(quality, 100), 0)
 
     def get_access_point_timeout(self):
         """
@@ -10112,7 +10072,7 @@ def _prepare_network_discovery(self):
             self.set_discovery_timeout(self._node_timeout)
         except XBeeException as exc:
             raise XBeeException(
-                "Could not prepare XBee for network discovery: %s" % str(exc))
+                "Could not prepare XBee for network discovery: %s" % str(exc)) from exc
 
     def __init_scan(self):
         """
@@ -10346,6 +10306,7 @@ def __discover_devices(self, node_id=None):
             return err_code
         except Exception as exc:
             self._local_xbee.log.exception(exc)
+            return NetworkDiscoveryStatus.ERROR_GENERAL
 
     def _node_discovery_process_finished(self, requester, code=None, error=None):
         """
@@ -10713,7 +10674,7 @@ def get_node_connections(self, node):
         connections = []
         with self.__conn_lock:
             for conn in self.__connections:
-                if conn.node_a == node or conn.node_b == node:
+                if node in (conn.node_a, conn.node_b):
                     connections.append(conn)
 
         return connections
@@ -11074,7 +11035,7 @@ def _prepare_network_discovery(self):
             self.__enable_explicit_mode()
         except XBeeException as exc:
             raise XBeeException(
-                "Could not prepare XBee for network discovery: %s" % str(exc))
+                "Could not prepare XBee for network discovery: %s" % str(exc)) from exc
 
     def _discover_neighbors(self, requester, nodes_queue, active_processes, node_timeout):
         """
@@ -11457,7 +11418,8 @@ def __get_zdo_command(self, xbee, cmd_type):
 
         return None
 
-    def __stop_zdo_command(self, commands, cmd_type):
+    @staticmethod
+    def __stop_zdo_command(commands, cmd_type):
         """
         Stops the execution of the ZDO command contained in the given dictionary.
         This method blocks until the ZDO command is completely stopped.
@@ -11609,7 +11571,7 @@ def _prepare_network_discovery(self):
 
         except XBeeException as exc:
             raise XBeeException(
-                "Could not prepare XBee for network discovery: %s" % str(exc))
+                "Could not prepare XBee for network discovery: %s" % str(exc)) from exc
 
         # Calculate the real timeout to wait for responses, based on 'N?' and
         # the cyclic sleep times, if the node is configured for that.

digi/xbee/filesystem.py

@@ -148,13 +148,13 @@ def get(cls, name):
                 provided name.
         """
         for value in _FilesystemFunction:
-            if value.name == name:
+            if value.cmd_name == name:
                 return value
 
         return None
 
     @property
-    def name(self):
+    def cmd_name(self):
         """
         Returns the name of the `_FilesystemFunction` element.
 
@@ -2684,7 +2684,7 @@ def _is_function_supported(self, function):
         if not isinstance(function, _FilesystemFunction):
             return False
 
-        return function.name in self._supported_functions
+        return function.cmd_name in self._supported_functions
 
     @staticmethod
     def _check_function_error(answer, command):
@@ -2777,7 +2777,7 @@ def _execute_command(self, cmd_type, *args, wait_for_answer=True):
         """
         # Sanity checks.
         if not self._is_function_supported(cmd_type):
-            raise FileSystemException(_ERROR_FUNCTION_NOT_SUPPORTED % cmd_type.name)
+            raise FileSystemException(_ERROR_FUNCTION_NOT_SUPPORTED % cmd_type.cmd_name)
         if not self._check_atcmd_mode():
             raise FileSystemException(_ERROR_ENTER_CMD_MODE)
 
@@ -2794,7 +2794,7 @@ def _execute_command(self, cmd_type, *args, wait_for_answer=True):
             return answer
         except SerialException as exc:
             raise FileSystemException(_ERROR_EXECUTE_COMMAND %
-                                      (command.replace("\r", ""), str(exc)))
+                                      (command.replace("\r", ""), str(exc))) from None
 
     @property
     def is_connected(self):
@@ -2849,7 +2849,7 @@ def connect(self):
                 # much info but confusion.
                 pass
             if isinstance(exc, SerialException):
-                raise FileSystemException(_ERROR_CONNECT_FILESYSTEM % str(exc))
+                raise FileSystemException(_ERROR_CONNECT_FILESYSTEM % str(exc)) from None
             raise exc
 
     def disconnect(self):
@@ -3071,10 +3071,10 @@ def put_file(self, source_path, dest_path, secure=False, progress_callback=None)
         # Sanity checks.
         if secure and not self._is_function_supported(_FilesystemFunction.XPUT):
             raise FileSystemException(_ERROR_FUNCTION_NOT_SUPPORTED
-                                      % _FilesystemFunction.XPUT.name)
+                                      % _FilesystemFunction.XPUT.cmd_name)
         if not secure and not self._is_function_supported(_FilesystemFunction.PUT):
             raise FileSystemException(_ERROR_FUNCTION_NOT_SUPPORTED
-                                      % _FilesystemFunction.PUT.name)
+                                      % _FilesystemFunction.PUT.cmd_name)
 
         # Sanitize destination path.
         dest_path = dest_path.replace('\\', '/')
@@ -3111,7 +3111,7 @@ def put_file(self, source_path, dest_path, secure=False, progress_callback=None)
                 progress_cb=progress_callback, log=_log)
         except XModemException as exc:
             raise FileSystemException(_ERROR_EXECUTE_COMMAND %
-                                      (command.replace("\r", ""), str(exc)))
+                                      (command.replace("\r", ""), str(exc))) from None
         # Read operation result.
         answer = self._read_data(timeout=_READ_DATA_TIMEOUT,
                                  empty_retries=_READ_EMPTY_DATA_RETRIES)
@@ -3197,14 +3197,14 @@ def get_file(self, source_path, dest_path, progress_callback=None):
                                            "Transfer not ready"))
         except SerialException as exc:
             raise FileSystemException(_ERROR_EXECUTE_COMMAND %
-                                      (command.replace("\r", ""), str(exc)))
+                                      (command.replace("\r", ""), str(exc))) from None
         # Receive the file.
         try:
             xmodem.get_file_ymodem(dest_path, self._xmodem_write_cb, self._xmodem_read_cb,
                                    progress_cb=progress_callback, log=_log)
         except XModemException as exc:
             raise FileSystemException(_ERROR_EXECUTE_COMMAND %
-                                      (command.replace("\r", ""), str(exc)))
+                                      (command.replace("\r", ""), str(exc))) from None
         # Read operation result.
         answer = self._read_data()
         if not answer:
@@ -3233,7 +3233,7 @@ def format_filesystem(self):
                 raise FileSystemException(_ERROR_TIMEOUT)
         except SerialException as exc:
             raise FileSystemException(_ERROR_EXECUTE_COMMAND %
-                                      (command.replace("\r", ""), str(exc)))
+                                      (command.replace("\r", ""), str(exc))) from None
 
     def get_usage_information(self):
         """
@@ -3323,7 +3323,7 @@ def update_remote_filesystem_image(remote_device, ota_filesystem_file,
             timeout=timeout, progress_callback=progress_callback, _prepare=_prepare)
     except FirmwareUpdateException as exc:
         _log.error("ERROR: %s", str(exc))
-        raise FileSystemException(str(exc))
+        raise FileSystemException(str(exc)) from None
 
 
 def check_fs_support(xbee, min_fw_vers=None, max_fw_vers=None):