Fix for backwards compatibility, new feature ROIs and RODs for AutoFocus and new timeout mechanic for all clients

.gitignore

@@ -16,3 +16,6 @@
 
 # Cache data unittests
 /.pytest_cache
+
+# proto folders/scripts
+/examples_development

examples/update_scripts/README.md

@@ -45,3 +45,31 @@ Go to the `examples/update_scripts` folder and run the script with following arg
 Go to the `examples/update_scripts` folder and run the script with following arguments
 
     $ python o2x5xx_multi_fw_updater.py -i O2x5xx_Firmware_1.30.10629.swu -H 192.168.0.69
+
+### Build stand-alone application
+
+Navigate to the project folder and build the application with following command:
+
+```
+python -m PyInstaller --onefile --windowed --name O2X5xxO3D3xxMultiFWUpdater o2x5xx_multi_fw_updater.py
+```
+
+You will find the stand-alone application LogTracesExtractor.exe in the dist folder.
+
+Usage of O2X5xxO3D3xxMultiFWUpdater.exe stand-alone application:
+
+    usage: O2X5xxO3D3xxMultiFWUpdater.exe [-h] -i INPUT [INPUT ...] -H HOST [HOST ...]
+                                          [-b BACKUP] [-l LOG] [-r]
+
+    example: O2X5xxO3D3xxMultiFWUpdater.exe -i O2x5xx_Firmware_1.30.10629.swu -H 192.168.0.69
+
+    optional arguments:
+      -h, --help            show this help message and exit
+      -i INPUT [INPUT ...], --input INPUT [INPUT ...]
+                            specify input SWU file(s)
+      -H HOST [HOST ...], --host HOST [HOST ...]
+                            specify host IPs
+      -b BACKUP, --backup BACKUP
+                            path for config backup folder
+      -l LOG, --log LOG     path for log file folder
+      -r, --remove          remove config backup folder after application finished

setup.py

@@ -15,7 +15,7 @@ def read_requires():
 
 setup(
     name='o2x5xx',
-    version='0.4',
+    version='0.5',
     description='A Python library for ifm O2x5xx (O2D5xx / O2I5xx) devices',
     author='Michael Gann',
     author_email='[email protected]',

source/device/client.py

@@ -7,10 +7,11 @@ def __init__(self, address="192.168.0.69", port=50010, autoconnect=True, timeout
         self._address = address
         self._port = port
         self._autoconnect = autoconnect
+        self._device_timeout = timeout
         self._rpc = None
         if autoconnect:
-            self._rpc = O2x5xxRPCDevice(address=self._address)
-        super(O2x5xxPCICDevice, self).__init__(address, port, autoconnect, timeout)
+            self._rpc = O2x5xxRPCDevice(address=self._address, timeout=self._device_timeout)
+        super(O2x5xxPCICDevice, self).__init__(address=address, port=port, autoconnect=autoconnect, timeout=timeout)
 
     def __enter__(self):
         return self
@@ -22,35 +23,45 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         self._rpc = None
 
     @property
-    def rpc(self):
+    def rpc(self) -> O2x5xxRPCDevice:
+        if not self._rpc:
+            self._rpc = O2x5xxRPCDevice(address=self._address, timeout=self._device_timeout)
         return self._rpc
 
 
 class O2x5xxDeviceV2(object):
     def __init__(self, address="192.168.0.69", port=50010, autoconnect=True, timeout=SOCKET_TIMEOUT):
         self._address = address
         self._port = port
-        self._timeout = timeout
+        self.__timeout = timeout
         self._autoconnect = autoconnect
         self._pcic = None
         self._rpc = None
+        if autoconnect:
+            self._pcic = O2x5xxPCICDevice(address=self._address, port=self._port,
+                                          autoconnect=self._autoconnect, timeout=self.__timeout)
+            self._rpc = O2x5xxRPCDevice(address=self._address)
 
     def __enter__(self):
-        self._pcic = O2x5xxPCICDevice(address=self._address, port=self._port, autoconnect=self._autoconnect,
-                                      timeout=self._timeout)
-        self._rpc = O2x5xxRPCDevice(address=self._address)
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self._pcic.close()
-        self._rpc.mainProxy.close()
-        self._pcic = None
+        if self._rpc:
+            self._rpc.mainProxy.close()
+        if self._pcic:
+            self._pcic.close()
         self._rpc = None
+        self._pcic = None
 
     @property
     def rpc(self) -> O2x5xxRPCDevice:
+        if not self._rpc:
+            self._rpc = O2x5xxRPCDevice(address=self._address, timeout=self.__timeout)
         return self._rpc
 
     @property
     def pcic(self) -> O2x5xxPCICDevice:
+        if not self._pcic:
+            self._pcic = O2x5xxPCICDevice(address=self._address, port=self._port,
+                                          autoconnect=self._autoconnect, timeout=self.__timeout)
         return self._pcic

source/pcic/client.py

@@ -1,5 +1,4 @@
 from ..static.formats import error_codes, serialization_format
-from .utils import socket_exception_handler
 import matplotlib.image as mpimg
 import binascii
 import socket
@@ -18,7 +17,7 @@ def __init__(self, address, port, autoconnect=True, timeout=SOCKET_TIMEOUT):
         self.address = address
         self.port = port
         self.autoconnect = autoconnect
-        self.timeout = timeout
+        self._timeout = timeout
         self.pcicSocket = None
         self.connected = False
         if self.autoconnect:
@@ -27,7 +26,6 @@ def __init__(self, address, port, autoconnect=True, timeout=SOCKET_TIMEOUT):
         self.debug = False
         self.debugFull = False
 
-    @socket_exception_handler(timeout=SOCKET_TIMEOUT)
     def connect(self):
         """
         Open the socket session with the device.
@@ -40,6 +38,30 @@ def connect(self):
             self.pcicSocket.connect((self.address, self.port))
             self.connected = True
 
+    @property
+    def timeout(self):
+        """
+        Get the current timeout value on blocking socket operations as a floating point number expressing seconds.
+
+        :return: (float) socket timeout in seconds
+        """
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, value):
+        """
+        Set a timeout on blocking socket operations. The value argument can be a non-negative floating point number
+        expressing seconds, or None. If a non-zero value is given, subsequent socket operations will raise a timeout
+        exception if the timeout period value has elapsed before the operation has completed. If zero is given,
+        the socket is put in non-blocking mode. If None is given, the socket is put in blocking mode.
+
+        :param value: (float) in seconds.
+        :return: None
+        """
+        self._timeout = value
+        if self.pcicSocket:
+            self.pcicSocket.settimeout(self._timeout)
+
     def disconnect(self):
         """
         Close the socket session with the device.
@@ -81,27 +103,6 @@ def recv(self, number_bytes):
             fragments.append(chunk)
         return b''.join(fragments)
 
-    @property
-    def pcic_socket_timeout(self) -> float:
-        """
-		Getter for timeout value of lowlevel connection socket.
-
-		:return: (float) socket timeout in seconds
-		"""
-        return self.timeout
-
-    @pcic_socket_timeout.setter
-    def pcic_socket_timeout(self, value: float) -> None:
-        """
-        Setter for timeout value of lowlevel connection socket.
-
-        :param value: (float) in seconds.
-        :return: None
-        """
-        if self.pcicSocket:
-            self.pcicSocket.settimeout(value)
-        self.timeout = value
-
 
 class PCICV3Client(Client):
     DEFAULT_TICKET = "1000"
@@ -154,7 +155,7 @@ def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.disconnect()
+        self.close()
 
     def activate_application(self, application_number: [str, int]) -> str:
         """
@@ -241,6 +242,7 @@ def retrieve_current_process_interface_configuration(self):
         """
         result = self.send_command('C?')
         result = result.decode()
+
         return result
 
     def request_current_error_state(self):
@@ -494,27 +496,6 @@ def set_logic_state_of_an_id(self, io_id, state):
         result = result.decode()
         return result
 
-    # def set_logic_state_of_an_id2(self, io_id, state):
-    #     """
-    #     This is a reST style.
-    #
-    #     :param io_id : (int)
-    #     2 digits for digital output
-    #         * "01": IO1
-    #         * "02": IO2
-    #     :param state : (str)
-    #     this is a second param
-    #         * "01": IO1
-    #         * "02": IO2
-    #     :returns: this is a description of what is returned
-    #     :raises keyError: raises an exception
-    #     """
-    #     if str(io_id).isnumeric():
-    #         io_id = str(io_id).zfill(2)
-    #     result = self.send_command('o{io_id}{state}'.format(io_id=io_id, state=str(state)))
-    #     result = result.decode()
-    #     return result
-
     def request_state_of_an_id(self, io_id):
         """
         Requests the state of a specific ID.

source/pcic/utils.py

@@ -2,42 +2,17 @@
 import multiprocessing.pool
 
 
-def socket_exception_handler(timeout):
+def timeout(max_timeout):
     """Timeout decorator, parameter in seconds."""
-
-    def exception_decorator(item):
+    def timeout_decorator(item):
         """Wrap the original function."""
-
-        def close_socket_on_exception(session):
-            pcicSocket = getattr(session, "pcicSocket")
-            if pcicSocket:
-                pcicSocket.close()
-
         @functools.wraps(item)
         def func_wrapper(*args, **kwargs):
             """Closure for function."""
-            max_timeout = getattr(args[0], "timeout")
-            try:
-                pool = multiprocessing.pool.ThreadPool(processes=1)
-                async_result = pool.apply_async(item, args, kwargs)
-                pool.close()
-                # raises a TimeoutError if execution exceeds max_timeout
-                return async_result.get(max_timeout)
-
-            except multiprocessing.context.TimeoutError:
-                close_socket_on_exception(session=args[0])
-                raise TimeoutError(
-                    "Unable to establish socket connection to device with IP {}. "
-                    "Execution time exceeded max timeout of {} seconds."
-                    .format(args[0].address, max_timeout))
-
-            except ConnectionRefusedError:
-                close_socket_on_exception(session=args[0])
-                raise ConnectionRefusedError(
-                    "Device with IP {} refuses socket connection with defined port {}. "
-                    "Is the port ok? Default port number is 50010."
-                    .format(args[0].address, args[0].port))
-
+            pool = multiprocessing.pool.ThreadPool(processes=1)
+            async_result = pool.apply_async(item, args, kwargs)
+            pool.close()
+            # raises a TimeoutError if execution exceeds max_timeout
+            return async_result.get(max_timeout)
         return func_wrapper
-
-    return exception_decorator
+    return timeout_decorator

source/rpc/application.py

@@ -1,6 +1,7 @@
 import json
 import os
 import warnings
+from .proxy import ImagerProxy
 
 
 class Application(object):
@@ -12,6 +13,25 @@ def __init__(self, applicationProxy, device):
         self._applicationProxy = applicationProxy
         self._device = device
 
+    def editImage(self, imager_index: int):
+        """
+        Requests an Imager object specified by the image index.
+
+        :param imager_index: (int) index of image from ImagerConfigList
+        :return: Imager (object)
+        """
+        imageIDs = [int(x["Id"]) for x in self.getImagerConfigList()]
+        if imager_index not in imageIDs:
+            raise ValueError("Image index {} not available. Choose one imageIndex from following"
+                             "ImagerConfigList or create a new one with method createImagerConfig():\n{}"
+                             .format(imager_index, self.getImagerConfigList()))
+
+        _imagerURL = self._applicationProxy.baseURL + 'imager_{0:03d}/'.format(imager_index)
+        setattr(self._device, "_imagerURL", _imagerURL)
+        _imagerProxy = ImagerProxy(url=_imagerURL, device=self._device)
+        setattr(self._device, "_imagerProxy", _imagerProxy)
+        return self._device.imager
+
     def getAllParameters(self):
         """
         Returns all parameters of the object in one data-structure. For an overview which parameters can be request use
@@ -174,7 +194,7 @@ def HWROI(self) -> dict:
 
         :return:
         """
-        result = eval(self.getParameter("HWROI"))
+        result = json.loads(self.getParameter("HWROI"))
         return result
 
     @HWROI.setter
@@ -278,6 +298,7 @@ def FocusDistance(self, value: float) -> None:
                              .format(self.getAllParameterLimits()["FocusDistance"]))
         self._applicationProxy.setParameter("FocusDistance", value)
         # TODO: Wird hier geblockt? Wird der Focus Distance direkt nach dem setzen angefahren?
+        # Edit: Kein Error, jedoch sind die Bilder unscharf wenn direkt danach das Bild angefordert wird: Fokus wird während requestImage im PCIC noch angefahren!
         self.waitForConfigurationDone()
 
     @property
@@ -507,3 +528,13 @@ def waitForConfigurationDone(self):
         :return: None
         """
         self._applicationProxy.waitForConfigurationDone()
+
+    def __getattr__(self, name):
+        """Pass given name to the actual xmlrpc.client.ServerProxy.
+
+        Args:
+            name (str): name of attribute
+        Returns:
+            Attribute of xmlrpc.client.ServerProxy
+        """
+        return self._editProxy.__getattr__(name)