Pull from upstream

.gitignore

@@ -1,5 +1,8 @@
 test/__tempdir__/
 .pytest_cache/
+.mypy_cache/
+.dmypy.json
+dmypy.json
 
 # -------------------------
 # below: https://github.com/github/gitignore/blob/da00310ccba9de9a988cc973ef5238ad2c1460e9/Python.gitignore

.travis.yml

@@ -84,6 +84,24 @@ jobs:
         # warnings to the .pylintrc-wip file to prevent them from being
         # re-introduced
         - pylint --rcfile=.pylintrc-wip can/
+        # mypy checking
+        - mypy
+          --python-version=3.7
+          --ignore-missing-imports
+          --no-implicit-optional
+          can/bit_timing.py
+          can/broadcastmanager.py
+          can/bus.py
+          can/interface.py
+          can/listener.py
+          can/logger.py
+          can/message.py
+          can/notifier.py
+          can/player.py
+          can/thread_safe_bus.py
+          can/typechecking.py
+          can/util.py
+          can/io/**.py
     - stage: linter
       name: "Formatting Checks"
       python: "3.7"

README.rst

@@ -1,12 +1,26 @@
 python-can
 ==========
 
-|release| |docs| |build_travis| |build_appveyor| |coverage| |downloads| |formatter|
+|release| |downloads| |downloads_monthly| |formatter|
+
+|docs| |build_travis| |build_appveyor| |coverage|
 
 .. |release| image:: https://img.shields.io/pypi/v/python-can.svg
    :target: https://pypi.python.org/pypi/python-can/
    :alt: Latest Version on PyPi
 
+.. |downloads| image:: https://pepy.tech/badge/python-can
+   :target: https://pepy.tech/project/python-can
+   :alt: Downloads on PePy
+
+.. |downloads_monthly| image:: https://pepy.tech/badge/python-can/month
+   :target: https://pepy.tech/project/python-can/month
+   :alt: Monthly downloads on PePy
+
+.. |formatter| image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://github.com/python/black
+   :alt: This project uses the black formatter.
+
 .. |docs| image:: https://readthedocs.org/projects/python-can/badge/?version=stable
    :target: https://python-can.readthedocs.io/en/stable/
    :alt: Documentation
@@ -23,14 +37,6 @@ python-can
    :target: https://codecov.io/gh/hardbyte/python-can/branch/develop
    :alt: Test coverage reports on Codecov.io
 
-.. |downloads| image:: https://pepy.tech/badge/python-can
-   :target: https://pepy.tech/project/python-can
-   :alt: Downloads on PePy
-
-.. |formatter| image:: https://img.shields.io/badge/code%20style-black-000000.svg
-   :target: https://github.com/python/black
-   :alt: This project uses the black formatter.
-
 The **C**\ ontroller **A**\ rea **N**\ etwork is a bus standard designed
 to allow microcontrollers and devices to communicate with each other. It
 has priority based bus arbitration and reliable deterministic
@@ -44,13 +50,13 @@ messages on a can bus.
 The library currently supports Python 3.6+ as well as PyPy 3 and runs
 on Mac, Linux and Windows.
 
-=============================  ===========
-Library Version                Python
------------------------------  -----------
-  2.x                          2.6+, 3.4+
-  3.x                          2.7+, 3.5+
-  4.x *(currently on devlop)*  3.6+
-=============================  ===========
+==============================  ===========
+Library Version                 Python
+------------------------------  -----------
+  2.x                           2.6+, 3.4+
+  3.x                           2.7+, 3.5+
+  4.x *(currently on develop)*  3.6+
+==============================  ===========
 
 
 Features

can/__init__.py

@@ -6,11 +6,13 @@
 
 import logging
 
+from typing import Dict, Any
+
 __version__ = "3.2.0"
 
 log = logging.getLogger("can")
 
-rc = dict()
+rc: Dict[str, Any] = dict()
 
 
 class CanError(IOError):

can/bit_timing.py

@@ -1,4 +1,4 @@
-from typing import Union
+from typing import Optional, Union
 
 
 class BitTiming:
@@ -27,15 +27,15 @@ class BitTiming:
 
     def __init__(
         self,
-        bitrate: int = None,
-        f_clock: int = None,
-        brp: int = None,
-        tseg1: int = None,
-        tseg2: int = None,
-        sjw: int = None,
+        bitrate: Optional[int] = None,
+        f_clock: Optional[int] = None,
+        brp: Optional[int] = None,
+        tseg1: Optional[int] = None,
+        tseg2: Optional[int] = None,
+        sjw: Optional[int] = None,
         nof_samples: int = 1,
-        btr0: int = None,
-        btr1: int = None,
+        btr0: Optional[int] = None,
+        btr1: Optional[int] = None,
     ):
         """
         :param int bitrate:

can/broadcastmanager.py

@@ -7,12 +7,27 @@
 :meth:`can.BusABC.send_periodic`.
 """
 
+from typing import Optional, Sequence, Tuple, Union, TYPE_CHECKING
+
+from can import typechecking
+
+if TYPE_CHECKING:
+    from can.bus import BusABC
+
+from can.message import Message
+
 import abc
 import logging
 import threading
 import time
 
-import can
+# try to import win32event for event-based cyclic send task(needs pywin32 package)
+try:
+    import win32event
+
+    HAS_EVENTS = True
+except ImportError:
+    HAS_EVENTS = False
 
 log = logging.getLogger("can.bcm")
 
@@ -36,11 +51,11 @@ class CyclicSendTaskABC(CyclicTask):
     Message send task with defined period
     """
 
-    def __init__(self, messages, period):
+    def __init__(self, messages: Union[Sequence[Message], Message], period: float):
         """
-        :param Union[Sequence[can.Message], can.Message] messages:
+        :param messages:
             The messages to be sent periodically.
-        :param float period: The rate in seconds at which to send the messages.
+        :param period: The rate in seconds at which to send the messages.
         """
         messages = self._check_and_convert_messages(messages)
 
@@ -50,7 +65,9 @@ def __init__(self, messages, period):
         self.messages = messages
 
     @staticmethod
-    def _check_and_convert_messages(messages):
+    def _check_and_convert_messages(
+        messages: Union[Sequence[Message], Message]
+    ) -> Tuple[Message, ...]:
         """Helper function to convert a Message or Sequence of messages into a
         tuple, and raises an error when the given value is invalid.
 
@@ -60,7 +77,7 @@ def _check_and_convert_messages(messages):
         Should be called when the cyclic task is initialized
         """
         if not isinstance(messages, (list, tuple)):
-            if isinstance(messages, can.Message):
+            if isinstance(messages, Message):
                 messages = [messages]
             else:
                 raise ValueError("Must be either a list, tuple, or a Message")
@@ -84,13 +101,18 @@ def _check_and_convert_messages(messages):
 
 
 class LimitedDurationCyclicSendTaskABC(CyclicSendTaskABC):
-    def __init__(self, messages, period, duration):
+    def __init__(
+        self,
+        messages: Union[Sequence[Message], Message],
+        period: float,
+        duration: Optional[float],
+    ):
         """Message send task with a defined duration and period.
 
-        :param Union[Sequence[can.Message], can.Message] messages:
+        :param messages:
             The messages to be sent periodically.
-        :param float period: The rate in seconds at which to send the messages.
-        :param float duration:
+        :param period: The rate in seconds at which to send the messages.
+        :param duration:
             Approximate duration in seconds to continue sending messages. If
             no duration is provided, the task will continue indefinitely.
         """
@@ -110,7 +132,7 @@ def start(self):
 class ModifiableCyclicTaskABC(CyclicSendTaskABC):
     """Adds support for modifying a periodic message"""
 
-    def _check_modified_messages(self, messages):
+    def _check_modified_messages(self, messages: Tuple[Message, ...]):
         """Helper function to perform error checking when modifying the data in
         the cyclic task.
 
@@ -130,12 +152,12 @@ def _check_modified_messages(self, messages):
                 "from when the task was created"
             )
 
-    def modify_data(self, messages):
+    def modify_data(self, messages: Union[Sequence[Message], Message]):
         """Update the contents of the periodically sent messages, without
         altering the timing.
 
-        :param Union[Sequence[can.Message], can.Message] messages:
-            The messages with the new :attr:`can.Message.data`.
+        :param messages:
+            The messages with the new :attr:`Message.data`.
 
             Note: The arbitration ID cannot be changed.
 
@@ -153,35 +175,57 @@ class MultiRateCyclicSendTaskABC(CyclicSendTaskABC):
     """A Cyclic send task that supports switches send frequency after a set time.
     """
 
-    def __init__(self, channel, messages, count, initial_period, subsequent_period):
+    def __init__(
+        self,
+        channel: typechecking.Channel,
+        messages: Union[Sequence[Message], Message],
+        count: int,
+        initial_period: float,
+        subsequent_period: float,
+    ):
         """
         Transmits a message `count` times at `initial_period` then continues to
         transmit messages at `subsequent_period`.
 
         :param channel: See interface specific documentation.
-        :param Union[Sequence[can.Message], can.Message] messages:
-        :param int count:
-        :param float initial_period:
-        :param float subsequent_period:
+        :param messages:
+        :param count:
+        :param initial_period:
+        :param subsequent_period:
         """
-        super().__init__(channel, messages, subsequent_period)
+        super().__init__(messages, subsequent_period)
+        self._channel = channel
 
 
 class ThreadBasedCyclicSendTask(
     ModifiableCyclicTaskABC, LimitedDurationCyclicSendTaskABC, RestartableCyclicTaskABC
 ):
     """Fallback cyclic send task using thread."""
 
-    def __init__(self, bus, lock, messages, period, duration=None):
+    def __init__(
+        self,
+        bus: "BusABC",
+        lock: threading.Lock,
+        messages: Union[Sequence[Message], Message],
+        period: float,
+        duration: Optional[float] = None,
+    ):
         super().__init__(messages, period, duration)
         self.bus = bus
         self.send_lock = lock
         self.stopped = True
         self.thread = None
-        self.end_time = time.time() + duration if duration else None
+        self.end_time = time.perf_counter() + duration if duration else None
+
+        if HAS_EVENTS:
+            self.period_ms: int = int(round(period * 1000, 0))
+            self.event = win32event.CreateWaitableTimer(None, False, None)
+
         self.start()
 
     def stop(self):
+        if HAS_EVENTS:
+            win32event.CancelWaitableTimer(self.event.handle)
         self.stopped = True
 
     def start(self):
@@ -190,22 +234,32 @@ def start(self):
             name = "Cyclic send task for 0x%X" % (self.messages[0].arbitration_id)
             self.thread = threading.Thread(target=self._run, name=name)
             self.thread.daemon = True
+
+            if HAS_EVENTS:
+                win32event.SetWaitableTimer(
+                    self.event.handle, 0, self.period_ms, None, None, False
+                )
+
             self.thread.start()
 
     def _run(self):
         msg_index = 0
         while not self.stopped:
             # Prevent calling bus.send from multiple threads
             with self.send_lock:
-                started = time.time()
+                started = time.perf_counter()
                 try:
                     self.bus.send(self.messages[msg_index])
                 except Exception as exc:
                     log.exception(exc)
                     break
-            if self.end_time is not None and time.time() >= self.end_time:
+            if self.end_time is not None and time.perf_counter() >= self.end_time:
                 break
             msg_index = (msg_index + 1) % len(self.messages)
-            # Compensate for the time it takes to send the message
-            delay = self.period - (time.time() - started)
-            time.sleep(max(0.0, delay))
+
+            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))