deapi 5.3b4__tar.gz → 5.3b5__tar.gz

{deapi-5.3b4 → deapi-5.3b5}/.github/workflows/build.yaml

@@ -16,8 +16,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.11", "3.12"]
+        os: [ubuntu-latest, windows-latest]
+        python-version: ["3.12", "3.13", "3.14"]
         include:
           - os: ubuntu-latest
             python-version: 3.11

{deapi-5.3b4 → deapi-5.3b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deapi
-Version: 5.3b4
+Version: 5.3b5
 Summary: API for DE Server
 Author: Direct Electron
 Project-URL: Bug Reports, https://github.com/directelectron/deapi/issues

{deapi-5.3b4 → deapi-5.3b5}/deapi/client.py

@@ -15,8 +15,6 @@ import mmap
 from datetime import datetime
 from time import sleep
 import re
-import win32event
-import win32api
 import threading
 from typing import List, Union, Tuple
 
@@ -47,6 +45,10 @@ from deapi.version import version, commandVersion
 from deapi.version import commandVersion as cVersion
 from deapi.wrappers import write_only, disable_scan, deprecated_argument
 
+if sys.platform.startswith("win"):
+    import win32event
+    import win32api
+
 
 ## the commandInfo contains [VERSION_MAJOR.VERSION_MINOR.VERSION_PATCH.VERSION_REVISION]
 
@@ -55,6 +57,7 @@ logLevel = logging.INFO
 logging.basicConfig(format="%(asctime)s DE %(levelname)-8s %(message)s", level=logLevel)
 log = logging.getLogger("DECameraClientLib")
 
+
 def print_info():
     log.info(f"DEAPI Version: {version} (Command Version: {commandVersion})")
     log.info("Python    : " + sys.version.split("(")[0])
@@ -62,6 +65,7 @@ def print_info():
     log.info("CommandVer: " + str(commandVersion))
     log.info("logLevel  : " + str(logging.getLevelName(logLevel)))
 
+
 class Client:
     """A class for connecting to the DE-Server
 
@@ -183,7 +187,7 @@ class Client:
         response = self._sendCommand(command)
         if response != False:
             self.camera = self.__getParameters(response.acknowledge[0])[0]
-        
+
         if logLevel == logging.DEBUG:
             log.debug("Camera: %s", self.camera)
 
@@ -282,7 +286,7 @@ class Client:
             _,
         ) = self.get_result(mask_name, DataType.DE8u, attributes=a)
         return res
-    
+
     def get_current_camera(self) -> str:
         """
         Get the current camera on the server.
@@ -291,7 +295,7 @@ class Client:
             return "No current camera"
         else:
             return self.camera
-        
+
     @write_only
     def set_current_camera(self, camera_name: str = None):
         """
@@ -340,7 +344,7 @@ class Client:
         if search is not None:
             available_registers = [p for p in available_registers if search in p]
         return available_registers
-    
+
     @deprecated_argument(
         name="propertyName", since="5.2.0", alternative="property_name"
     )
@@ -508,7 +512,7 @@ class Client:
                     )
 
         return ret
-    
+
     def get_register(self, register_name: str):
         """
         Get the value of a register of the camera on DE-Server
@@ -639,7 +643,6 @@ class Client:
             )
 
         return ret
-    
 
     @write_only
     def set_register(self, name: str, value):
@@ -674,7 +677,6 @@ class Client:
 
         return ret
 
-
     @write_only
     def set_engineering_mode(self, enable, password):
         """
@@ -1000,8 +1002,12 @@ class Client:
             if commandVersion >= 13:
                 retval = self.SetProperty("Server Normalize Properties", "Off")
 
-            retval &= self.SetProperty("Hardware Binning X", 2 if bin_x >= 2 and use_hw else 1)
-            retval &= self.SetProperty("Hardware Binning Y", 2 if bin_y >= 2 and use_hw else 1)
+            retval &= self.SetProperty(
+                "Hardware Binning X", 2 if bin_x >= 2 and use_hw else 1
+            )
+            retval &= self.SetProperty(
+                "Hardware Binning Y", 2 if bin_y >= 2 and use_hw else 1
+            )
 
             prop_hw_bin_x = self.GetProperty("Hardware Binning X")
             prop_hw_bin_y = self.GetProperty("Hardware Binning Y")
@@ -1577,7 +1583,6 @@ class Client:
             lapsed = (self.GetTime() - step_time) * 1000
             log.debug(" Command Time: %.1f ms", lapsed)
             step_time = self.GetTime()
-        ack = response.acknowledge[0]
 
         if response:
             values = self.__getParameters(response.acknowledge[0])
@@ -1894,7 +1899,9 @@ class Client:
                             f"expected: {totalBytes}, received: {movieBufferSize}"
                         )
                     else:
-                        log.info(f"reading movie buffer {totalBytes}", )
+                        log.info(
+                            f"reading movie buffer {totalBytes}",
+                        )
                         movieBuffer = self._recvFromSocket(self.socket, totalBytes)
                         log.info("Done reading movie buffer")
         else:
@@ -2345,7 +2352,7 @@ class Client:
 
         if counting:
             self["Image Processing - Mode"] = "Counting"
-            self["Reference - Counting Gain Target (ADU/pix)"] = (
+            self["Reference - Counting Gain Target (e-/pix)"] = (
                 2000
                 if target_electrons_per_pixel is None
                 else target_electrons_per_pixel
@@ -2367,30 +2374,41 @@ class Client:
         while self.acquiring:
             time.sleep(2)
 
+        img, dtype, attr, _ = self.get_result(
+            FrameType.SUMINTERMEDIATE, PixelFormat.UINT16
+        )
+
         if counting:
             exposure_time = self["Reference - Counting Gain Exposure Time (seconds)"]
             total_acquisitions = self["Reference - Counting Gain Acquisitions"]
+            num_el = np.max([attr.eppixpf * frame_rate, attr.eppixps])
+            log.info(
+                f"The number of electrons per pixel per second (eppixps): {num_el:.2f}"
+            )
         else:
             exposure_time = self["Reference - Integrating Gain Exposure Time (seconds)"]
             total_acquisitions = self["Reference - Integrating Gain Acquisitions"]
+            num_el = attr.imageMean * frame_rate
+            log.info(f"The number of ADUs per pixel per second : {num_el:.2f}")
 
-        img, dtype, attr, _ = self.get_result(FrameType.SUMTOTAL, PixelFormat.FLOAT32)
         self.SetProperty("Exposure Mode", prevExposureMode)
-
         self.SetProperty("Exposure Time (seconds)", prevExposureTime)
 
         num_el = np.max([attr.eppixpf * frame_rate, attr.eppixps])
-        log.info(f"The number of electrons per pixel per second (eppixps): {num_el:.2f}")
+        log.info(
+            f"The number of electrons per pixel per second (eppixps): {num_el:.2f}"
+        )
 
         if attr.saturation > 0.0001:  # Nothing should be saturated in a gain image.
             raise ValueError(
                 "The trial gain reference image has pixels that are close to saturation. "
                 "Please reduce the beam intensity or exposure time."
             )
+
         # recalculating to check...
-        total_acquisitions = int(
-            np.ceil(target_electrons_per_pixel / (exposure_time * num_el))
-        )
+        # total_acquisitions = int(
+        # np.ceil(target_electrons_per_pixel / (exposure_time * num_el))
+        # )
         if total_acquisitions == 1:
             total_acquisitions = 2
 
@@ -2404,6 +2422,7 @@ class Client:
         target_electrons_per_pixel: float = None,
         timeout: int = 600,
         counting: bool = False,
+        num_acq: int = 0,
     ):
         """Take a gain reference.
 
@@ -2430,6 +2449,8 @@ class Client:
             If True, the gain reference will be taken in counting mode, by default False.
             This is useful for cameras that support counting mode and can be used to take gain references
             with a lower noise level.
+        num_acq: int, optional
+            Force the number of acquisiton to this number, otherwise it will be automatically calculated.
         """
         if target_electrons_per_pixel is None and not counting:
             target_electrons_per_pixel = 16000
@@ -2440,6 +2461,9 @@ class Client:
             frame_rate, target_electrons_per_pixel, counting
         )
 
+        if num_acq != 0:
+            num_acquisitions = num_acq
+
         log.info(
             f"Gain reference: {exposure_time:.2f} seconds, "
             f"total acquisitions: {num_acquisitions}, "
@@ -2476,19 +2500,33 @@ class Client:
             return time.clock()
         else:
             return time.perf_counter()
-        
+
+    def ensure_get_event_supported(self):
+        """Ensure get_event related functions are only used on Windows platforms.
+
+        Raises
+        ------
+        NotImplementedError
+            If called on a non-Windows platform.
+        """
+        if not sys.platform.startswith("win"):
+            raise NotImplementedError(
+                "get_event functionality is only available on Windows platforms."
+            )
+
     def enable_get_event(self):
         """
         Enable event retrieval from the server.
-        
+
         Creates a Windows semaphore to handle event notifications and enables
         the getEventEnabled flag. This must be called before get_event() can be used.
-        
+
         Returns
         -------
         bool
             True if event retrieval was successfully enabled, False otherwise.
         """
+        self.ensure_get_event_supported()
         with self.eventMutex:
             command = self._addSingleCommand(self.ENABLE_GET_EVENT, None, None)
             response = self._sendCommand(command)
@@ -2496,15 +2534,17 @@ class Client:
             if response != False:
                 semaphoreName = self.__getParameters(response.acknowledge[0])[0]
                 if semaphoreName is not None:
-                    self.sdkEventSemaphore = win32event.CreateSemaphore(None, 0, 999, semaphoreName)
+                    self.sdkEventSemaphore = win32event.CreateSemaphore(
+                        None, 0, 999, semaphoreName
+                    )
                 else:
                     return False
-                
+
                 self.getEventEnabled = True
                 return True
             else:
                 return False
-        
+
     def get_event(self):
         """
         Retrieve the next event from the server.
@@ -2533,6 +2573,7 @@ class Client:
               If they are empty strings, then the limits did not change.
             If event retrieval is disabled or the client is disconnected, an empty list is returned.
         """
+        self.ensure_get_event_supported()
         if self.sdkEventSemaphore is not None:
             win32event.WaitForSingleObject(self.sdkEventSemaphore, win32event.INFINITE)
         else:
@@ -2541,7 +2582,7 @@ class Client:
         with self.eventMutex:
             if not self.connected or not self.getEventEnabled:
                 return []
-                
+
             command = self._addSingleCommand(self.GET_EVENT, None, None)
             response = self._sendCommand(command)
 
@@ -2556,20 +2597,21 @@ class Client:
                     eventSpec.append(values[4])
 
             return eventSpec
-    
+
     def disable_get_event(self):
         """
         Disable event retrieval from the server.
-        
+
         Releases and closes the Windows semaphore used for event notification,
         and disables the getEventEnabled flag. After calling this, get_event()
         will no longer function.
-        
+
         Returns
         -------
         bool
             True if event retrieval was successfully disabled, False otherwise.
         """
+        self.ensure_get_event_supported()
         with self.eventMutex:
             command = self._addSingleCommand(self.DISABLE_GET_EVENT, None, None)
             response = self._sendCommand(command)
@@ -2583,7 +2625,7 @@ class Client:
                 return True
             else:
                 return False
-        
+
     def is_get_event_enabled(self):
         """
         Check if event retrieval from the server is currently enabled.
@@ -2593,6 +2635,7 @@ class Client:
         bool
             True if event retrieval is enabled, False otherwise.
         """
+        self.ensure_get_event_supported()
         with self.eventMutex:
             return self.getEventEnabled
 
@@ -2675,7 +2718,7 @@ class Client:
 
         if command is None:
             return False
-        
+
         if len(command.camera_name) == 0:
             command.camera_name = (
                 self.camera
@@ -2683,18 +2726,28 @@ class Client:
 
         try:
             packet = struct.pack("I", command.ByteSize()) + command.SerializeToString()
-            res = self.socket.send(packet)
-            # packet.PrintDebugString()
-            # log.debug("sent result = %d\n", res)
+            # sendall() loops internally until every byte is delivered (or raises).
+            # send() can return a short count on a non-blocking/timeout socket —
+            # that leaves _recv_exact on the server waiting for the rest of the
+            # message while this side waits for the reply: a deadlock.
+            self.socket.sendall(packet)
         except socket.error as e:
-            raise e("Error sending %s\n", command)
+            log.error("Error sending command: %s", e)
+            return False
 
         if logLevel == logging.DEBUG:
             lapsed = (self.GetTime() - step_time) * 1000
             log.debug(" Send Time: %.1f ms", lapsed)
             step_time = self.GetTime()
 
-        return self.__ReceiveResponseForCommand(command)
+        try:
+            return self.__ReceiveResponseForCommand(command)
+        except ConnectionResetError as e:
+            # Server closed the connection mid-reply (e.g. it crashed or dropped
+            # the client).  Return False so callers' existing  `if response != False`
+            # guards work correctly, rather than propagating an unexpected exception.
+            log.error("Connection reset while waiting for response: %s", e)
+            return False
 
     def __ReceiveResponseForCommand(self, command):
         step_time = self.GetTime()
@@ -2779,7 +2832,17 @@ class Client:
                 packet_size = upper_lim
             loopTime = self.GetTime()
             try:
-                buffer += sock.recv(packet_size)
+                chunk = sock.recv(packet_size)
+                if not chunk:
+                    # recv() returns b'' when the remote end has closed the
+                    # connection.  Without this check the loop would spin
+                    # forever because b'' never raises an exception and never
+                    # advances total_len — the primary hang on macOS / Py 3.11+.
+                    raise ConnectionResetError(
+                        f"Server closed the connection after {total_len} "
+                        f"of {bytes} expected bytes"
+                    )
+                buffer += chunk
 
             except socket.timeout:
                 log.debug(
@@ -2793,8 +2856,7 @@ class Client:
                 else:
                     pass  # continue further
             except socket.error as e:
-                raise e("Error receiving %d bytes: %s", bytes, e)
-                break
+                raise ConnectionResetError(f"Error receiving {bytes} bytes: {e}") from e
             total_len = len(buffer)
 
         totalTimeMs = (self.GetTime() - startTime) * 1000
@@ -2882,7 +2944,7 @@ class Client:
     GetProperty = get_property
     SetProperty = set_property
     SetPropertyAndGetChangedProperties = set_property_and_get_changed_properties
-    GetRegister = get_register 
+    GetRegister = get_register
     SetRegister = set_register
     ListRegisters = list_registers
     setEngMode = set_engineering_mode
@@ -2967,7 +3029,7 @@ class Client:
     DISABLE_GET_EVENT = 37
     GET_REGISTER = 38
     SET_REGISTER = 39
-    LIST_REGISTERS = 40 
+    LIST_REGISTERS = 40
 
 
 MMF_DATA_HEADER_SIZE = 24

{deapi-5.3b4 → deapi-5.3b5}/deapi/data_types.py

@@ -698,6 +698,11 @@ class VirtualMask:
 
     def __getitem__(self, item):
         full_img = self.client.get_virtual_mask(self.index)
+        if full_img is None:
+            raise RuntimeError(
+                f"get_virtual_mask({self.index}) returned None — "
+                "the server may have dropped the connection or encountered an error."
+            )
         return full_img[item]
 
     def __setitem__(self, key, value):

{deapi-5.3b4 → deapi-5.3b5}/deapi/simulated_server/fake_server.py

@@ -1,3 +1,4 @@
+import socket
 import time
 import warnings
 
@@ -19,15 +20,15 @@ def add_parameter(ack, value):
     Add a parameter to a protobuffer
     """
     param = ack.parameter.add()
-    if isinstance(value, str):
+    if isinstance(value, bool):  # must be before int — bool is a subclass of int
+        param.type = pb.AnyParameter.P_BOOL
+        param.p_bool = value
+    elif isinstance(value, str):
         param.type = pb.AnyParameter.P_STRING
         param.p_string = value
     elif isinstance(value, int):
         param.type = pb.AnyParameter.P_INT
         param.p_int = value
-    elif isinstance(value, bool):
-        param.type = pb.AnyParameter.P_BOOL
-        param.p_bool = value
     elif isinstance(value, float):
         param.type = pb.AnyParameter.P_FLOAT
         param.p_float = value
@@ -346,9 +347,14 @@ class FakeServer:
         if total_len < total_bytes:
             while total_len < total_bytes:
                 try:
-                    buffer += self.socket.recv(total_bytes)
+                    chunk = self.socket.recv(total_bytes - total_len)
+                    if not chunk:
+                        raise ConnectionResetError(
+                            "Connection closed while reading virtual mask"
+                        )
+                    buffer += chunk
                     total_len = len(buffer)
-                except self.socket.timeout:
+                except socket.timeout:
                     raise ValueError("Socket timed out")
         buffer = buffer
         mask = np.frombuffer(buffer, dtype=np.int8).reshape((w, h))
@@ -714,6 +720,9 @@ class FakeServer:
         if histo_min == 0 and histo_max == 0:
             histo_min = np.min(image)
             histo_max = np.max(image)
+        # np.histogram requires max > min; pad when image is uniform
+        if histo_min == histo_max:
+            histo_max = histo_min + 1
         image_hist, bins = np.histogram(
             image.flatten(), bins=histo_bins, range=(histo_min, histo_max)
         )

{deapi-5.3b4 → deapi-5.3b5}/deapi/simulated_server/initialize_server.py

@@ -1,31 +1,51 @@
 import sys
+import traceback
 
 from deapi.simulated_server.fake_server import FakeServer
 import socket
 import struct
 from deapi.buffer_protocols import pb
-import sys
 import argparse
 
 
+def _recv_exact(conn, n):
+    """Read exactly *n* bytes from *conn*, looping over partial reads.
+
+    Returns the complete byte string, or raises ``ConnectionResetError`` if
+    the peer closes the connection before all bytes arrive.  This is necessary
+    because TCP is a stream protocol: a single ``recv(n)`` call may legally
+    return anywhere from 1 to n bytes, and on macOS the loopback interface
+    fragments packets far more aggressively than Linux does.
+    """
+    buf = b""
+    while len(buf) < n:
+        chunk = conn.recv(n - len(buf))
+        if not chunk:
+            raise ConnectionResetError(
+                f"Connection closed after {len(buf)} of {n} expected bytes"
+            )
+        buf += chunk
+    return buf
+
+
 # Defining main function
 def main(port=13240):
     parser = argparse.ArgumentParser()
     parser.add_argument("--port", type=int, help="Port to listen on")
-    try:
-        args = parser.parse_args()
-        if args.port:
-            port = args.port
-    except:
-        pass
+    args, _ = parser.parse_known_args()
+    if args.port:
+        port = args.port
 
     HOST = "127.0.0.1"  # Standard loopback interface address (localhost)
     PORT = port  # Port to listen on (non-privileged ports are > 1023)
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server_socket:
+        # Allow the port to be reused immediately after the process exits
+        # (avoids "Address already in use" / TIME_WAIT failures between test runs)
+        server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         server_socket.bind((HOST, PORT))
         server_socket.listen()
-        sys.stderr.write("started .... \n\n")
-        sys.stderr.flush()
+        sys.stdout.write("started .... \n\n")
+        sys.stdout.flush()
         sys.stderr.write(
             "Waiting for a Connection to: \n"
             f"    Host: {HOST}\n"
@@ -34,13 +54,18 @@ def main(port=13240):
         sys.stderr.flush()
         while True:
             conn, addr = server_socket.accept()  # What waits for a connection
+            # Guard against a stalled client leaving _recv_exact blocked forever.
+            # 120 s is generous enough to survive debugger pauses and slow CI
+            # runners, while still breaking the partial-send deadlock if sendall()
+            # somehow delivers a short write.
+            conn.settimeout(120)
             server = FakeServer(socket=conn)
             connected = True
             while connected:
                 try:
-                    totallen = conn.recv(4)
+                    totallen = _recv_exact(conn, 4)
                     totallenRecv = struct.unpack("I", totallen)[0]
-                    message = conn.recv(totallenRecv)
+                    message = _recv_exact(conn, totallenRecv)
                     message_packet = pb.DEPacket()
                     message_packet.ParseFromString(message)
                     response = server._respond_to_command(message_packet)
@@ -50,10 +75,11 @@ def main(port=13240):
                             packet = (
                                 struct.pack("I", r.ByteSize()) + r.SerializeToString()
                             )
-                            conn.send(packet)
+                            conn.sendall(packet)
                         else:
                             conn.sendall(r)
-                except:
+                except Exception:
+                    traceback.print_exc(file=sys.stderr)
                     connected = False
 
 

{deapi-5.3b4 → deapi-5.3b5}/deapi/tests/conftest.py

@@ -22,6 +22,37 @@ def close_port(port):
             process.terminate()
 
 
+def wait_for_idle(client, timeout: float = 30, interval: float = 0.1):
+    """Poll ``client.acquiring`` until it is False or *timeout* seconds elapse.
+
+    Replaces bare ``while client.acquiring: time.sleep(N)`` loops in tests so
+    that a stalled socket or an unexpectedly long acquisition does not cause the
+    test suite to hang indefinitely.
+
+    The default *timeout* of 30 s is sized for fake-server tests where all
+    acquisitions complete in well under a second (FPS=1000, small scan grids).
+    Pass a larger value for tests that run against real hardware with long
+    exposures, e.g. ``wait_for_idle(client, timeout=300)``.
+
+    Parameters
+    ----------
+    client:
+        A connected :class:`deapi.Client` instance.
+    timeout:
+        Maximum number of seconds to wait before failing the test.
+    interval:
+        Polling interval in seconds.
+    """
+    deadline = time.monotonic() + timeout
+    while client.acquiring:
+        if time.monotonic() > deadline:
+            pytest.fail(
+                f"Camera still acquiring after {timeout:.0f} s — "
+                "possible socket deadlock or FakeServer state error"
+            )
+        time.sleep(interval)
+
+
 # Modifying pytest run options
 def pytest_addoption(parser):
     parser.addoption(
@@ -111,7 +142,7 @@ def server(xprocess, request):
         curdir = pathlib.Path(__file__).parent.parent
 
         class Starter(ProcessStarter):
-            timeout = 10
+            timeout = 60
             pattern = "started"
             args = [
                 sys.executable,

{deapi-5.3b4 → deapi-5.3b5}/deapi/tests/original_tests/10_imageStatistics.py

@@ -163,9 +163,18 @@ def statisticsValueCheck(imageProcessingMode, correctionMode):
     print(stats.eppix)
     print(stats.epa2)
     # precision issue, we will compare the float number with a tolerance value. The tolerance value is set to 10**-numPrecision * frameCount for e-/pix, 10**-numPrecision * fps for e-/pix/s and 10**-numPrecision * fps * numPhysicalPixels for e-/s.
-    ret &= math.isclose(stats.eppix, attributes.eppix, rel_tol=0, abs_tol=10**-numPrecision * frameCount)
-    ret &= math.isclose(stats.eppixps, attributes.eppixps, rel_tol=0, abs_tol=10**-numPrecision * fps)
-    ret &= math.isclose(stats.eps, attributes.eps, rel_tol=0, abs_tol=10**-numPrecision * fps * numPhysicalPixels)
+    ret &= math.isclose(
+        stats.eppix, attributes.eppix, rel_tol=0, abs_tol=10**-numPrecision * frameCount
+    )
+    ret &= math.isclose(
+        stats.eppixps, attributes.eppixps, rel_tol=0, abs_tol=10**-numPrecision * fps
+    )
+    ret &= math.isclose(
+        stats.eps,
+        attributes.eps,
+        rel_tol=0,
+        abs_tol=10**-numPrecision * fps * numPhysicalPixels,
+    )
 
     ret &= func.compare2FloatValue(stats.epa2, attributes.epa2, numPrecision, "e-/a^2")
     return ret
@@ -212,10 +221,16 @@ def compareBin1Bin2(imageProcessingMode, correctionMode, swBinningFactor):
         swBinY,
     )
 
-    ret &= func.compare2FloatValue(statsBin1.eppix, statsBin2.eppix, numPrecision, "e-/pix")
-    ret &= func.compare2FloatValue(statsBin1.eppixps, statsBin2.eppixps, numPrecision, "e-/pix/s")
+    ret &= func.compare2FloatValue(
+        statsBin1.eppix, statsBin2.eppix, numPrecision, "e-/pix"
+    )
+    ret &= func.compare2FloatValue(
+        statsBin1.eppixps, statsBin2.eppixps, numPrecision, "e-/pix/s"
+    )
     ret &= func.compare2FloatValue(statsBin1.eps, statsBin2.eps, numPrecision, "e-/s")
-    ret &= func.compare2FloatValue(statsBin1.epa2, statsBin2.epa2, numPrecision, "e-/a^2")
+    ret &= func.compare2FloatValue(
+        statsBin1.epa2, statsBin2.epa2, numPrecision, "e-/a^2"
+    )
     return ret
 
 

{deapi-5.3b4 → deapi-5.3b5}/deapi/tests/original_tests/test_legacy.py

@@ -125,5 +125,6 @@ class TestVirtualMasks08:
 
         deClient.SetVirtualMask(maskID, 1024, 1024, mask)
         # Generate and check the first image
-        mask = deClient.virtual_masks[1][:]
+        # virtual_masks uses 0-based indexing where index 0 maps to mask ID 1
+        mask = deClient.virtual_masks[0][:]
         assert mask.shape == (1024, 1024)

{deapi-5.3b4 → deapi-5.3b5}/deapi/tests/test_client.py

@@ -10,6 +10,7 @@ from deapi.data_types import (
     MovieBufferStatus,
     ContrastStretchType,
 )
+from deapi.tests.conftest import wait_for_idle
 
 
 class TestClient:
@@ -57,8 +58,7 @@ class TestClient:
         client.scan(size_x=10, size_y=10, enable="On")
         client.start_acquisition(1)
         assert client.acquiring
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         assert not client.acquiring
 
     def test_start_acquisition_scan_disabled(self, client):
@@ -66,8 +66,7 @@ class TestClient:
         client.scan(enable="Off")
         client.start_acquisition(10)
         assert client.acquiring
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         assert not client.acquiring
 
     def test_get_result(self, client):
@@ -80,8 +79,7 @@ class TestClient:
         assert client["Hardware ROI Offset X"] == 0
         assert client["Hardware ROI Offset Y"] == 0
         client.start_acquisition(1)
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         result = client.get_result()
         assert isinstance(result, tuple)
         assert len(result) == 4
@@ -93,8 +91,7 @@ class TestClient:
         client["Frames Per Second"] = 1000
         client.scan(size_x=10, size_y=10, enable="On")
         client.start_acquisition(1)
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         result = client.get_result("singleframe_integrated")
         assert isinstance(result[3], Histogram)
         result[3].plot()
@@ -107,8 +104,7 @@ class TestClient:
         assert isinstance(result, tuple)
         assert len(result) == 4
         assert result[0].shape == (1024, 1024)
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
 
     def test_binning_linked_parameters(self, client):
 
@@ -123,8 +119,7 @@ class TestClient:
         client["Hardware Binning X"] = binx
         assert client["Hardware Binning X"] == binx
         client.start_acquisition(1)
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         result = client.get_result("singleframe_integrated")
         assert result[0].shape[1] == 1024 // binx
 
@@ -173,8 +168,7 @@ class TestClient:
         assert client["Scan - Virtual Detector 3 Calculation"] == "Difference"
         np.testing.assert_allclose(client.virtual_masks[2][::2], 2)
         client.start_acquisition(1)
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         result = client.get_result("virtual_image3")
         assert result is not None
         assert result[0].shape == (10, 8)
@@ -247,7 +241,7 @@ class TestClient:
     def test_stream_data(self, client):
         client["Frames Per Second"] = 5
         client.scan(size_x=10, size_y=10, enable="On")
-        client.start_acquisition(1, requestMovieBuffer=True)
+        client.start_acquisition(1, request_movie_buffer=True)
         numberFrames = 0
         index = 0
         status = MovieBufferStatus.OK
@@ -309,8 +303,7 @@ class TestClient:
         assert is_set
         assert client["Scan - Points"] == np.sum(mask) * 2
         client.start_acquisition(1)
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         result = client.get_result("virtual_image1")
         assert result[0].shape == (12, 12)
         client["Scan - Type"] = "Raster"  # clean up
@@ -352,28 +345,21 @@ class TestClient:
         client.take_dark_reference(frame_rate=10)
         client["Image Processing - Flatfield Correction"] = "Dark"
         client.start_acquisition(1)
-        # assert that the dark reference corrects the image to zero...
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         image = client.get_result()[0]
         np.testing.assert_array_equal(image, 0)
 
-        # Now flip the dark reference
         client["Image Processing - Flip Horizontally"] = "On"
         client["Exposure Time (seconds)"] = 1
         client.start_acquisition(1)
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         image = client.get_result()[0]
         np.testing.assert_array_equal(image, 0)
         client["Image Processing - Flip Horizontally"] = "Off"
 
-        # test bin by a factor of 2
-
         client["Binning X"] = 2
         client["Binning Y"] = 2
         client.start_acquisition(1)
-        while client.acquiring:
-            time.sleep(1)
+        wait_for_idle(client)
         image = client.get_result()[0]
         np.testing.assert_array_equal(image, 0)

{deapi-5.3b4 → deapi-5.3b5}/deapi/tests/test_fake_server/test_server.py

@@ -28,7 +28,8 @@ class TestFakeServer:
 
     def test_set_virtual_image_calculation(self, fake_server):
         assert fake_server["Scan - Virtual Detector 1 Calculation"] == "Sum"
-        fake_server["Scan - Virtual Detector 1 Calculation"] = "Susd"
+        with pytest.warns(UserWarning, match="not in options"):
+            fake_server["Scan - Virtual Detector 1 Calculation"] = "Susd"
         assert fake_server["Scan - Virtual Detector 1 Calculation"] == "Sum"
 
     def test_server_software_version(self, fake_server):

{deapi-5.3b4 → deapi-5.3b5}/deapi/tests/test_file_saving/test_scan_pattern_saving.py

@@ -22,9 +22,9 @@ class TestSavingScans:
 
         i = 16
         num_pos = i * i
-        if not os.path.exists("D:\Temp"):
-            os.mkdir("D:\Temp")
-        temp_dir = "D:\Temp"
+        if not os.path.exists(r"D:\Temp"):
+            os.mkdir(r"D:\Temp")
+        temp_dir = r"D:\Temp"
 
         if scan_type == "Serpentine":
             frame_num_order = np.arange(num_pos)
@@ -91,9 +91,9 @@ class TestSavingVirtual:
     def test_save_scans(self, client, scan_type, buffer):
         i = 8
         num_pos = i * i
-        if not os.path.exists("D:\Temp"):
-            os.mkdir("D:\Temp")
-        temp_dir = "D:\Temp"
+        if not os.path.exists(r"D:\Temp"):
+            os.mkdir(r"D:\Temp")
+        temp_dir = r"D:\Temp"
 
         if scan_type == "Serpentine":
             frame_num_order = np.arange(num_pos)

{deapi-5.3b4 → deapi-5.3b5}/deapi/version.py

@@ -1,4 +1,3 @@
 version = "5.3.0"
 versionInfo = list(map(int, version.split(".")))
 commandVersion = (versionInfo[0] - 4) * 10 + versionInfo[1] + 2
-

{deapi-5.3b4 → deapi-5.3b5}/deapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deapi
-Version: 5.3b4
+Version: 5.3b5
 Summary: API for DE Server
 Author: Direct Electron
 Project-URL: Bug Reports, https://github.com/directelectron/deapi/issues

{deapi-5.3b4 → deapi-5.3b5}/pyproject.toml

@@ -25,7 +25,7 @@ dependencies = [
     "sympy",
 ]
 description = "API for DE Server"
-version = "5.3b4"
+version = "5.3b5"
 keywords = [
     "EELS",
     "STEM",