Use 'from typing import X' to make type annotations less verbose

Author: David Miguel Susano Pinto

microscope/__init__.py

@@ -18,7 +18,7 @@
 ## along with Microscope.  If not, see <http://www.gnu.org/licenses/>.
 
 import enum
-import typing
+from typing import NamedTuple
 
 
 class MicroscopeError(Exception):
@@ -127,21 +127,21 @@ class LibraryLoadError(MicroscopeError):
     pass
 
 
-class AxisLimits(typing.NamedTuple):
+class AxisLimits(NamedTuple):
     """Limits of a :class:`microscope.abc.StageAxis`."""
 
     lower: float
     upper: float
 
 
-class Binning(typing.NamedTuple):
+class Binning(NamedTuple):
     """A tuple containing parameters for horizontal and vertical binning."""
 
     h: int
     v: int
 
 
-class ROI(typing.NamedTuple):
+class ROI(NamedTuple):
     """A tuple that defines a region of interest.
 
     This rectangle format completely defines the ROI without reference

microscope/_utils.py

@@ -21,14 +21,13 @@
 import os
 import sys
 import threading
-import typing
+from typing import List, Optional, Type
 
 import serial
 
 import microscope
 import microscope.abc
 
-
 # Both pySerial and serial distribution packages install an import
 # package named serial.  If both are installed we may have imported
 # the wrong one.  Check it to provide a better error message.  See
@@ -47,7 +46,7 @@
 
 
 def library_loader(
-    libname: str, dlltype: typing.Type[ctypes.CDLL] = ctypes.CDLL, **kwargs
+    libname: str, dlltype: Type[ctypes.CDLL] = ctypes.CDLL, **kwargs
 ) -> ctypes.CDLL:
     """Load shared library.
 
@@ -156,14 +155,14 @@ def readline(self) -> bytes:
         with self._lock:
             return self._serial.readline()
 
-    def readlines(self, hint: int = -1) -> typing.List[bytes]:
+    def readlines(self, hint: int = -1) -> List[bytes]:
         with self._lock:
             return self._serial.readlines(hint)
 
     # Beware: pySerial 3.5 changed the named of its first argument
     # from terminator to expected.  See issue #233.
     def read_until(
-        self, terminator: bytes = b"\n", size: typing.Optional[int] = None
+        self, terminator: bytes = b"\n", size: Optional[int] = None
     ) -> bytes:
         with self._lock:
             return self._serial.read_until(terminator, size=size)

microscope/abc.py

@@ -28,16 +28,15 @@
 import queue
 import threading
 import time
-import typing
 from enum import EnumMeta
 from threading import Thread
+from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple
 
 import numpy
 import Pyro4
 
 import microscope
 
-
 _logger = logging.getLogger(__name__)
 
 
@@ -99,10 +98,10 @@ def __init__(
         self,
         name: str,
         dtype: str,
-        get_func: typing.Optional[typing.Callable[[], typing.Any]],
-        set_func: typing.Optional[typing.Callable[[typing.Any], None]] = None,
-        values: typing.Any = None,
-        readonly: typing.Optional[typing.Callable[[], bool]] = None,
+        get_func: Optional[Callable[[], Any]],
+        set_func: Optional[Callable[[Any], None]] = None,
+        values: Any = None,
+        readonly: Optional[Callable[[], bool]] = None,
     ) -> None:
         self.name = name
         if dtype not in DTYPES:
@@ -286,7 +285,7 @@ class Device(metaclass=abc.ABCMeta):
 
     def __init__(self) -> None:
         self.enabled = False
-        self._settings: typing.Dict[str, _Setting] = {}
+        self._settings: Dict[str, _Setting] = {}
 
     def __del__(self) -> None:
         self.shutdown()
@@ -402,7 +401,7 @@ def add_setting(
         get_func,
         set_func,
         values,
-        readonly: typing.Optional[typing.Callable[[], bool]] = None,
+        readonly: Optional[Callable[[], bool]] = None,
     ) -> None:
         """Add a setting definition.
 
@@ -864,7 +863,7 @@ def _process_data(self, data):
         }[flips](data)
         return super()._process_data(data)
 
-    def get_transform(self) -> typing.Tuple[bool, bool, bool]:
+    def get_transform(self) -> Tuple[bool, bool, bool]:
         """Return the current transform without readout transform."""
         return self._client_transform
 
@@ -879,7 +878,7 @@ def _update_transform(self):
             ud = not ud
         self._transform = (lr, ud, rot)
 
-    def set_transform(self, transform: typing.Tuple[bool, bool, bool]) -> None:
+    def set_transform(self, transform: Tuple[bool, bool, bool]) -> None:
         """Set client transform and update resultant transform."""
         self._client_transform = transform
         self._update_transform()
@@ -903,11 +902,11 @@ def get_cycle_time(self) -> float:
         pass
 
     @abc.abstractmethod
-    def _get_sensor_shape(self) -> typing.Tuple[int, int]:
+    def _get_sensor_shape(self) -> Tuple[int, int]:
         """Return a tuple of `(width, height)` indicating shape in pixels."""
         pass
 
-    def get_sensor_shape(self) -> typing.Tuple[int, int]:
+    def get_sensor_shape(self) -> Tuple[int, int]:
         """Return a tuple of `(width, height)` corrected for transform."""
         shape = self._get_sensor_shape()
         if self._transform[2]:
@@ -1065,7 +1064,7 @@ class DeformableMirror(TriggerTargetMixin, Device, metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
-        self._patterns: typing.Optional[numpy.ndarray] = None
+        self._patterns: Optional[numpy.ndarray] = None
         self._pattern_idx: int = -1
 
     @property
@@ -1193,7 +1192,7 @@ def __init__(self, **kwargs):
         self._set_point = 0.0
 
     @abc.abstractmethod
-    def get_status(self) -> typing.List[str]:
+    def get_status(self) -> List[str]:
         """Query and return the light source status."""
         result = []
         return result
@@ -1319,7 +1318,7 @@ class Controller(Device, metaclass=abc.ABCMeta):
 
     @property
     @abc.abstractmethod
-    def devices(self) -> typing.Mapping[str, Device]:
+    def devices(self) -> Mapping[str, Device]:
         """Map of names to the controlled devices."""
         raise NotImplementedError()
 
@@ -1432,7 +1431,7 @@ class documentation for hardware specific details.
 
     @property
     @abc.abstractmethod
-    def axes(self) -> typing.Mapping[str, StageAxis]:
+    def axes(self) -> Mapping[str, StageAxis]:
         """Map of axis names to the corresponding :class:`StageAxis`.
 
         .. code-block:: python
@@ -1475,7 +1474,7 @@ def may_move_on_enable(self) -> bool:
         raise NotImplementedError()
 
     @property
-    def position(self) -> typing.Mapping[str, float]:
+    def position(self) -> Mapping[str, float]:
         """Map of axis name to their current position.
 
         .. code-block:: python
@@ -1490,7 +1489,7 @@ def position(self) -> typing.Mapping[str, float]:
         return {name: axis.position for name, axis in self.axes.items()}
 
     @property
-    def limits(self) -> typing.Mapping[str, microscope.AxisLimits]:
+    def limits(self) -> Mapping[str, microscope.AxisLimits]:
         """Map of axis name to its upper and lower limits.
 
         .. code-block:: python
@@ -1510,7 +1509,7 @@ def limits(self) -> typing.Mapping[str, microscope.AxisLimits]:
         return {name: axis.limits for name, axis in self.axes.items()}
 
     @abc.abstractmethod
-    def move_by(self, delta: typing.Mapping[str, float]) -> None:
+    def move_by(self, delta: Mapping[str, float]) -> None:
         """Move axes by the corresponding amounts.
 
         Args:
@@ -1536,7 +1535,7 @@ def move_by(self, delta: typing.Mapping[str, float]) -> None:
         raise NotImplementedError()
 
     @abc.abstractmethod
-    def move_to(self, position: typing.Mapping[str, float]) -> None:
+    def move_to(self, position: Mapping[str, float]) -> None:
         """Move axes to the corresponding positions.
 
         Args:

microscope/cameras/hamamatsu.py

@@ -45,7 +45,7 @@
 import math
 import sys
 import threading
-import typing
+from typing import Callable, Dict, List, Optional, Tuple, Type
 
 import numpy as np
 
@@ -134,7 +134,7 @@ def _status_to_error(status: int) -> str:
     return "{}[{:#010x}]".format(name, status & 0x8FFFFFFF)
 
 
-def _call(f: typing.Callable[..., int], *args) -> None:
+def _call(f: Callable[..., int], *args) -> None:
     """Call a C function from dcamapi4.
 
     This is an helper function for the most typical case of checking
@@ -150,15 +150,15 @@ def _call(f: typing.Callable[..., int], *args) -> None:
 
 
 def _create_struct_with_size(
-    stype: typing.Type[ctypes.Structure],
+    stype: Type[ctypes.Structure],
 ) -> ctypes.Structure:
     s = stype()
     s.size = ctypes.sizeof(stype)
     return s
 
 
 def _create_struct_with_cbSize(
-    stype: typing.Type[ctypes.Structure],
+    stype: Type[ctypes.Structure],
 ) -> ctypes.Structure:
     s = stype()
     s.cbSize = ctypes.sizeof(stype)
@@ -167,7 +167,7 @@ def _create_struct_with_cbSize(
 
 def _create_devstring_with_length(
     nbytes: int,
-) -> typing.Tuple[dcam.DEV_STRING, ctypes.c_char]:
+) -> Tuple[dcam.DEV_STRING, ctypes.c_char]:
     # FIXME: the type annotation is not quite right, we actually
     #        return a ctypes array of c_char as the second value.
     devstr = _create_struct_with_size(dcam.DEV_STRING)
@@ -498,14 +498,14 @@ def _init_method_add_all_properties(self) -> None:
 
     def _init_method_get_prop_values(
         self, prop_attr: dcam.PROP_ATTR
-    ) -> typing.Dict[int, str]:
+    ) -> Dict[int, str]:
         strbuf = ctypes.create_string_buffer(64)
         vtxt = _create_struct_with_cbSize(dcam.PROP_VALUETEXT)
         vtxt.iProp = prop_attr.iProp
         vtxt.text = ctypes.cast(ctypes.pointer(strbuf), ctypes.c_char_p)
         vtxt.textbytes = ctypes.sizeof(strbuf)
 
-        val2txt: typing.Dict[int, str] = {}
+        val2txt: Dict[int, str] = {}
         next_value = ctypes.c_double(prop_attr.valuemin)
         while next_value.value <= prop_attr.valuemax:
             vtxt.value = next_value.value
@@ -681,7 +681,7 @@ def set_exposure_time(self, seconds: float) -> None:
     def get_cycle_time(self) -> float:
         return self._get_real_property(dcam.IDPROP.TIMING_MINTRIGGERINTERVAL)
 
-    def _get_sensor_shape(self) -> typing.Tuple[int, int]:
+    def _get_sensor_shape(self) -> Tuple[int, int]:
         return self._sensor_shape
 
     def _get_binning(self) -> microscope.Binning:
@@ -733,7 +733,7 @@ def _get_roi(self) -> microscope.ROI:
     def _set_roi(self, roi: microscope.ROI) -> None:
         pass
 
-    def _fetch_data(self) -> typing.Optional[np.ndarray]:
+    def _fetch_data(self) -> Optional[np.ndarray]:
         _logger.debug("Start waiting for FRAMEREADY")
         status = dcam.wait_start(
             self._wait_open.hwait, ctypes.byref(self._wait_start)
@@ -766,7 +766,7 @@ def _do_trigger(self) -> None:
 
     def _get_trigger_combo(
         self,
-    ) -> typing.Tuple[microscope.TriggerType, microscope.TriggerMode]:
+    ) -> Tuple[microscope.TriggerType, microscope.TriggerMode]:
         source = self._get_long_property(dcam.IDPROP.TRIGGERSOURCE)
         if source == dcam.PROPMODEVALUE.TRIGGERSOURCE__SOFTWARE:
             return (
@@ -858,8 +858,8 @@ def _list_devices() -> None:
     """Print all available Hamamatsu devices and some of their info."""
     api = _DCAM_API()
 
-    models: typing.List[str] = []
-    cids: typing.List[str] = []
+    models: List[str] = []
+    cids: List[str] = []
 
     devstr, devstrbuf = _create_devstring_with_length(64)
     for i in range(api.n_devices):
@@ -906,10 +906,10 @@ def _list_properties(index: int) -> None:
     hdcam = sopen.hdcam
 
     # Collect all the strings to pretty print later.
-    ids: typing.List[str] = []
-    names: typing.List[str] = []
-    rws: typing.List[str] = []
-    values: typing.List[str] = []
+    ids: List[str] = []
+    names: List[str] = []
+    rws: List[str] = []
+    values: List[str] = []
 
     # There is no property with ID zero, it is reserved, so we start
     # at ID zero and loop to the next until there is no next property.
@@ -1007,7 +1007,7 @@ def _list_properties(index: int) -> None:
         _logger.warning("failed to close device during shutdown")
 
 
-def _main(argv: typing.List[str]) -> int:
+def _main(argv: List[str]) -> int:
     prog_name = "microscope.cameras.hamamatsu"
     parser = argparse.ArgumentParser(prog=prog_name)
     subparsers = parser.add_subparsers(

microscope/cameras/ximea.py

@@ -59,7 +59,7 @@
 import contextlib
 import enum
 import logging
-import typing
+from typing import Optional, Tuple
 
 import numpy as np
 from ximea import xiapi
@@ -183,9 +183,7 @@ class XimeaCamera(microscope.abc.Camera):
 
     """
 
-    def __init__(
-        self, serial_number: typing.Optional[str] = None, **kwargs
-    ) -> None:
+    def __init__(self, serial_number: Optional[str] = None, **kwargs) -> None:
         super().__init__(**kwargs)
         self._acquiring = False
         self._handle = xiapi.Camera()
@@ -216,7 +214,7 @@ def _trigger_source_setter(index: int) -> None:
 
         self.initialize()
 
-    def _fetch_data(self) -> typing.Optional[np.ndarray]:
+    def _fetch_data(self) -> Optional[np.ndarray]:
         if not self._acquiring:
             return None
 
@@ -359,7 +357,7 @@ def get_exposure_time(self) -> float:
     def get_cycle_time(self):
         return 1.0 / self._handle.get_framerate()
 
-    def _get_sensor_shape(self) -> typing.Tuple[int, int]:
+    def _get_sensor_shape(self) -> Tuple[int, int]:
         return self._sensor_shape
 
     def soft_trigger(self) -> None: