syndesi 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

syndesi/__init__.py

@@ -0,0 +1,6 @@
+from .tools.log import set_log_file, set_log_level
+
+from .adapters.ip import IP
+from .adapters.serialport import SerialPort
+from .protocols.delimited import Delimited
+from .protocols.scpi import SCPI

syndesi/adapters/adapter.py

@@ -14,7 +14,6 @@
 #
 # An adapter is meant to work with bytes objects but it can accept strings.
 # Strings will automatically be converted to bytes using utf-8 encoding
-#
 
 from abc import abstractmethod, ABC
 from .timed_queue import TimedQueue
@@ -26,12 +25,13 @@ from .timeout import Timeout, TimeoutException, timeout_fuse
 from typing import Union
 from ..tools.types import is_number
 from ..tools.log import LoggerAlias
+import socket
 import logging
 from time import time
 from dataclasses import dataclass
 from ..tools.others import DEFAULT
 
-DEFAULT_TIMEOUT = Timeout(response=1, continuation=100e-3, total=None)
+DEFAULT_TIMEOUT = Timeout(response=5, continuation=200e-3, total=None)
 DEFAULT_STOP_CONDITION = None
 
 
@@ -48,7 +48,7 @@ STOP_DESIGNATORS = {
         Termination : 'ST',
         Length : 'SL'
     },
-    'previous-read-buffer' : 'RB'
+    'previous-buffer' : 'PB'
 }
 
 class Origin(Enum):
@@ -81,7 +81,7 @@ class Adapter(ABC):
         alias : str
             The alias is used to identify the class in the logs
         timeout : float or Timeout instance
-            Default timeout is Timeout(response=1, continuation=0.1, total=None)
+            Default timeout is Timeout(response=5, continuation=0.2, total=None)
         stop_condition : StopCondition or None
             Default to None
         """
@@ -97,10 +97,11 @@ class Adapter(ABC):
         self._thread : Union[Thread, None] = None
         self._status = self.Status.DISCONNECTED
         self._logger = logging.getLogger(LoggerAlias.ADAPTER.value)
+        self._thread_stop_read, self._thread_stop_write = socket.socketpair()
 
         # Buffer for data that has been pulled from the queue but
         # not used because of termination or length stop condition
-        self._previous_read_buffer = b''
+        self._previous_buffer = b''
 
         self._default_timeout = timeout == DEFAULT
         if self._default_timeout:
@@ -113,6 +114,16 @@ class Adapter(ABC):
             else:
                 raise ValueError(f"Invalid timeout type : {type(timeout)}")
 
+    def set_timeout(self, timeout : Timeout):
+        """
+        Overwrite timeout
+
+        Parameters
+        ----------
+        timeout : Timeout
+        """
+        self._timeout = timeout
+
     def set_default_timeout(self, default_timeout : Union[Timeout, tuple, float]):
         """
         Set the default timeout for this adapter. If a previous timeout has been set, it will be fused
@@ -122,9 +133,22 @@ class Adapter(ABC):
         default_timeout : Timeout or tuple or float
         """
         if self._default_timeout:
+            self._logger.debug(f'Setting default timeout to {default_timeout}')
             self._timeout = default_timeout
         else:
+            log = f'Fusing timeouts {self._timeout}+{default_timeout} -> '
             self._timeout = timeout_fuse(self._timeout, default_timeout)
+            self._logger.debug(f'{log}{self._timeout}')
+
+    def set_stop_condition(self, stop_condition):
+        """
+        Overwrite the stop-condition
+
+        Parameters
+        ----------
+        stop_condition : StopCondition
+        """
+        self._stop_condition = stop_condition
 
     def set_default_stop_condition(self, stop_condition):
         """
@@ -142,7 +166,17 @@ class Adapter(ABC):
         Flush the input buffer
         """
         self._read_queue.clear()
-        self._previous_read_buffer = b''
+        self._previous_buffer = b''
+
+    def previous_read_buffer_empty(self):
+        """
+        Check whether the previous read buffer is empty
+
+        Returns
+        -------
+        empty : bool
+        """
+        return self._previous_buffer == b''
 
     @abstractmethod
     def open(self):
@@ -151,12 +185,12 @@ class Adapter(ABC):
         """
         pass
 
-    @abstractmethod
     def close(self):
         """
         Stop communication with the device
         """
-        pass
+        self._logger.debug('Closing adapter and stopping read thread')
+        self._thread_stop_write.send(b'1')
 
     @abstractmethod
     def write(self, data : Union[bytes, str]):
@@ -168,12 +202,9 @@ class Adapter(ABC):
         data : bytes or str
         """
         pass
-    
-    # TODO : Return None or b'' when read thread is killed while reading
-    # This is to detect if a server socket has been closed
 
 
-    def read(self, timeout=None, stop_condition=None, return_metrics : bool = False) -> bytes:
+    def read(self, timeout=DEFAULT, stop_condition=DEFAULT, return_metrics : bool = False) -> bytes:
         """
         Read data from the device
 
@@ -190,13 +221,12 @@ class Adapter(ABC):
             self.open()
 
         # Use adapter values if no custom value is specified
-        if timeout is None:
+        if timeout == DEFAULT:
             timeout = self._timeout
         elif isinstance(timeout, float):
             timeout = Timeout(timeout)
         
-        
-        if stop_condition is None:
+        if stop_condition == DEFAULT:
             stop_condition = self._stop_condition
 
         # If the adapter is closed, open it
@@ -206,18 +236,25 @@ class Adapter(ABC):
         if self._thread is None or not self._thread.is_alive():
             self._start_thread()
 
-        timeout_ms = timeout.initiate_read(len(self._previous_read_buffer) > 0)
+        timeout_ms = timeout.initiate_read(len(self._previous_buffer) > 0)
 
         if stop_condition is not None:
             stop_condition.initiate_read()
 
+
         deferred_buffer = b''
 
         # Start with the deferred buffer
         # TODO : Check if data could be lost here, like the data is put in the previous_read_buffer and is never
         # read back again because there's no stop condition
-        if len(self._previous_read_buffer) > 0 and stop_condition is not None:
-            stop, output, self._previous_read_buffer = stop_condition.evaluate(self._previous_read_buffer)
+        if len(self._previous_buffer) > 0:# and stop_condition is not None:
+            self._logger.debug(f'Using previous buffer ({self._previous_buffer})')
+            if stop_condition is not None:
+                stop, output, self._previous_buffer = stop_condition.evaluate(self._previous_buffer)
+            else:
+                stop = True
+                output = self._previous_buffer
+                self._previous_buffer = b''
             previous_read_buffer_used = True
         else:
             stop = False
@@ -231,8 +268,8 @@ class Adapter(ABC):
                 (timestamp, fragment) = self._read_queue.get(timeout_ms)
                 n_fragments += 1
 
-                if fragment == b'':
-                    raise AdapterDisconnected()
+                if isinstance(fragment, AdapterDisconnected):
+                    raise fragment
 
                 # 1) Evaluate the timeout
                 stop, timeout_ms = timeout.evaluate(timestamp)
@@ -248,10 +285,10 @@ class Adapter(ABC):
                             output += fragment
                     elif data_strategy == Timeout.OnTimeoutStrategy.STORE:
                         # Store the data
-                        self._previous_read_buffer = output
+                        self._previous_buffer = output
                         output = b''
                     elif data_strategy == Timeout.OnTimeoutStrategy.ERROR:
-                        raise TimeoutException(origin)
+                        raise TimeoutException(origin, timeout._stop_source_overtime, timeout._stop_source_limit)
                     break
                 else:
                     origin = None
@@ -267,7 +304,7 @@ class Adapter(ABC):
                     stop, kept_fragment, deferred_buffer = stop_condition.evaluate(fragment)
                     output += kept_fragment
                     if stop:
-                        self._previous_read_buffer = deferred_buffer
+                        self._previous_buffer = deferred_buffer
                 else:
                     output += fragment
                 if stop:
@@ -279,11 +316,11 @@ class Adapter(ABC):
             else:
                 designator = STOP_DESIGNATORS['stop_condition'][type(stop_condition)]
         else:
-            designator = STOP_DESIGNATORS['previous-read-buffer']
+            designator = STOP_DESIGNATORS['previous-buffer']
         
         read_duration = time() - read_start
-        if self._previous_read_buffer:
-            self._logger.debug(f'Read [{designator}, {read_duration*1e3:.3f}ms] : {output} , previous read buffer : {self._previous_read_buffer}')
+        if self._previous_buffer:
+            self._logger.debug(f'Read [{designator}, {read_duration*1e3:.3f}ms] : {output} , previous read buffer : {self._previous_buffer}')
         else:
             self._logger.debug(f'Read [{designator}, {read_duration*1e3:.3f}ms] : {output}')
 

syndesi/adapters/ip.py

@@ -1,25 +1,26 @@
 import socket
 from enum import Enum
-from .adapter import Adapter
+from .adapter import Adapter, AdapterDisconnected
 from ..tools.types import to_bytes
-from .timeout import Timeout
+from .timeout import Timeout, timeout_fuse
+from .stop_conditions import StopCondition
 from threading import Thread
 from .timed_queue import TimedQueue
 from typing import Union
 from time import time
 import argparse
-from ..tools import shell
+#from ..cli import shell
+from ..tools.others import DEFAULT
+import select
 
 class IP(Adapter):
-    DEFAULT_RESPONSE_TIMEOUT = 1
-    DEFAULT_CONTINUATION_TIMEOUT = 1e-3
-    DEFAULT_TOTAL_TIMEOUT = 5
-
-
     DEFAULT_TIMEOUT = Timeout(
-                        response=DEFAULT_RESPONSE_TIMEOUT,
-                        continuation=DEFAULT_CONTINUATION_TIMEOUT,
-                        total=DEFAULT_TOTAL_TIMEOUT)
+                        response=2,
+                        on_response='error',
+                        continuation=100e-3,
+                        on_continuation='return',
+                        total=5,
+                        on_total='error')
     DEFAULT_BUFFER_SIZE = 1024
     class Protocol(Enum):
         TCP = 'TCP'
@@ -29,8 +30,8 @@ class IP(Adapter):
                 address : str,
                 port : int = None,
                 transport : str = 'TCP',
-                timeout : Union[Timeout, float] = DEFAULT_TIMEOUT,
-                stop_condition = None,
+                timeout : Union[Timeout, float] = DEFAULT,
+                stop_condition : StopCondition = DEFAULT,
                 alias : str = '',
                 buffer_size : int = DEFAULT_BUFFER_SIZE,
                 _socket : socket.socket = None):
@@ -56,6 +57,11 @@ class IP(Adapter):
         socket : socket.socket
             Specify a custom socket, this is reserved for server application
         """
+        if timeout == DEFAULT:
+            timeout = self.DEFAULT_TIMEOUT
+        else:
+            timeout = timeout_fuse(timeout, self.DEFAULT_TIMEOUT)
+        
         super().__init__(alias=alias, timeout=timeout, stop_condition=stop_condition)
         self._transport = self.Protocol(transport)
         self._is_server = _socket is not None
@@ -101,6 +107,13 @@ class IP(Adapter):
         self._logger.info(f"Adapter {self._alias} opened !")
 
     def close(self):
+        super().close()
+        if self._thread is not None and self._thread.is_alive():
+            try:
+                self._thread.join()
+            except RuntimeError:
+                # If the thread cannot be joined, then so be it
+                pass
         if hasattr(self, '_socket'):
             self._socket.close()
         self._logger.info("Adapter closed !")
@@ -114,31 +127,47 @@ class IP(Adapter):
         write_start = time()
         self._socket.send(data)
         write_duration = time() - write_start
-        self._logger.debug(f"Written [{write_duration*1e3:.3f}ms]: {repr(data)}")
+        self._logger.debug(f"Write [{write_duration*1e3:.3f}ms]: {repr(data)}")
 
     def _start_thread(self):
         self._logger.debug("Starting read thread...")
-        self._thread = Thread(target=self._read_thread, daemon=True, args=(self._socket, self._read_queue))
-        self._thread.start()
-
-    # EXPERIMENTAL
-    def read_thread_alive(self):
-        return self._thread.is_alive()
+        if self._thread is None or not self._thread.is_alive():
+            self._thread = Thread(target=self._read_thread, daemon=True, args=(self._socket, self._read_queue, self._thread_stop_read))
+            self._thread.start()
 
+    # # EXPERIMENTAL
+    # def read_thread_alive(self):
+    #     return self._thread.is_alive()
 
-    def _read_thread(self, socket : socket.socket, read_queue : TimedQueue):
+    def _read_thread(self, socket : socket.socket, read_queue : TimedQueue, stop : socket.socket):
+        # Using select.select works on both Windows and Linux as long as the inputs are all sockets
         while True: # TODO : Add stop_pipe ? Maybe it was removed ?
+            
             try:
-                payload = socket.recv(self._buffer_size)
-                if len(payload) == self._buffer_size and self._transport == self.Protocol.UDP:
-                    self._logger.warning("Warning, inbound UDP data may have been lost (max buffer size attained)")
-            except OSError:
-                break
-            # If payload is empty, it means the socket has been disconnected
-            if payload == b'':
-                read_queue.put(payload)
-                break
-            read_queue.put(payload)
+                ready, _, _ = select.select([socket, stop], [], [])
+            except ValueError:
+                # File desctiptor is s negative integer
+                read_queue.put(AdapterDisconnected())
+            else:
+                if stop in ready:
+                    # Stop the thread
+                    stop.recv(1)
+                    break
+                elif socket in ready:
+                    # Read from the socket
+                    try:
+                        payload = socket.recv(self._buffer_size)
+                    except ConnectionRefusedError:
+                        # TODO : Check if this is the right way of doing it
+                        read_queue.put(AdapterDisconnected())
+                    else:
+                        if len(payload) == self._buffer_size and self._transport == self.Protocol.UDP:
+                            self._logger.warning("Warning, inbound UDP data may have been lost (max buffer size attained)")
+                        if payload == b'':
+                            read_queue.put(AdapterDisconnected())
+                            break
+                        else:
+                            read_queue.put(payload)
 
     def query(self, data : Union[bytes, str], timeout=None, stop_condition=None, return_metrics : bool = False):
         if self._is_server:

syndesi/adapters/proxy.py

@@ -46,16 +46,24 @@ class Proxy(Adapter):
 
         if isinstance(proxy_adapter, IP):
             proxy_adapter.set_default_port(DEFAULT_PORT)
-
         if isinstance(self._remote, IP):
             self._proxy.query(IPInstanciate(
-                    address=self._remote._address,
-                    port=self._remote._port,
-                    transport=self._remote._transport,
-                    buffer_size=self._remote._buffer_size
-                ).encode())
+                address=self._remote._address,
+                port=self._remote._port,
+                transport=self._remote._transport,
+                buffer_size=self._remote._buffer_size,
+            ).encode())
         elif isinstance(self._remote, SerialPort):
-            self._proxy.query()
+            self._proxy.query(SerialPortInstanciate(
+                port=self._remote._port_name,
+                baudrate=self._remote._baudrate,
+                timeout=timeout_to_api(self._remote._timeout),
+                stop_condition=stop_condition_to_api(self._remote._stop_condition)
+            ))
+        elif isinstance(self._remote, VISA):
+            self._proxy.query(VisaInstanciate(
+                resource=self._remote._resource,
+            ))
 
     def check(self, status : ReturnStatus):
         if not status.success:
@@ -82,7 +90,6 @@ class Proxy(Adapter):
         else:
             raise RuntimeError(f"Invalid return : {type(output)}")
 
-
     def query(self, data : Union[bytes, str], timeout=None, stop_condition=None, return_metrics : bool = False):
         self.check(parse(self._proxy.query(AdapterFlushRead().encode())))
         self.check(parse(self._proxy.query(AdapterWrite(data).encode())))

syndesi/adapters/serialport.py

@@ -4,27 +4,28 @@ from threading import Thread
 from typing import Union
 import select
 import argparse
+import socket
+import sys
 #from collections.abc import Sequence
 
-from .adapter import Adapter
+from .adapter import Adapter, AdapterDisconnected
 from ..tools.types import to_bytes
 from .stop_conditions import *
 from .timeout import Timeout
 from .timed_queue import TimedQueue
-from ..tools import shell
+#from ..cli import shell
 from ..tools.others import DEFAULT
 
-# From pyserial - serialposix.py
-import fcntl
-import termios
-import struct
-if hasattr(termios, 'TIOCINQ'):
-    TIOCINQ = termios.TIOCINQ
-else:
-    TIOCINQ = getattr(termios, 'FIONREAD', 0x541B)
-TIOCM_zero_str = struct.pack('I', 0)
+DEFAULT_TIMEOUT = Timeout(
+                    response=1,
+                    on_response='error',
+                    continuation=200e-3,
+                    on_continuation='return',
+                    total=None,
+                    on_total='error')
+
+
 
-DEFAULT_TIMEOUT = Timeout(response=1, continuation=200e-3, total=None)
 
 class SerialPort(Adapter):
     def __init__(self,  
@@ -46,15 +47,15 @@ class SerialPort(Adapter):
             
         super().__init__(timeout=timeout, stop_condition=stop_condition)
         self._logger.info(f"Setting up SerialPort adapter timeout:{timeout}, stop_condition:{stop_condition}")
-        self._port = serial.Serial(port=port, baudrate=baudrate)
+        self._port_name = port
+        self._baudrate = baudrate
+        self._port = serial.Serial(port=self._port_name, baudrate=self._baudrate)
         if self._port.isOpen():
             self._status = self.Status.CONNECTED
         else:
             self._status = self.Status.DISCONNECTED
 
         self._rts_cts = rts_cts
-        
-        self._stop_event_pipe, self._stop_event_pipe_write = os.pipe()
 
     def flushRead(self):
         self._port.flush()
@@ -68,10 +69,15 @@ class SerialPort(Adapter):
         self._logger.info("Adapter opened !")
 
     def close(self):
+        super().close()
         if self._thread is not None and self._thread.is_alive():
-            os.write(self._stop_event_pipe_write, b'1')
-            self._thread.join()
+            try:
+                self._thread.join()
+            except RuntimeError:
+                # If the thread cannot be joined, then so be it
+                pass
         if hasattr(self, '_port'):
+            # Close and the read thread will die by itself
             self._port.close()
         self._logger.info("Adapter closed !")
             
@@ -84,7 +90,7 @@ class SerialPort(Adapter):
         write_start = time()
         self._port.write(data)
         write_duration = time() - write_start
-        self._logger.debug(f"Written [{write_duration*1e3:.3f}ms]: {repr(data)}")
+        self._logger.debug(f"Write [{write_duration*1e3:.3f}ms]: {repr(data)}")
 
     def _start_thread(self):
         """
@@ -92,26 +98,44 @@ class SerialPort(Adapter):
         """
         self._logger.debug("Starting read thread...")
         if self._thread is None or not self._thread.is_alive():
-            self._thread = Thread(target=self._read_thread, daemon=True, args=(self._port, self._read_queue, self._stop_event_pipe))
+            self._thread = Thread(target=self._read_thread, daemon=True, args=(self._port, self._read_queue, self._thread_stop_read))
             self._thread.start()
 
-    def _read_thread(self, port : serial.Serial , read_queue : TimedQueue, stop_event_pipe):
+    def _read_thread(self, port : serial.Serial,read_queue : TimedQueue, stop : socket.socket):
+        # On linux, it is possivle to use the select.select for both serial port and stop socketpair.
+        # On Windows, this is not possible. so the port timeout is used instead.
+        if sys.platform == 'win32':
+            port.timeout = 0.1
         while True:
-            # It looks like using the raw implementation of port.in_waiting and port.read is better, there's no more warnings
-            # Equivalent of port.in_waiting :
-            #in_waiting = struct.unpack('I', fcntl.ioctl(port.fd, TIOCINQ, TIOCM_zero_str))[0]
-            in_waiting = self._port.in_waiting # This is a temporary fix to get windows compatiblity back, an error might pop up
-            if in_waiting == 0:
-                ready, _, _ = select.select([port.fd, stop_event_pipe], [], [], None)
-                if stop_event_pipe in ready:
-                    # Stop
+            # Check how many bytes are available
+            if sys.platform == 'win32':
+                ready, _, _ = select.select([stop], [], [], 0)
+                if stop in ready:
+                    # Stop the read thread
                     break
-            # Else, read as many bytes as possible
-            fragment = os.read(port.fd, 1000) # simplified version of port.read()
-            if fragment:
-                read_queue.put(fragment)        
-
-    def read(self, timeout=None, stop_condition=None, return_metrics: bool = False) -> bytes:
+                else:
+                    # Read data from the serialport with a timeout, if the timeout occurs, read again.
+                    # This is to avoid having a crazy fast loop
+                    data = port.read()
+                    if len(data) > 0:
+                        read_queue.put(fragment)
+            else:
+                ready, _, _ = select.select([self._port.fd, stop], [], [])
+                if stop in ready:
+                    # Stop the read thread
+                    break
+                elif self._port.fd in ready:
+                    try:
+                        in_waiting = self._port.in_waiting
+                    except OSError:
+                        # Input/output error, the port was disconnected
+                        read_queue.put(AdapterDisconnected)
+                    else:
+                        fragment = port.read(in_waiting)
+                        if fragment:
+                            read_queue.put(fragment) 
+
+    def read(self, timeout=DEFAULT, stop_condition=DEFAULT, return_metrics: bool = False) -> bytes:
         """
         Read data from the device
 
@@ -140,19 +164,19 @@ class SerialPort(Adapter):
         self.write(data)
         return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
 
-    def shell_parse(inp: str):
-        parser = argparse.ArgumentParser(
-        prog='',
-        description='Serial port shell parser',
-        epilog='')
-        # Parse subcommand    
-        parser.add_argument('--' + shell.Arguments.PORT.value, type=str)
-        parser.add_argument('--' + shell.Arguments.BAUDRATE.value, type=int)
-        parser.add_argument('--' + shell.Arguments.ENABLE_RTS_CTS.value, action='store_true')
-        args = parser.parse_args(inp.split())
-
-        return {
-            'port' : getattr(args, shell.Arguments.PORT.value),
-            'baudrate' : getattr(args, shell.Arguments.BAUDRATE.value),
-            'rts_cts' : bool(getattr(args, shell.Arguments.ENABLE_RTS_CTS.value))
-        }
+    # def shell_parse(inp: str):
+    #     parser = argparse.ArgumentParser(
+    #     prog='',
+    #     description='Serial port shell parser',
+    #     epilog='')
+    #     # Parse subcommand    
+    #     parser.add_argument('--' + shell.Arguments.PORT.value, type=str)
+    #     parser.add_argument('--' + shell.Arguments.BAUDRATE.value, type=int)
+    #     parser.add_argument('--' + shell.Arguments.ENABLE_RTS_CTS.value, action='store_true')
+    #     args = parser.parse_args(inp.split())
+
+    #     return {
+    #         'port' : getattr(args, shell.Arguments.PORT.value),
+    #         'baudrate' : getattr(args, shell.Arguments.BAUDRATE.value),
+    #         'rts_cts' : bool(getattr(args, shell.Arguments.ENABLE_RTS_CTS.value))
+    #     }