Merge branch 'develop' into feature/bus_fd_field

# Conflicts:
#	can/__init__.py
#	can/interfaces/canalystii.py
#	can/interfaces/cantact.py
#	can/interfaces/etas/__init__.py
#	can/interfaces/gs_usb.py
#	can/interfaces/ics_neovi/neovi_bus.py
#	can/interfaces/iscan.py
#	can/interfaces/ixxat/canlib_vcinpl.py
#	can/interfaces/ixxat/canlib_vcinpl2.py
#	can/interfaces/kvaser/canlib.py
#	can/interfaces/neousys/neousys.py
#	can/interfaces/nican.py
#	can/interfaces/nixnet.py
#	can/interfaces/pcan/pcan.py
#	can/interfaces/robotell.py
#	can/interfaces/serial/serial_can.py
#	can/interfaces/slcan.py
#	can/interfaces/systec/ucanbus.py
#	can/interfaces/udp_multicast/bus.py
#	can/interfaces/usb2can/usb2canInterface.py
#	can/interfaces/vector/canlib.py
#	test/serial_test.py
#	test/test_interface_canalystii.py

Author: zariiii9003

.github/workflows/ci.yml

@@ -95,6 +95,9 @@ jobs:
     - name: mypy 3.11
       run: |
         mypy --python-version 3.11 .
+    - name: ruff
+      run: |
+        ruff check can
     - name: pylint
       run: |
         pylint --rcfile=.pylintrc \

.pylintrc

@@ -438,6 +438,8 @@ known-standard-library=
 # Force import order to recognize a module as part of a third party library.
 known-third-party=enchant
 
+# Allow explicit reexports by alias from a package __init__
+allow-reexport-from-package=no
 
 [CLASSES]
 
@@ -498,5 +500,5 @@ min-public-methods=2
 
 # Exceptions that will emit a warning when being caught. Defaults to
 # "BaseException, Exception".
-overgeneral-exceptions=BaseException,
-                       Exception
+overgeneral-exceptions=builtins.BaseException,
+                       builtins.Exception

can/__init__.py

@@ -6,47 +6,105 @@
 """
 
 import logging
-from typing import Dict, Any
+from typing import Any, Dict
 
 __version__ = "4.1.0"
+__all__ = [
+    "ASCReader",
+    "ASCWriter",
+    "AsyncBufferedReader",
+    "BitTiming",
+    "BitTimingFd",
+    "BLFReader",
+    "BLFWriter",
+    "broadcastmanager",
+    "BufferedReader",
+    "Bus",
+    "BusABC",
+    "BusState",
+    "CanError",
+    "CanInitializationError",
+    "CanInterfaceNotImplementedError",
+    "CanOperationError",
+    "CanProtocol",
+    "CanTimeoutError",
+    "CanutilsLogReader",
+    "CanutilsLogWriter",
+    "CSVReader",
+    "CSVWriter",
+    "CyclicSendTaskABC",
+    "detect_available_configs",
+    "interface",
+    "LimitedDurationCyclicSendTaskABC",
+    "Listener",
+    "Logger",
+    "LogReader",
+    "ModifiableCyclicTaskABC",
+    "Message",
+    "MessageSync",
+    "Notifier",
+    "Printer",
+    "RedirectReader",
+    "RestartableCyclicTaskABC",
+    "set_logging_level",
+    "SizedRotatingLogger",
+    "SqliteReader",
+    "SqliteWriter",
+    "ThreadSafeBus",
+    "typechecking",
+    "TRCFileVersion",
+    "TRCReader",
+    "TRCWriter",
+    "util",
+    "VALID_INTERFACES",
+]
 
 log = logging.getLogger("can")
 
 rc: Dict[str, Any] = {}
 
-from .listener import Listener, BufferedReader, RedirectReader, AsyncBufferedReader
-
+from . import typechecking  # isort:skip
+from . import util  # isort:skip
+from . import broadcastmanager, interface
+from .bit_timing import BitTiming, BitTimingFd
+from .broadcastmanager import (
+    CyclicSendTaskABC,
+    LimitedDurationCyclicSendTaskABC,
+    ModifiableCyclicTaskABC,
+    RestartableCyclicTaskABC,
+)
+from .bus import BusABC, BusState, CanProtocol
 from .exceptions import (
     CanError,
-    CanInterfaceNotImplementedError,
     CanInitializationError,
+    CanInterfaceNotImplementedError,
     CanOperationError,
     CanTimeoutError,
 )
-
-from .util import set_logging_level
-
-from .message import Message
-from .bus import BusABC, BusState, CanProtocol
-from .thread_safe_bus import ThreadSafeBus
-from .notifier import Notifier
-from .interfaces import VALID_INTERFACES
-from . import interface
 from .interface import Bus, detect_available_configs
-from .bit_timing import BitTiming, BitTimingFd
-
-from .io import Logger, SizedRotatingLogger, Printer, LogReader, MessageSync
-from .io import ASCWriter, ASCReader
-from .io import BLFReader, BLFWriter
-from .io import CanutilsLogReader, CanutilsLogWriter
-from .io import CSVWriter, CSVReader
-from .io import SqliteWriter, SqliteReader
-from .io import TRCReader, TRCWriter, TRCFileVersion
-
-from .broadcastmanager import (
-    CyclicSendTaskABC,
-    LimitedDurationCyclicSendTaskABC,
-    ModifiableCyclicTaskABC,
-    MultiRateCyclicSendTaskABC,
-    RestartableCyclicTaskABC,
+from .interfaces import VALID_INTERFACES
+from .io import (
+    ASCReader,
+    ASCWriter,
+    BLFReader,
+    BLFWriter,
+    CanutilsLogReader,
+    CanutilsLogWriter,
+    CSVReader,
+    CSVWriter,
+    Logger,
+    LogReader,
+    MessageSync,
+    Printer,
+    SizedRotatingLogger,
+    SqliteReader,
+    SqliteWriter,
+    TRCFileVersion,
+    TRCReader,
+    TRCWriter,
 )
+from .listener import AsyncBufferedReader, BufferedReader, Listener, RedirectReader
+from .message import Message
+from .notifier import Notifier
+from .thread_safe_bus import ThreadSafeBus
+from .util import set_logging_level

can/bit_timing.py

@@ -1,8 +1,8 @@
 # pylint: disable=too-many-lines
 import math
-from typing import List, Mapping, Iterator, cast
+from typing import Iterator, List, Mapping, cast
 
-from can.typechecking import BitTimingFdDict, BitTimingDict
+from can.typechecking import BitTimingDict, BitTimingFdDict
 
 
 class BitTiming(Mapping):

can/broadcastmanager.py

@@ -5,30 +5,39 @@
 :meth:`can.BusABC.send_periodic`.
 """
 
-from typing import Optional, Sequence, Tuple, Union, Callable, TYPE_CHECKING
+import abc
+import logging
+import sys
+import threading
+import time
+from typing import TYPE_CHECKING, Callable, Optional, Sequence, Tuple, Union
+
+from typing_extensions import Final
 
 from can import typechecking
+from can.message import Message
 
 if TYPE_CHECKING:
     from can.bus import BusABC
 
-from can.message import Message
-
-import abc
-import logging
-import threading
-import time
 
 # try to import win32event for event-based cyclic send task (needs the pywin32 package)
+USE_WINDOWS_EVENTS = False
 try:
     import win32event
 
-    HAS_EVENTS = True
+    # Python 3.11 provides a more precise sleep implementation on Windows, so this is not necessary.
+    # Put version check here, so mypy does not complain about `win32event` not being defined.
+    if sys.version_info < (3, 11):
+        USE_WINDOWS_EVENTS = True
 except ImportError:
-    HAS_EVENTS = False
+    pass
 
 log = logging.getLogger("can.bcm")
 
+NANOSECONDS_IN_SECOND: Final[int] = 1_000_000_000
+NANOSECONDS_IN_MILLISECOND: Final[int] = 1_000_000
+
 
 class CyclicTask(abc.ABC):
     """
@@ -64,6 +73,7 @@ def __init__(
         # Take the Arbitration ID of the first element
         self.arbitration_id = messages[0].arbitration_id
         self.period = period
+        self.period_ns = int(round(period * 1e9))
         self.messages = messages
 
     @staticmethod
@@ -246,7 +256,7 @@ def __init__(
         )
         self.on_error = on_error
 
-        if HAS_EVENTS:
+        if USE_WINDOWS_EVENTS:
             self.period_ms = int(round(period * 1000, 0))
             try:
                 self.event = win32event.CreateWaitableTimerEx(
@@ -261,7 +271,7 @@ def __init__(
         self.start()
 
     def stop(self) -> None:
-        if HAS_EVENTS:
+        if USE_WINDOWS_EVENTS:
             win32event.CancelWaitableTimer(self.event.handle)
         self.stopped = True
 
@@ -272,7 +282,7 @@ def start(self) -> None:
             self.thread = threading.Thread(target=self._run, name=name)
             self.thread.daemon = True
 
-            if HAS_EVENTS:
+            if USE_WINDOWS_EVENTS:
                 win32event.SetWaitableTimer(
                     self.event.handle, 0, self.period_ms, None, None, False
                 )
@@ -281,10 +291,11 @@ def start(self) -> None:
 
     def _run(self) -> None:
         msg_index = 0
+        msg_due_time_ns = time.perf_counter_ns()
+
         while not self.stopped:
             # Prevent calling bus.send from multiple threads
             with self.send_lock:
-                started = time.perf_counter()
                 try:
                     self.bus.send(self.messages[msg_index])
                 except Exception as exc:  # pylint: disable=broad-except
@@ -294,13 +305,19 @@ def _run(self) -> None:
                             break
                     else:
                         break
+            msg_due_time_ns += self.period_ns
             if self.end_time is not None and time.perf_counter() >= self.end_time:
                 break
             msg_index = (msg_index + 1) % len(self.messages)
 
-            if HAS_EVENTS:
-                win32event.WaitForSingleObject(self.event.handle, self.period_ms)
-            else:
-                # Compensate for the time it takes to send the message
-                delay = self.period - (time.perf_counter() - started)
-                time.sleep(max(0.0, delay))
+            # Compensate for the time it takes to send the message
+            delay_ns = msg_due_time_ns - time.perf_counter_ns()
+
+            if delay_ns > 0:
+                if USE_WINDOWS_EVENTS:
+                    win32event.WaitForSingleObject(
+                        self.event.handle,
+                        int(round(delay_ns / NANOSECONDS_IN_MILLISECOND)),
+                    )
+                else:
+                    time.sleep(delay_ns / NANOSECONDS_IN_SECOND)

can/bus.py

@@ -2,18 +2,17 @@
 Contains the ABC bus implementation and its documentation.
 """
 
-from typing import cast, Any, Iterator, List, Optional, Sequence, Tuple, Union
-
-import can.typechecking
-
-from abc import ABC, ABCMeta, abstractmethod
-import can
+import contextlib
 import logging
 import threading
-from time import time
+from abc import ABC, ABCMeta, abstractmethod
 from enum import Enum, auto
+from time import time
+from typing import Any, Iterator, List, Optional, Sequence, Tuple, Union, cast
 
-from can.broadcastmanager import ThreadBasedCyclicSendTask, CyclicSendTaskABC
+import can
+import can.typechecking
+from can.broadcastmanager import CyclicSendTaskABC, ThreadBasedCyclicSendTask
 from can.message import Message
 
 LOG = logging.getLogger(__name__)
@@ -52,13 +51,15 @@ class BusABC(metaclass=ABCMeta):
     #: Log level for received messages
     RECV_LOGGING_LEVEL = 9
 
+    _is_shutdown: bool = False
+
     @abstractmethod
     def __init__(
         self,
         channel: Any,
         protocol: CanProtocol = CanProtocol.CAN_20,
         can_filters: Optional[can.typechecking.CanFilters] = None,
-        **kwargs: object
+        **kwargs: object,
     ):
         """Construct and open a CAN bus instance of the specified type.
 
@@ -110,7 +111,6 @@ def recv(self, timeout: Optional[float] = None) -> Optional[Message]:
         time_left = timeout
 
         while True:
-
             # try to get a message
             msg, already_filtered = self._recv_internal(timeout=time_left)
 
@@ -126,7 +126,6 @@ def recv(self, timeout: Optional[float] = None) -> Optional[Message]:
             # try next one only if there still is time, and with
             # reduced timeout
             else:
-
                 time_left = timeout - (time() - start)
 
                 if time_left > 0:
@@ -320,6 +319,10 @@ def stop_all_periodic_tasks(self, remove_tasks: bool = True) -> None:
         :param remove_tasks:
             Stop tracking the stopped tasks.
         """
+        if not hasattr(self, "_periodic_tasks"):
+            # avoid AttributeError for partially initialized BusABC instance
+            return
+
         for task in self._periodic_tasks:
             # we cannot let `task.stop()` modify `self._periodic_tasks` while we are
             # iterating over it (#634)
@@ -434,9 +437,15 @@ def flush_tx_buffer(self) -> None:
 
     def shutdown(self) -> None:
         """
-        Called to carry out any interface specific cleanup required
-        in shutting down a bus.
+        Called to carry out any interface specific cleanup required in shutting down a bus.
+
+        This method can be safely called multiple times.
         """
+        if self._is_shutdown:
+            LOG.debug("%s is already shut down", self.__class__)
+            return
+
+        self._is_shutdown = True
         self.stop_all_periodic_tasks()
 
     def __enter__(self):
@@ -445,6 +454,14 @@ def __enter__(self):
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.shutdown()
 
+    def __del__(self) -> None:
+        if not self._is_shutdown:
+            LOG.warning("%s was not properly shut down", self.__class__)
+            # We do some best-effort cleanup if the user
+            # forgot to properly close the bus instance
+            with contextlib.suppress(AttributeError):
+                self.shutdown()
+
     @property
     def state(self) -> BusState:
         """