Always 'import numpy as np' for consistency

Author: David Miguel Susano Pinto

microscope/abc.py

@@ -32,7 +32,7 @@
 from threading import Thread
 from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple
 
-import numpy
+import numpy as np
 import Pyro4
 
 import microscope
@@ -853,13 +853,13 @@ def _process_data(self, data):
 
         # Choose appropriate transform based on (flips, rot).
         # Do rotation
-        data = numpy.rot90(data, rot)
+        data = np.rot90(data, rot)
         # Flip
         data = {
             (0, 0): lambda d: d,
-            (0, 1): numpy.flipud,
-            (1, 0): numpy.fliplr,
-            (1, 1): lambda d: numpy.fliplr(numpy.flipud(d)),
+            (0, 1): np.flipud,
+            (1, 0): np.fliplr,
+            (1, 1): lambda d: np.fliplr(np.flipud(d)),
         }[flips](data)
         return super()._process_data(data)
 
@@ -1064,15 +1064,15 @@ class DeformableMirror(TriggerTargetMixin, Device, metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
-        self._patterns: Optional[numpy.ndarray] = None
+        self._patterns: Optional[np.ndarray] = None
         self._pattern_idx: int = -1
 
     @property
     @abc.abstractmethod
     def n_actuators(self) -> int:
         raise NotImplementedError()
 
-    def _validate_patterns(self, patterns: numpy.ndarray) -> None:
+    def _validate_patterns(self, patterns: np.ndarray) -> None:
         """Validate the shape of a series of patterns.
 
         Only validates the shape of the patterns, not if the values
@@ -1096,10 +1096,10 @@ def _validate_patterns(self, patterns: numpy.ndarray) -> None:
             )
 
     @abc.abstractmethod
-    def _do_apply_pattern(self, pattern: numpy.ndarray) -> None:
+    def _do_apply_pattern(self, pattern: np.ndarray) -> None:
         raise NotImplementedError()
 
-    def apply_pattern(self, pattern: numpy.ndarray) -> None:
+    def apply_pattern(self, pattern: np.ndarray) -> None:
         """Apply this pattern.
 
         Raises:
@@ -1118,7 +1118,7 @@ def apply_pattern(self, pattern: numpy.ndarray) -> None:
         self._validate_patterns(pattern)
         self._do_apply_pattern(pattern)
 
-    def queue_patterns(self, patterns: numpy.ndarray) -> None:
+    def queue_patterns(self, patterns: np.ndarray) -> None:
         """Send values to the mirror.
 
         Args:

microscope/gui.py

@@ -37,7 +37,7 @@
 import threading
 from typing import Dict, List, Optional, Sequence
 
-import numpy
+import numpy as np
 import Pyro4
 from qtpy import QtCore, QtGui, QtWidgets
 
@@ -136,7 +136,7 @@ def put(self, *args, **kwargs):
 class _Imager(QtCore.QObject):
     """Helper for CameraWidget handling the internals of the camera trigger."""
 
-    imageAcquired = QtCore.Signal(numpy.ndarray)
+    imageAcquired = QtCore.Signal(np.ndarray)
 
     def __init__(self, camera: microscope.abc.Camera) -> None:
         super().__init__()
@@ -187,7 +187,7 @@ def __init__(self, device: microscope.abc.Camera, *args, **kwargs) -> None:
 
         self._view = QtWidgets.QLabel(parent=self)
         self.displayData(
-            numpy.zeros(self._device.get_sensor_shape(), dtype=numpy.uint8)
+            np.zeros(self._device.get_sensor_shape(), dtype=np.uint8)
         )
 
         self._enable_check = QtWidgets.QCheckBox("Enabled", parent=self)
@@ -232,10 +232,10 @@ def updateEnableState(self) -> None:
         self._snap_button.setEnabled(self._device.get_is_enabled())
         self._exposure_box.setEnabled(self._device.get_is_enabled())
 
-    def displayData(self, data: numpy.ndarray) -> None:
+    def displayData(self, data: np.ndarray) -> None:
         np_to_qt = {
-            numpy.dtype("uint8"): QtGui.QImage.Format_Grayscale8,
-            numpy.dtype("uint16"): QtGui.QImage.Format_Grayscale16,
+            np.dtype("uint8"): QtGui.QImage.Format_Grayscale8,
+            np.dtype("uint16"): QtGui.QImage.Format_Grayscale16,
         }
         qt_img = QtGui.QImage(
             data.tobytes(), *data.shape, np_to_qt[data.dtype]
@@ -257,7 +257,7 @@ def __init__(
         super().__init__(*args, **kwargs)
         self._device = device
 
-        self._pattern = numpy.ndarray(shape=(self._device.n_actuators))
+        self._pattern = np.ndarray(shape=(self._device.n_actuators))
         self._actuators: List[QtWidgets.QSlider] = []
         for i in range(self._device.n_actuators):
             actuator = QtWidgets.QSlider(QtCore.Qt.Horizontal, parent=self)

microscope/mirror/alpao.py

@@ -20,7 +20,7 @@
 import ctypes
 import warnings
 
-import numpy
+import numpy as np
 
 import microscope
 import microscope.abc
@@ -55,7 +55,7 @@ class AlpaoDeformableMirror(microscope.abc.DeformableMirror):
     ]
 
     @staticmethod
-    def _normalize_patterns(patterns: numpy.ndarray) -> numpy.ndarray:
+    def _normalize_patterns(patterns: np.ndarray) -> np.ndarray:
         """
         Alpao SDK expects values in the [-1 1] range, so we normalize
         them from the [0 1] range we expect in our interface.
@@ -124,7 +124,7 @@ def trigger_mode(self) -> microscope.TriggerMode:
     def trigger_type(self) -> microscope.TriggerType:
         return self._trigger_type
 
-    def _do_apply_pattern(self, pattern: numpy.ndarray) -> None:
+    def _do_apply_pattern(self, pattern: np.ndarray) -> None:
         pattern = self._normalize_patterns(pattern)
         data_pointer = pattern.ctypes.data_as(asdk.Scalar_p)
         status = asdk.Send(self._dm, data_pointer)
@@ -157,14 +157,14 @@ def set_trigger(self, ttype, tmode):
         self._raise_if_error(status)
         self._trigger_type = ttype
 
-    def queue_patterns(self, patterns: numpy.ndarray) -> None:
+    def queue_patterns(self, patterns: np.ndarray) -> None:
         if self._trigger_type == microscope.TriggerType.SOFTWARE:
             super().queue_patterns(patterns)
             return
 
         self._validate_patterns(patterns)
         patterns = self._normalize_patterns(patterns)
-        patterns = numpy.atleast_2d(patterns)
+        patterns = np.atleast_2d(patterns)
         n_patterns: int = patterns.shape[0]
 
         # The Alpao SDK seems to only support the trigger mode start.  It

microscope/mirror/bmc.py

@@ -24,7 +24,7 @@
 import os
 import warnings
 
-import numpy
+import numpy as np
 
 import microscope
 import microscope._utils
@@ -62,7 +62,7 @@ def __init__(self, serial_number: str, **kwargs) -> None:
     def n_actuators(self) -> int:
         return self._dm.ActCount
 
-    def _do_apply_pattern(self, pattern: numpy.ndarray) -> None:
+    def _do_apply_pattern(self, pattern: np.ndarray) -> None:
         data_pointer = pattern.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
         status = BMC.SetArray(self._dm, data_pointer, None)
         if status:

microscope/mirror/mirao52e.py

@@ -42,7 +42,7 @@
 import ctypes
 from typing import Callable
 
-import numpy
+import numpy as np
 
 import microscope
 import microscope._utils
@@ -82,15 +82,15 @@ def n_actuators(self) -> int:
         return mro.NB_COMMAND_VALUES
 
     @staticmethod
-    def _normalize_patterns(patterns: numpy.ndarray) -> numpy.ndarray:
+    def _normalize_patterns(patterns: np.ndarray) -> np.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 _do_apply_pattern(self, pattern: numpy.ndarray) -> None:
+    def _do_apply_pattern(self, pattern: np.ndarray) -> None:
         pattern = self._normalize_patterns(pattern)
         command = pattern.ctypes.data_as(mro.Command)
         if not mro.applyCommand(command, mro.FALSE, self._status):

microscope/testsuite/hardware.py

@@ -22,7 +22,7 @@
 
 import time
 
-import numpy
+import numpy as np
 
 
 def test_mirror_actuators(dm, time_interval=0.5):
@@ -34,7 +34,7 @@ def test_mirror_actuators(dm, time_interval=0.5):
             actuator.
     """
     base_value = 0.5
-    data = numpy.full((dm.n_actuators), base_value)
+    data = np.full((dm.n_actuators), base_value)
     dm.apply_pattern(data)
 
     time.sleep(time_interval)

microscope/testsuite/test_devices.py

@@ -39,7 +39,7 @@
 import unittest.mock
 from queue import Queue
 
-import numpy
+import numpy as np
 
 import microscope
 import microscope.testsuite.devices as dummies
@@ -280,7 +280,7 @@ class DeformableMirrorTests(DeviceTests):
     """
 
     def assertCurrentPattern(self, expected_pattern, msg=""):
-        numpy.testing.assert_array_equal(
+        np.testing.assert_array_equal(
             self.fake.get_current_pattern(), expected_pattern, msg
         )
 
@@ -290,39 +290,39 @@ def test_get_number_of_actuators(self):
         self.assertEqual(self.device.n_actuators, self.planned_n_actuators)
 
     def test_applying_pattern(self):
-        pattern = numpy.full((self.planned_n_actuators,), 0.2)
+        pattern = np.full((self.planned_n_actuators,), 0.2)
         self.device.apply_pattern(pattern)
         self.assertCurrentPattern(pattern)
 
     def test_out_of_range_pattern(self):
         # While we expect values in the [0 1] range, we should not
         # actually be checking for that.
-        pattern = numpy.zeros((self.planned_n_actuators,))
+        pattern = np.zeros((self.planned_n_actuators,))
         for v in [-1000, -1, 0, 1, 3]:
             pattern[:] = v
             self.device.apply_pattern(pattern)
             self.assertCurrentPattern(pattern)
 
     def test_software_triggering(self):
         n_patterns = 5
-        patterns = numpy.random.rand(n_patterns, self.planned_n_actuators)
+        patterns = np.random.rand(n_patterns, self.planned_n_actuators)
         self.device.queue_patterns(patterns)
         for i in range(n_patterns):
             self.device.next_pattern()
             self.assertCurrentPattern(patterns[i])
 
     def test_validate_pattern_too_long(self):
-        patterns = numpy.zeros((self.planned_n_actuators + 1))
+        patterns = np.zeros((self.planned_n_actuators + 1))
         with self.assertRaisesRegex(Exception, "length of second dimension"):
             self.device.apply_pattern(patterns)
 
     def test_validate_pattern_swapped_dimensions(self):
-        patterns = numpy.zeros((self.planned_n_actuators, 1))
+        patterns = np.zeros((self.planned_n_actuators, 1))
         with self.assertRaisesRegex(Exception, "length of second dimension"):
             self.device.apply_pattern(patterns)
 
     def test_validate_pattern_with_extra_dimension(self):
-        patterns = numpy.zeros((2, 1, self.planned_n_actuators))
+        patterns = np.zeros((2, 1, self.planned_n_actuators))
         with self.assertRaisesRegex(
             Exception, "dimensions \\(must be 1 or 2\\)"
         ):
@@ -444,7 +444,7 @@ def test_non_square_patterns_shape(self):
 
 class TestStageAwareCamera(unittest.TestCase, CameraTests):
     def setUp(self):
-        image = numpy.full((3000, 1500, 1), 42, dtype=numpy.uint8)
+        image = np.full((3000, 1500, 1), 42, dtype=np.uint8)
         self.sensor_shape = (128, 128)
         self.stage = simulators.SimulatedStage(
             {