Add type annotations for ABC DeformableMirror and Mirao52e (issue #108)

Author: carandraug

microscope/devices.py

@@ -28,20 +28,19 @@
 import functools
 import itertools
 import logging
+import queue
+import threading
 import time
+import typing
+
 from ast import literal_eval
-from collections import OrderedDict
+from collections import OrderedDict, namedtuple
 from threading import Thread
-import threading
-import Pyro4
-import numpy
-import queue
-
 from enum import Enum, EnumMeta
 
 import numpy
+import Pyro4
 
-from collections import namedtuple
 # A tuple that defines a region of interest.
 ROI = namedtuple('ROI', ['left', 'top', 'width', 'height'])
 # A tuple containing parameters for horizontal and vertical binning.
@@ -948,7 +947,7 @@ class DeformableMirror(Device):
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs) -> None:
         """Constructor.
 
         Subclasses must define the following properties during
@@ -962,14 +961,14 @@ def __init__(self, **kwargs):
         """
         super(DeformableMirror, self).__init__(**kwargs)
 
-        self._patterns = None
-        self._pattern_idx = None
+        self._patterns = None  # type: typing.Optional[numpy.ndarray]
+        self._pattern_idx = -1  # type: int
 
     @property
-    def n_actuators(self):
+    def n_actuators(self) -> int:
         return self._n_actuators
 
-    def _validate_patterns(self, patterns):
+    def _validate_patterns(self, patterns: numpy.ndarray) -> None:
         """Validate the shape of a series of patterns.
 
         Only validates the shape of the patterns, not if the values
@@ -987,12 +986,12 @@ def _validate_patterns(self, patterns):
                              % (patterns.shape[-1], self._n_actuators)))
 
     @abc.abstractmethod
-    def apply_pattern(self, pattern):
+    def apply_pattern(self, pattern: numpy.ndarray) -> None:
         """Apply this pattern.
         """
         pass
 
-    def queue_patterns(self, patterns):
+    def queue_patterns(self, patterns: numpy.ndarray) -> None:
         """Send values to the mirror.
 
         Parameters
@@ -1009,7 +1008,7 @@ def queue_patterns(self, patterns):
         self._patterns = patterns
         self._pattern_idx = -1 # none is applied yet
 
-    def next_pattern(self):
+    def next_pattern(self) -> None:
         """Apply the next pattern in the queue.
 
         A convenience fallback is provided.
@@ -1019,10 +1018,10 @@ def next_pattern(self):
         self._pattern_idx += 1
         self.apply_pattern(self._patterns[self._pattern_idx,:])
 
-    def initialize(self):
+    def initialize(self) -> None:
         pass
 
-    def _on_shutdown(self):
+    def _on_shutdown(self) -> None:
         pass
 
 

microscope/mirror/mirao52e.py

@@ -39,13 +39,16 @@
 """
 
 import ctypes
+import typing
+
+import numpy
 
 import microscope.devices
 import microscope._wrappers.mirao52e as mro
 
 
 class Mirao52e(microscope.devices.DeformableMirror):
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         ## Status is not the return code of the function calls.
         ## Status is where we can find the error code in case a
@@ -57,34 +60,34 @@ def __init__(self, **kwargs):
 
         ## super class needs this, but maybe it should be calling the
         ## property directly?
-        self._n_actuators = mro.NB_COMMAND_VALUES
+        self._n_actuators = mro.NB_COMMAND_VALUES # type: int
 
     @property
-    def n_actuators(self):
+    def n_actuators(self) -> int:
         return mro.NB_COMMAND_VALUES
 
     @staticmethod
-    def _normalize_patterns(patterns):
+    def _normalize_patterns(patterns: numpy.ndarray) -> numpy.ndarray:
         """
         mirao52e SDK expects values in the [-1 1] range, so we normalize
         them from the [0 1] range we expect in our interface.
         """
         patterns = (patterns * 2) -1
         return patterns
 
-    def apply_pattern(self, pattern):
+    def apply_pattern(self, pattern: numpy.ndarray) -> None:
         self._validate_patterns(pattern)
         pattern = self._normalize_patterns(pattern)
         command = pattern.ctypes.data_as(mro.Command)
         if not mro.applyCommand(command, mro.FALSE, self._status):
             self._raise_status(mro.applyCommand)
 
-    def _raise_status(self, func):
+    def _raise_status(self, func: typing.Callable) -> None:
         error_code = self._status.contents.value
         raise RuntimeError('mro_%s() failed (error code %d)'
                            % (func.__name__, error_code))
 
-    def __del__(self):
+    def __del__(self) -> None:
         if not mro.close(self._status):
             self._raise_status(mro.close)
         super().__del__()