Make black and pydocstyle happy

bessman · bessman · commit 0cbc2bd0ca99 · 2020-10-13T11:45:47.000+02:00
diff --git a/PSL/digital_channel.py b/PSL/digital_channel.py
@@ -1,5 +1,4 @@
-"""Objects related to the PSLab's digital input channels.
-"""
+"""Objects related to the PSLab's digital input channels."""
 
 import numpy as np
 
diff --git a/PSL/logic_analyzer.py b/PSL/logic_analyzer.py
@@ -404,9 +404,11 @@ def _capture_four(self, e2e_time: float):
         self._device.send_byte(self._prescaler)
 
         try:
-            trigger = {0: 4, 1: 8, 2: 16,}[
-                self._trigger_channel.number
-            ] | self._trigger_mode
+            trigger = {
+                0: 4,
+                1: 8,
+                2: 16,
+            }[self._trigger_channel.number] | self._trigger_mode
         except KeyError:
             e = "Triggering is only possible on LA1, LA2, or LA3."
             raise NotImplementedError(e)
@@ -592,7 +594,7 @@ def _get_initial_states_and_progress(self) -> Tuple[Dict[str, bool], List[int]]:
         return initial_states, progress
 
     def configure_trigger(self, trigger_channel: str, trigger_mode: str):
-        """Setup trigger channel and trigger condition.
+        """Set up trigger channel and trigger condition.
 
         Parameters
         ----------
@@ -618,17 +620,20 @@ def _configure_trigger(self, channels: int):
                 "sixteen rising": 5,
             }[self.trigger_mode]
         elif channels == 2:
-            self._trigger_mode = {"disabled": 0, "falling": 3, "rising": 1,}[
-                self.trigger_mode
-            ]
+            self._trigger_mode = {
+                "disabled": 0,
+                "falling": 3,
+                "rising": 1,
+            }[self.trigger_mode]
         elif channels == 4:
-            self._trigger_mode = {"disabled": 0, "falling": 1, "rising": 3,}[
-                self.trigger_mode
-            ]
+            self._trigger_mode = {
+                "disabled": 0,
+                "falling": 1,
+                "rising": 3,
+            }[self.trigger_mode]
 
     def stop(self):
-        """Stop a running :meth:`capture` function.
-        """
+        """Stop a running :meth:`capture` function."""
         self._device.send_byte(CP.TIMING)
         self._device.send_byte(CP.STOP_LA)
         self._device.get_ack()
@@ -657,7 +662,7 @@ def get_states(self) -> Dict[str, bool]:
     def count_pulses(
         self, channel: str, interval: float = 1, block: bool = True
     ) -> Union[int, None]:
-        """	Count pulses on a digital input.
+        """Count pulses on a digital input.
 
         The counter is 16 bits, so it will roll over after 65535 pulses. This method
         can be used at the same time as the oscilloscope.
diff --git a/PSL/oscilloscope.py b/PSL/oscilloscope.py
@@ -45,7 +45,12 @@ def __init__(self, device: packet_handler.Handler = None):
         self._trigger_enabled = False
         self._trigger_channel = "CH1"
 
-    def capture(self, channels: int, samples: int, timegap: float,) -> np.ndarray:
+    def capture(
+        self,
+        channels: int,
+        samples: int,
+        timegap: float,
+    ) -> np.ndarray:
         """Capture an oscilloscope trace from the specified input channels.
 
         This is a blocking call.
diff --git a/PSL/packet_handler.py b/PSL/packet_handler.py
@@ -77,7 +77,10 @@ def _list_ports() -> List[str]:  # Promote to public?
         return [p.device for p in list_ports.comports()]
 
     def connect(
-        self, port: str = None, baudrate: int = 1000000, timeout: float = 1.0,
+        self,
+        port: str = None,
+        baudrate: int = 1000000,
+        timeout: float = 1.0,
     ):
         """Connect to PSLab.
 
@@ -100,7 +103,10 @@ def connect(
         """
         # serial.Serial opens automatically if port is not None.
         self.interface = serial.Serial(
-            port=port, baudrate=baudrate, timeout=timeout, write_timeout=timeout,
+            port=port,
+            baudrate=baudrate,
+            timeout=timeout,
+            write_timeout=timeout,
         )
 
         if self.interface.is_open:
@@ -132,7 +138,10 @@ def disconnect(self):
         self.interface.close()
 
     def reconnect(
-        self, port: str = None, baudrate: int = None, timeout: float = None,
+        self,
+        port: str = None,
+        baudrate: int = None,
+        timeout: float = None,
     ):
         """Reconnect to PSLab.
 
@@ -151,7 +160,10 @@ def reconnect(
         timeout = self.interface.timeout if timeout is None else timeout
 
         self.interface = serial.Serial(
-            port=port, baudrate=baudrate, timeout=timeout, write_timeout=timeout,
+            port=port,
+            baudrate=baudrate,
+            timeout=timeout,
+            write_timeout=timeout,
         )
         self.connect()
 
@@ -265,11 +277,34 @@ def _receive(self, size: int) -> int:
         return retval
 
     def read(self, number_of_bytes: int) -> bytes:
+        """Log incoming bytes.
+
+        Wrapper for Serial.read().
+
+        Parameters
+        ----------
+        number_of_bytes : int
+            Number of bytes to read from the serial port.
+
+        Returns
+        -------
+        bytes
+            Bytes read from the serial port.
+        """
         data = self.interface.read(number_of_bytes)
         self._write_log(data, "RX")
         return data
 
     def write(self, data: bytes):
+        """Log outgoing bytes.
+
+        Wrapper for Serial.write().
+
+        Parameters
+        ----------
+        data : int
+            Bytes to write to the serial port.
+        """
         self.interface.write(data)
         self._write_log(data, "TX")
 
@@ -351,47 +386,63 @@ class MockHandler(Handler):
     VERSION = "PSLab vMOCK"
 
     def __init__(
-        self, port: str = None, baudrate: int = 1000000, timeout: float = 1.0,
+        self,
+        port: str = None,
+        baudrate: int = 1000000,
+        timeout: float = 1.0,
     ):
         self._in_buffer = b""
         super().__init__(port, baudrate, timeout)
 
     def connect(
-        self, port: str = None, baudrate: int = 1000000, timeout: float = 1.0,
+        self,
+        port: str = None,
+        baudrate: int = 1000000,
+        timeout: float = 1.0,
     ):
+        """See :meth:`Handler.connect`."""
         self.version = self.get_version()
 
     def disconnect(self):
+        """See :meth:`Handler.disconnect`."""
         pass
 
     def reconnect(
-        self, port: str = None, baudrate: int = None, timeout: float = None,
+        self,
+        port: str = None,
+        baudrate: int = None,
+        timeout: float = None,
     ):
+        """See :meth:`Handler.reconnect`."""
         pass
 
     def get_version(self, *args) -> str:
+        """Return mock version."""
         return self.VERSION
 
     def read(self, number_of_bytes: int) -> bytes:
         """Mimic the behavior of the serial bus by returning recorded RX traffic.
 
         The returned data depends on how :meth:`write` was called prior to calling
         :meth:`read`.
+
+        See also :meth:`Handler.read`.
         """
         read_bytes = self._in_buffer[:number_of_bytes]
         self._in_buffer = self._in_buffer[number_of_bytes:]
         return read_bytes
 
     def write(self, data: bytes):
         """Add recorded RX data to buffer if written data equals recorded TX data.
+
+        See also :meth:`Handler.write`.
         """
         tx, rx = next(RECORDED_TRAFFIC)
         if tx == data:
             self._in_buffer += rx
 
     def wait_for_data(self, timeout: float = 0.2) -> bool:
-        """Return True if there is data in buffer, or return False after timeout.
-        """
+        """Return True if there is data in buffer, or return False after timeout."""
         if self._in_buffer:
             return True
         else:
diff --git a/tests/test_logic_analyzer.py b/tests/test_logic_analyzer.py
@@ -40,8 +40,7 @@ def la(handler, request):
 
 
 def enable_pwm(psl: sciencelab.ScienceLab, test_name: str):
-    """Enable PWM output for integration testing.
-    """
+    """Enable PWM output for integration testing."""
     low_frequency_tests = (
         "test_capture_four_low_frequency",
         "test_capture_four_lower_frequency",
