use new super syntax in can/**

felixdivo · felixdivo · commit 048df91f0a0f · 2019-05-19T14:10:38.000+02:00
diff --git a/can/broadcastmanager.py b/can/broadcastmanager.py
@@ -44,7 +44,7 @@ def __init__(self, message, period):
         self.can_id = message.arbitration_id
         self.arbitration_id = message.arbitration_id
         self.period = period
-        super(CyclicSendTaskABC, self).__init__()
+        super().__init__()
 
 
 class LimitedDurationCyclicSendTaskABC(CyclicSendTaskABC):
@@ -57,7 +57,7 @@ def __init__(self, message, period, duration):
         :param float duration:
             The duration to keep sending this message at given rate.
         """
-        super(LimitedDurationCyclicSendTaskABC, self).__init__(message, period)
+        super().__init__(message, period)
         self.duration = duration
 
 
@@ -99,7 +99,7 @@ def __init__(self, channel, message, count, initial_period, subsequent_period):
         :param float initial_period:
         :param float subsequent_period:
         """
-        super(MultiRateCyclicSendTaskABC, self).__init__(channel, message, subsequent_period)
+        super().__init__(channel, message, subsequent_period)
 
 
 class ThreadBasedCyclicSendTask(ModifiableCyclicTaskABC,
@@ -108,7 +108,7 @@ class ThreadBasedCyclicSendTask(ModifiableCyclicTaskABC,
     """Fallback cyclic send task using thread."""
 
     def __init__(self, bus, lock, message, period, duration=None):
-        super(ThreadBasedCyclicSendTask, self).__init__(message, period, duration)
+        super().__init__(message, period, duration)
         self.bus = bus
         self.lock = lock
         self.stopped = True
diff --git a/can/ctypesutil.py b/can/ctypesutil.py
@@ -58,9 +58,9 @@ class CLibrary_Win32(_LibBase, LibraryMixin):
 
     def __init__(self, library_or_path):
         if (isinstance(library_or_path, str)):
-            super(CLibrary_Win32, self).__init__(library_or_path)
+            super().__init__(library_or_path)
         else:
-            super(CLibrary_Win32, self).__init__(library_or_path._name, library_or_path._handle)
+            super().__init__(library_or_path._name, library_or_path._handle)
 
     @property
     def function_type(self):
@@ -72,9 +72,9 @@ class CLibrary_Unix(ctypes.CDLL, LibraryMixin):
 
     def __init__(self, library_or_path):
         if (isinstance(library_or_path, str)):
-            super(CLibrary_Unix, self).__init__(library_or_path)
+            super().__init__(library_or_path)
         else:
-            super(CLibrary_Unix, self).__init__(library_or_path._name, library_or_path._handle)
+            super().__init__(library_or_path._name, library_or_path._handle)
 
     @property
     def function_type(self):
diff --git a/can/interfaces/canalystii.py b/can/interfaces/canalystii.py
@@ -78,7 +78,7 @@ def __init__(self, channel, device=0, baud=None, Timing0=None, Timing1=None, can
         :param Timing1:
         :param can_filters: filters for packet
         """
-        super(CANalystIIBus, self).__init__(channel, can_filters)
+        super().__init__(channel, can_filters)
 
         if isinstance(channel, (list, tuple)):
             self.channels = channel
diff --git a/can/interfaces/ics_neovi/neovi_bus.py b/can/interfaces/ics_neovi/neovi_bus.py
@@ -45,7 +45,7 @@ def __init__(
             self, error_number, description_short, description_long,
             severity, restart_needed
     ):
-        super(ICSApiError, self).__init__(description_short)
+        super().__init__(description_short)
         self.error_number = error_number
         self.description_short = description_short
         self.description_long = description_long
@@ -97,8 +97,7 @@ def __init__(self, channel, can_filters=None, **kwargs):
         if ics is None:
             raise ImportError('Please install python-ics')
 
-        super(NeoViBus, self).__init__(
-            channel=channel, can_filters=can_filters, **kwargs)
+        super().__init__(channel=channel, can_filters=can_filters, **kwargs)
 
         logger.info("CAN Filters: {}".format(can_filters))
         logger.info("Got configuration of: {}".format(kwargs))
@@ -174,7 +173,7 @@ def get_serial_number(device):
         return str(device.SerialNumber)
 
     def shutdown(self):
-        super(NeoViBus, self).shutdown()
+        super().shutdown()
         ics.close_device(self.dev)
 
     @staticmethod
diff --git a/can/interfaces/iscan.py b/can/interfaces/iscan.py
@@ -86,7 +86,7 @@ def __init__(self, channel, bitrate=500000, poll_interval=0.01, **kwargs):
         self.poll_interval = poll_interval
         iscan.isCAN_DeviceInitEx(self.channel, self.BAUDRATES[bitrate])
 
-        super(IscanBus, self).__init__(channel=channel, bitrate=bitrate,
+        super().__init__(channel=channel, bitrate=bitrate,
             poll_interval=poll_interval, **kwargs)
 
     def _recv_internal(self, timeout):
@@ -159,7 +159,7 @@ class IscanError(CanError):
     }
 
     def __init__(self, function, error_code, arguments):
-        super(IscanError, self).__init__()
+        super().__init__()
         # :Status code
         self.error_code = error_code
         # :Function that failed
diff --git a/can/interfaces/ixxat/canlib.py b/can/interfaces/ixxat/canlib.py
@@ -389,7 +389,7 @@ def __init__(self, channel, can_filters=None, **kwargs):
             except (VCITimeout, VCIRxQueueEmptyError):
                 break
 
-        super(IXXATBus, self).__init__(channel=channel, can_filters=None, **kwargs)
+        super().__init__(channel=channel, can_filters=None, **kwargs)
 
     def _inWaiting(self):
         try:
@@ -532,7 +532,7 @@ class CyclicSendTask(LimitedDurationCyclicSendTaskABC,
     """A message in the cyclic transmit list."""
 
     def __init__(self, scheduler, msg, period, duration, resolution):
-        super(CyclicSendTask, self).__init__(msg, period, duration)
+        super().__init__(msg, period, duration)
         self._scheduler = scheduler
         self._index = None
         self._count = int(duration / period) if duration else 0
diff --git a/can/interfaces/ixxat/exceptions.py b/can/interfaces/ixxat/exceptions.py
@@ -23,8 +23,9 @@ class VCIError(CanError):
 
 class VCIRxQueueEmptyError(VCIError):
     """ Wraps the VCI_E_RXQUEUE_EMPTY error """
+
     def __init__(self):
-        super(VCIRxQueueEmptyError, self).__init__("Receive queue is empty")
+        super().__init__("Receive queue is empty")
 
 
 class VCIDeviceNotFoundError(CanError):
diff --git a/can/interfaces/kvaser/canlib.py b/can/interfaces/kvaser/canlib.py
@@ -67,7 +67,7 @@ class CANLIBError(CanError):
     """
 
     def __init__(self, function, error_code, arguments):
-        super(CANLIBError, self).__init__()
+        super().__init__()
         self.error_code = error_code
         self.function = function
         self.arguments = arguments
@@ -444,7 +444,7 @@ def __init__(self, channel, can_filters=None, **kwargs):
         self._timestamp_offset = time.time() - (timer.value * TIMESTAMP_FACTOR)
 
         self._is_filtered = False
-        super(KvaserBus, self).__init__(channel=channel, can_filters=can_filters, **kwargs)
+        super().__init__(channel=channel, can_filters=can_filters, **kwargs)
 
     def _apply_filters(self, filters):
         if filters and len(filters) == 1:
diff --git a/can/interfaces/nican.py b/can/interfaces/nican.py
@@ -201,7 +201,7 @@ def __init__(self, channel, can_filters=None, bitrate=None, log_errors=True, **k
         self.handle = ctypes.c_ulong()
         nican.ncOpenObject(channel, ctypes.byref(self.handle))
 
-        super(NicanBus, self).__init__(channel=channel,
+        super().__init__(channel=channel,
             can_filters=can_filters, bitrate=bitrate,
             log_errors=log_errors, **kwargs)
 
@@ -308,7 +308,7 @@ class NicanError(CanError):
     """Error from NI-CAN driver."""
 
     def __init__(self, function, error_code, arguments):
-        super(NicanError, self).__init__()
+        super().__init__()
         #: Status code
         self.error_code = error_code
         #: Function that failed
diff --git a/can/interfaces/pcan/pcan.py b/can/interfaces/pcan/pcan.py
@@ -195,7 +195,7 @@ def __init__(self, channel='PCAN_USBBUS1', state=BusState.ACTIVE, bitrate=500000
             if result != PCAN_ERROR_OK:
                 raise PcanError(self._get_formatted_error(result))
 
-        super(PcanBus, self).__init__(channel=channel, state=state, bitrate=bitrate, *args, **kwargs)
+        super().__init__(channel=channel, state=state, bitrate=bitrate, *args, **kwargs)
 
     def _get_formatted_error(self, error):
         """
@@ -399,7 +399,7 @@ def flash(self, flash):
         self.m_objPCANBasic.SetValue(self.m_PcanHandle, PCAN_CHANNEL_IDENTIFYING, bool(flash))
 
     def shutdown(self):
-        super(PcanBus, self).shutdown()
+        super().shutdown()
         self.m_objPCANBasic.Uninitialize(self.m_PcanHandle)
 
     @property
diff --git a/can/interfaces/serial/serial_can.py b/can/interfaces/serial/serial_can.py
@@ -58,7 +58,7 @@ def __init__(self, channel, baudrate=115200, timeout=0.1, rtscts=False,
         self.ser = serial.serial_for_url(
             channel, baudrate=baudrate, timeout=timeout, rtscts=rtscts)
 
-        super(SerialBus, self).__init__(channel=channel, *args, **kwargs)
+        super().__init__(channel=channel, *args, **kwargs)
 
     def shutdown(self):
         """
diff --git a/can/interfaces/slcan.py b/can/interfaces/slcan.py
@@ -99,7 +99,7 @@ def __init__(self, channel, ttyBaudrate=115200, bitrate=None,
 
         self.open()
 
-        super(slcanBus, self).__init__(channel, ttyBaudrate=115200,
+        super().__init__(channel, ttyBaudrate=115200,
                                        bitrate=None, rtscts=False, **kwargs)
 
     def write(self, string):
diff --git a/can/interfaces/socketcan/socketcan.py b/can/interfaces/socketcan/socketcan.py
@@ -285,7 +285,7 @@ def __init__(self, bcm_socket, message, period, duration=None):
         :param float period: The rate in seconds at which to send the message.
         :param float duration: Approximate duration in seconds to send the message.
         """
-        super(CyclicSendTask, self).__init__(message, period, duration)
+        super().__init__(message, period, duration)
         self.bcm_socket = bcm_socket
         self.duration = duration
         self._tx_setup(message)
@@ -345,7 +345,7 @@ class MultiRateCyclicSendTask(CyclicSendTask):
     """
 
     def __init__(self, channel, message, count, initial_period, subsequent_period):
-        super(MultiRateCyclicSendTask, self).__init__(channel, message, subsequent_period)
+        super().__init__(channel, message, subsequent_period)
 
         # Create a low level packed frame to pass to the kernel
         frame = build_can_frame(message)
@@ -500,7 +500,7 @@ def __init__(self, channel="", receive_own_messages=False, fd=False, **kwargs):
 
         bind_socket(self.socket, channel)
         kwargs.update({'receive_own_messages': receive_own_messages, 'fd': fd})
-        super(SocketcanBus, self).__init__(channel=channel, **kwargs)
+        super().__init__(channel=channel, **kwargs)
 
     def shutdown(self):
         """Stops all active periodic tasks and closes the socket."""
diff --git a/can/interfaces/systec/exceptions.py b/can/interfaces/systec/exceptions.py
@@ -6,6 +6,7 @@
 
 class UcanException(CanError):
     """ Base class for USB can errors. """
+
     def __init__(self, result, func, arguments):
         self.result = result.value
         self.func = func
@@ -20,7 +21,7 @@ def __str__(self):
 class UcanError(UcanException):
     """ Exception class for errors from USB-CAN-library. """
     def __init__(self, result, func, arguments):
-        super(UcanError, self).__init__(result, func, arguments)
+        super().__init__(result, func, arguments)
         self.return_msgs = {
             ReturnCode.ERR_RESOURCE: "could not created a resource (memory, handle, ...)",
             ReturnCode.ERR_MAXMODULES: "the maximum number of opened modules is reached",
@@ -46,8 +47,9 @@ def __init__(self, result, func, arguments):
 
 class UcanCmdError(UcanException):
     """ Exception class for errors from firmware in USB-CANmodul."""
+
     def __init__(self, result, func, arguments):
-        super(UcanCmdError, self).__init__(result, func, arguments)
+        super().__init__(result, func, arguments)
         self.return_msgs = {
             ReturnCode.ERRCMD_NOTEQU: "the received response does not match to the transmitted command",
             ReturnCode.ERRCMD_REGTST: "no access to the CAN controller",
@@ -69,8 +71,9 @@ def __init__(self, result, func, arguments):
 
 class UcanWarning(UcanException):
     """ Exception class for warnings, the function has been executed anyway. """
+
     def __init__(self, result, func, arguments):
-        super(UcanWarning, self).__init__(result, func, arguments)
+        super().__init__(result, func, arguments)
         self.return_msgs = {
             ReturnCode.WARN_NODATA: "no CAN messages received",
             ReturnCode.WARN_SYS_RXOVERRUN: "overrun in receive buffer of the kernel driver",
diff --git a/can/interfaces/systec/structures.py b/can/interfaces/systec/structures.py
@@ -36,7 +36,7 @@ class CanMsg(Structure):
     ]
 
     def __init__(self, id=0, frame_format=MsgFrameFormat.MSG_FF_STD, data=[]):
-        super(CanMsg, self).__init__(id, frame_format, len(data), (BYTE * 8)(*data), 0)
+        super().__init__(id, frame_format, len(data), (BYTE * 8)(*data), 0)
 
     def __eq__(self, other):
         if not isinstance(other, CanMsg):
@@ -121,8 +121,8 @@ class InitCanParam(Structure):
     ]
 
     def __init__(self, mode, BTR, OCR, AMR, ACR, baudrate, rx_buffer_entries, tx_buffer_entries):
-        super(InitCanParam, self).__init__(sizeof(InitCanParam), mode, BTR >> 8, BTR, OCR, AMR, ACR,
-                                           baudrate, rx_buffer_entries, tx_buffer_entries)
+        super().__init__(sizeof(InitCanParam), mode, BTR >> 8, BTR, OCR, AMR, ACR,
+                        baudrate, rx_buffer_entries, tx_buffer_entries)
 
     def __eq__(self, other):
         if not isinstance(other, InitCanParam):
diff --git a/can/interfaces/systec/ucanbus.py b/can/interfaces/systec/ucanbus.py
@@ -18,7 +18,7 @@ class Ucan(UcanServer):
     """
 
     def __init__(self):
-        super(Ucan, self).__init__()
+        super().__init__()
         self._msg_received_event = Event()
 
     def can_msg_received_event(self, channel):
@@ -29,7 +29,7 @@ def read_can_msg(self, channel, count, timeout):
         if self.get_msg_pending(channel, PendingFlags.PENDING_FLAG_RX_DLL) == 0:
             if not self._msg_received_event.wait(timeout):
                 return None, False
-        return super(Ucan, self).read_can_msg(channel, 1)
+        return super().read_can_msg(channel, 1)
 
 
 class UcanBus(BusABC):
@@ -132,7 +132,7 @@ def __init__(self, channel, can_filters=None, **kwargs):
             self.channel,
             self._ucan.get_baudrate_message(self.BITRATES[bitrate])
         )
-        super(UcanBus, self).__init__(channel=channel, can_filters=can_filters, **kwargs)
+        super().__init__(channel=channel, can_filters=can_filters, **kwargs)
 
     def _recv_internal(self, timeout):
         message, _ = self._ucan.read_can_msg(self.channel, 1, timeout)
diff --git a/can/interfaces/usb2can/usb2canInterface.py b/can/interfaces/usb2can/usb2canInterface.py
@@ -109,8 +109,8 @@ def __init__(self, channel=None, dll="usb2can.dll", flags=0x00000008,
         connector = "{}; {}".format(device_id, baudrate)
         self.handle = self.can.open(connector, flags)
 
-        super(Usb2canBus, self).__init__(channel=channel, dll=dll, flags=flags,
-                                         bitrate=bitrate, *args, **kwargs)
+        super().__init__(channel=channel, dll=dll, flags=flags, bitrate=bitrate,
+                         *args, **kwargs)
 
     def send(self, msg, timeout=None):
         tx = message_convert_tx(msg)
diff --git a/can/interfaces/vector/canlib.py b/can/interfaces/vector/canlib.py
@@ -210,7 +210,7 @@ def __init__(self, channel, can_filters=None, poll_interval=0.01,
         self._time_offset = time.time() - offset.value * 1e-9
 
         self._is_filtered = False
-        super(VectorBus, self).__init__(channel=channel, can_filters=can_filters, **kwargs)
+        super().__init__(channel=channel, can_filters=can_filters, **kwargs)
 
     def _apply_filters(self, filters):
         if filters:
diff --git a/can/interfaces/vector/exceptions.py b/can/interfaces/vector/exceptions.py
@@ -10,5 +10,4 @@ class VectorError(CanError):
 
     def __init__(self, error_code, error_string, function):
         self.error_code = error_code
-        text = "%s failed (%s)" % (function, error_string)
-        super(VectorError, self).__init__(text)
+        super().__init__(f"{function} failed ({error_string})")
diff --git a/can/interfaces/virtual.py b/can/interfaces/virtual.py
@@ -45,7 +45,7 @@ class VirtualBus(BusABC):
     """
 
     def __init__(self, channel=None, receive_own_messages=False, rx_queue_size=0, **kwargs):
-        super(VirtualBus, self).__init__(channel=channel, receive_own_messages=receive_own_messages, **kwargs)
+        super().__init__(channel=channel, receive_own_messages=receive_own_messages, **kwargs)
 
         # the channel identifier may be an arbitrary object
         self.channel_id = channel
diff --git a/can/io/asc.py b/can/io/asc.py
@@ -37,7 +37,7 @@ def __init__(self, file):
                      If this is a file-like object, is has to opened in text
                      read mode, not binary read mode.
         """
-        super(ASCReader, self).__init__(file, mode='r')
+        super().__init__(file, mode='r')
 
     @staticmethod
     def _extract_can_id(str_can_id):
@@ -140,7 +140,7 @@ def __init__(self, file, channel=1):
         :param channel: a default channel to use when the message does not
                         have a channel set
         """
-        super(ASCWriter, self).__init__(file, mode='w')
+        super().__init__(file, mode='w')
         self.channel = channel
 
         # write start of file header
@@ -157,7 +157,7 @@ def __init__(self, file, channel=1):
     def stop(self):
         if not self.file.closed:
             self.file.write("End TriggerBlock\n")
-        super(ASCWriter, self).stop()
+        super().stop()
 
     def log_event(self, message, timestamp=None):
         """Add a message to the log file.
diff --git a/can/io/blf.py b/can/io/blf.py
diff --git a/can/io/canutils.py b/can/io/canutils.py
diff --git a/can/io/csv.py b/can/io/csv.py
diff --git a/can/io/generic.py b/can/io/generic.py
diff --git a/can/io/printer.py b/can/io/printer.py
diff --git a/can/io/sqlite.py b/can/io/sqlite.py
diff --git a/can/thread_safe_bus.py b/can/thread_safe_bus.py
diff --git a/can/viewer.py b/can/viewer.py
