unsafe fixes and some manual ones

Author: rerpha

lewis/adapters/epics.py

@@ -76,7 +76,7 @@ class BoundPV:
     :param meta_target: Object that has an attribute named pv.meta_data_property.
     """
 
-    def __init__(self, pv, target, meta_target=None):
+    def __init__(self, pv, target, meta_target=None) -> None:
         self._meta_target = meta_target
         self._target = target
         self._pv = pv
@@ -87,7 +87,7 @@ def value(self):
         return getattr(self._target, self._pv.property)
 
     @value.setter
-    def value(self, new_value):
+    def value(self, new_value) -> None:
         if self.read_only:
             raise AccessViolationException(
                 "The property {} is read only.".format(self._pv.property)
@@ -217,7 +217,7 @@ def __init__(
         meta_data_property=None,
         doc=None,
         **kwargs,
-    ):
+    ) -> None:
         self.property = "value"
         self.read_only = read_only
         self.poll_interval = poll_interval
@@ -372,7 +372,7 @@ def _create_setter(self, func, *targets):
                 "methods does not count towards that number.".format(func.__name__)
             )
 
-        def setter(obj, value):
+        def setter(obj, value) -> None:
             func(value)
 
         return setter
@@ -415,7 +415,7 @@ def _function_has_n_args(self, func, n):
 
 @has_log
 class PropertyExposingDriver(Driver):
-    def __init__(self, interface, device_lock):
+    def __init__(self, interface, device_lock) -> None:
         super(PropertyExposingDriver, self).__init__()
 
         self._interface = interface
@@ -425,7 +425,7 @@ def __init__(self, interface, device_lock):
         self._timers = {k: 0.0 for k in self._interface.bound_pvs.keys()}
         self._last_update_call = None
 
-    def write(self, pv, value):
+    def write(self, pv, value) -> bool:
         self.log.debug("PV put request: %s=%s", pv, value)
 
         pv_object = self._interface.bound_pvs.get(pv)
@@ -476,7 +476,7 @@ def _get_param_info(self, pv, meta_keys):
 
         return info_dict
 
-    def process_pv_updates(self, force=False):
+    def process_pv_updates(self, force=False) -> None:
         """
         Update PV values that have changed for PVs that are due to update according to their
         respective poll interval timers.
@@ -511,7 +511,7 @@ def process_pv_updates(self, force=False):
 
         self._last_update_call = datetime.now()
 
-    def _process_value_updates(self, updates):
+    def _process_value_updates(self, updates) -> None:
         if updates:
             update_log = []
             for pv, value in updates:
@@ -523,7 +523,7 @@ def _process_value_updates(self, updates):
             # Calling this manually is only required for values, not for meta
             self.updatePVs()
 
-    def _process_meta_updates(self, updates):
+    def _process_meta_updates(self, updates) -> None:
         if updates:
             update_log = []
             for pv, info in updates:
@@ -549,7 +549,7 @@ class EpicsAdapter(Adapter):
 
     default_options = {"prefix": ""}
 
-    def __init__(self, options=None):
+    def __init__(self, options=None) -> None:
         super(EpicsAdapter, self).__init__(options)
 
         self._server = None
@@ -573,7 +573,7 @@ def documentation(self):
 
         return "\n\n".join([inspect.getdoc(self.interface) or "", "PVs\n==="] + pvs)
 
-    def start_server(self):
+    def start_server(self) -> None:
         """
         Creates a pcaspy-server.
 
@@ -597,15 +597,15 @@ def start_server(self):
                 ", ".join((self._options.prefix + pv for pv in self.interface.bound_pvs.keys())),
             )
 
-    def stop_server(self):
+    def stop_server(self) -> None:
         self._driver = None
         self._server = None
 
     @property
     def is_running(self):
         return self._server is not None
 
-    def handle(self, cycle_delay=0.1):
+    def handle(self, cycle_delay=0.1) -> None:
         """
         Call this method to spend about ``cycle_delay`` seconds processing
         requests in the pcaspy server. Under load, for example when running ``caget`` at a
@@ -677,15 +677,15 @@ def stop(self, value):
     protocol = "epics"
     pvs = None
 
-    def __init__(self):
+    def __init__(self) -> None:
         super(EpicsInterface, self).__init__()
         self.bound_pvs = None
 
     @property
     def adapter(self):
         return EpicsAdapter
 
-    def _bind_device(self):
+    def _bind_device(self) -> None:
         """
         This method transforms the ``self.pvs`` dict of :class:`PV` objects ``self.bound_pvs``,
         a dict of :class:`BoundPV` objects, the keys are always the PV-names that are exposed

lewis/adapters/modbus.py

@@ -54,7 +54,7 @@ class ModbusDataBank:
     :param kwargs: Configuration
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs) -> None:
         self._data = kwargs["data"]
         self._start_addr = kwargs["start_addr"]
 
@@ -74,7 +74,7 @@ def get(self, addr, count):
             raise IndexError("Invalid address range [{:#06x} - {:#06x}]".format(addr, addr + count))
         return data
 
-    def set(self, addr, values):
+    def set(self, addr, values) -> None:
         """
         Write list ``values`` to ``addr`` memory location in DataBank.
 
@@ -109,7 +109,7 @@ class ModbusBasicDataBank(ModbusDataBank):
     :param last_addr: Last valid address
     """
 
-    def __init__(self, default_value=0, start_addr=0x0000, last_addr=0xFFFF):
+    def __init__(self, default_value=0, start_addr=0x0000, last_addr=0xFFFF) -> None:
         super(ModbusBasicDataBank, self).__init__(
             start_addr=start_addr, data=[default_value] * (last_addr - start_addr + 1)
         )
@@ -118,7 +118,7 @@ def __init__(self, default_value=0, start_addr=0x0000, last_addr=0xFFFF):
 class ModbusDataStore:
     """Convenience struct to hold the four types of DataBanks in Modbus"""
 
-    def __init__(self, di=None, co=None, ir=None, hr=None):
+    def __init__(self, di=None, co=None, ir=None, hr=None) -> None:
         self.di = di
         self.co = co
         self.ir = ir
@@ -154,7 +154,7 @@ class ModbusTCPFrame:
     :except EOFError: Not enough data for complete frame; no data consumed.
     """
 
-    def __init__(self, stream=None):
+    def __init__(self, stream=None) -> None:
         self.transaction_id = 0
         self.protocol_id = 0
         self.length = 2
@@ -165,7 +165,7 @@ def __init__(self, stream=None):
         if stream is not None:
             self.from_bytearray(stream)
 
-    def from_bytearray(self, stream):
+    def from_bytearray(self, stream) -> None:
         """
         Constructs this frame from input data stream, consuming as many bytes as necessary from
         the beginning of the stream.
@@ -273,7 +273,7 @@ class ModbusProtocol:
     :param datastore: ModbusDataStore instance to reference when processing requests
     """
 
-    def __init__(self, sender, datastore):
+    def __init__(self, sender, datastore) -> None:
         self._buffer = bytearray()
         self._datastore = datastore
         self._send = lambda req: sender(req.to_bytearray())
@@ -290,7 +290,7 @@ def __init__(self, sender, datastore):
             0x10: self._handle_write_multiple_registers,
         }
 
-    def process(self, data, device_lock):
+    def process(self, data, device_lock) -> None:
         """
         Process as much of given data as possible.
 
@@ -530,7 +530,7 @@ def _handle_write_multiple_registers(self, request):
 
 @has_log
 class ModbusHandler(asyncore.dispatcher_with_send):
-    def __init__(self, sock, interface, server):
+    def __init__(self, sock, interface, server) -> None:
         asyncore.dispatcher_with_send.__init__(self, sock=sock)
         self._datastore = ModbusDataStore(interface.di, interface.co, interface.ir, interface.hr)
         self._modbus = ModbusProtocol(self.send, self._datastore)
@@ -539,19 +539,19 @@ def __init__(self, sock, interface, server):
         self._set_logging_context(interface)
         self.log.info("Client connected from %s:%s", *sock.getpeername())
 
-    def handle_read(self):
+    def handle_read(self) -> None:
         data = self.recv(8192)
         self._modbus.process(data, self._server.device_lock)
 
-    def handle_close(self):
+    def handle_close(self) -> None:
         self.log.info("Closing connection to client %s:%s", *self.socket.getpeername())
         self._server.remove_handler(self)
         self.close()
 
 
 @has_log
 class ModbusServer(asyncore.dispatcher):
-    def __init__(self, host, port, interface, device_lock):
+    def __init__(self, host, port, interface, device_lock) -> None:
         asyncore.dispatcher.__init__(self)
         self.device_lock = device_lock
         self.interface = interface
@@ -565,17 +565,17 @@ def __init__(self, host, port, interface, device_lock):
 
         self._accepted_connections = []
 
-    def handle_accept(self):
+    def handle_accept(self) -> None:
         pair = self.accept()
         if pair is not None:
             sock, _ = pair
             handler = ModbusHandler(sock, self.interface, self)
             self._accepted_connections.append(handler)
 
-    def remove_handler(self, handler):
+    def remove_handler(self, handler) -> None:
         self._accepted_connections.remove(handler)
 
-    def handle_close(self):
+    def handle_close(self) -> None:
         self.log.info("Shutting down server, closing all remaining client connections.")
 
         for handler in self._accepted_connections:
@@ -587,19 +587,19 @@ def handle_close(self):
 class ModbusAdapter(Adapter):
     default_options = {"bind_address": "0.0.0.0", "port": 502}
 
-    def __init__(self, options=None):
+    def __init__(self, options=None) -> None:
         super(ModbusAdapter, self).__init__(options)
         self._server = None
 
-    def start_server(self):
+    def start_server(self) -> None:
         self._server = ModbusServer(
             self._options.bind_address,
             self._options.port,
             self.interface,
             self.device_lock,
         )
 
-    def stop_server(self):
+    def stop_server(self) -> None:
         if self._server is not None:
             self._server.close()
             self._server = None
@@ -608,7 +608,7 @@ def stop_server(self):
     def is_running(self):
         return self._server is not None
 
-    def handle(self, cycle_delay=0.1):
+    def handle(self, cycle_delay=0.1) -> None:
         asyncore.loop(cycle_delay, count=1)