syndesi 0.2.2__tar.gz → 0.2.3__tar.gz

{syndesi-0.2.2/syndesi.egg-info → syndesi-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: syndesi
-Version: 0.2.2
+Version: 0.2.3
 Summary: Syndesi
 Author: Sebastien Deriaz
 Author-email: sebastien.deriaz1@gmail.com

{syndesi-0.2.2 → syndesi-0.2.3}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '0.2.2'
+VERSION = '0.2.3'
 DESCRIPTION = 'Syndesi'
 
 with open("README.md", "r", encoding="utf-8") as fh:
@@ -17,7 +17,7 @@ setup(
     long_description=long_description,
     entry_points = {
         'console_scripts': [
-            'syndesi=syndesi.shell.syndesi:main',
+            'syndesi=syndesi.cli.syndesi:main',
             'syndesi-proxy=syndesi.proxy.proxy:main'],
     },
     packages=find_packages(),

syndesi-0.2.3/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-0.2.2 → syndesi-0.2.3}/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-0.2.2 → syndesi-0.2.3}/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-0.2.2 → syndesi-0.2.3}/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-0.2.2 → syndesi-0.2.3}/syndesi/adapters/serialport.py

@@ -4,17 +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
 
-DEFAULT_TIMEOUT = Timeout(response=1, continuation=200e-3, total=None)
+DEFAULT_TIMEOUT = Timeout(
+                    response=1,
+                    on_response='error',
+                    continuation=200e-3,
+                    on_continuation='return',
+                    total=None,
+                    on_total='error')
+
+
+
 
 class SerialPort(Adapter):
     def __init__(self,  
@@ -36,7 +47,9 @@ 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:
@@ -56,6 +69,13 @@ class SerialPort(Adapter):
         self._logger.info("Adapter 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, '_port'):
             # Close and the read thread will die by itself
             self._port.close()
@@ -70,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):
         """
@@ -78,21 +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._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):
-        # NOTE : There should be some way to kill the thread, maybe check for an error on in_waiting but couldn't find it so far
+    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:
             # Check how many bytes are available
-            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:
-                # Read those bytes
-                fragment = port.read(in_waiting)
-                if fragment:
-                    read_queue.put(fragment)        
-
-    def read(self, timeout=None, stop_condition=None, return_metrics: bool = False) -> bytes:
+            if sys.platform == 'win32':
+                ready, _, _ = select.select([stop], [], [], 0)
+                if stop in ready:
+                    # Stop the read thread
+                    break
+                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
 
@@ -121,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))
+    #     }

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi/adapters/timeout.py

@@ -5,7 +5,6 @@
 from enum import Enum
 from typing import Union, Tuple
 from time import time
-#from ..tools.others import is_default_argument
 
 
 class Timeout():
@@ -16,9 +15,9 @@ class Timeout():
         ERROR = 'error' # If a timeout is reached, raise an error
 
     class TimeoutType(Enum):
-        RESPONSE = 0
-        CONTINUATION = 1
-        TOTAL = 2
+        RESPONSE = 'response'
+        CONTINUATION = 'continuation'
+        TOTAL = 'total'
         
     class _State(Enum):
         WAIT_FOR_RESPONSE = 0
@@ -26,12 +25,12 @@ class Timeout():
 
     DEFAULT_CONTINUATION = 5e-3
     DEFAULT_TOTAL = None
-    DEFAULT_ON_RESPONSE = OnTimeoutStrategy.DISCARD
+    DEFAULT_ON_RESPONSE = OnTimeoutStrategy.ERROR
     DEFAULT_ON_CONTINUATION = OnTimeoutStrategy.RETURN
     DEFAULT_ON_TOTAL = OnTimeoutStrategy.RETURN
 
     def __init__(self, 
-        response,
+        response=None,
         continuation=None,
         total=None,
         on_response=None,
@@ -151,6 +150,8 @@ class Timeout():
     def evaluate(self, timestamp : float) -> Tuple[bool, Union[float, None]]:
         stop = False
         self._data_strategy = None
+        self._stop_source_overtime = '###' # When a timeout occurs, store the value that exceeded its value here
+        self._stop_source_limit = '###' # And store the limit value here
 
         # First check if the timestamp is None, that would mean the timeout was reached in the queue
         if timestamp is None:
@@ -158,15 +159,17 @@ class Timeout():
             match self._queue_timeout_type:
                 case self.TimeoutType.RESPONSE:
                     self._data_strategy = self._on_response
-                    self.response_time = self._output_timeout # This is a test
+                    self._stop_source_limit = self._response
                 case self.TimeoutType.CONTINUATION:
                     self._data_strategy = self._on_continuation
-                    self.continuation_times.append(self._output_timeout) # This is a test
+                    self._stop_source_limit = self._continuation
                 case self.TimeoutType.TOTAL:
-                    self.total_time = self._output_timeout # This is a test
                     self._data_strategy = self._on_total
+                    self._stop_source_limit = self._total
+            self._stop_source_overtime = None # We do not have the exceed time, but None will be printed as '---'
             self._last_data_strategy_origin = self._queue_timeout_type
-            stop = True 
+            stop = True
+            
         else:
             # Check total
             if self._total is not None:
@@ -175,23 +178,27 @@ class Timeout():
                     stop = True
                     self._data_strategy = self._on_total
                     self._last_data_strategy_origin = self.TimeoutType.TOTAL
+                    self._stop_source_overtime = self.total_time
+                    self._stop_source_limit = self._total
             # Check continuation
-            # elif
-            if self._continuation is not None and self._state == self._State.CONTINUATION and self._last_timestamp is not None:
+            elif self._continuation is not None and self._state == self._State.CONTINUATION and self._last_timestamp is not None:
                 continuation_time = timestamp - self._last_timestamp
                 self.continuation_times.append(continuation_time)
                 if continuation_time >= self._continuation:
                     stop = True
                     self._data_strategy = self._on_continuation
                     self._last_data_strategy_origin = self.TimeoutType.CONTINUATION
+                    self._stop_source_overtime = continuation_time
+                    self._stop_source_limit = self._continuation
             # Check response time
-            # elif
-            if self._response is not None and self._state == self._State.WAIT_FOR_RESPONSE:
+            elif self._response is not None and self._state == self._State.WAIT_FOR_RESPONSE:
                 self.response_time = timestamp - self._start_time
                 if self.response_time >= self._response:
                     stop = True
                     self._data_strategy = self._on_response
                     self._last_data_strategy_origin = self.TimeoutType.RESPONSE
+                    self._stop_source_overtime = self.response_time
+                    self._stop_source_limit = self._response
 
         self._output_timeout = None
         # If we continue
@@ -236,9 +243,9 @@ class Timeout():
         return self._data_strategy, self._last_data_strategy_origin
 
     def __str__(self) -> str:
-        response = f'r:{self._response:.3f}ms/{self._on_response},' if self._response is not None else ''
-        continuation = f'c:{self._continuation:.3f}ms/{self._on_continuation},' if self._continuation is not None else ''
-        total = f't:{self._total:.3f}ms/{self._on_total}' if self._total is not None else ''
+        response = f'r:{self._response*1e3:.3f}ms/{self._on_response.value},' if self._response is not None else ''
+        continuation = f'c:{self._continuation*1e3:.3f}ms/{self._on_continuation.value},' if self._continuation is not None else ''
+        total = f't:{self._total*1e3:.3f}ms/{self._on_total.value}' if self._total is not None else ''
         return f'Timeout({response}{continuation}{total})'
 
     def __repr__(self) -> str:
@@ -246,10 +253,28 @@ class Timeout():
 
 
 class TimeoutException(Exception):
-    def __init__(self, type : Timeout.TimeoutType) -> None:
+    def __init__(self, type : Timeout.TimeoutType, value : float, limit : float) -> None:
         super().__init__()
         self._type = type
+        self._value = value
+        self._limit = limit
+    
+    def __str__(self) -> str:
+        try:
+            value_string = f'{self._value*1e3:.3f}ms'
+        except (ValueError, TypeError):
+            value_string = 'not received'
+
+        try:
+            limit_string = f'{self._limit*1e3:.3f}ms'
+        except (ValueError, TypeError):
+            limit_string = 'not received'
+
 
+        return f'{self._type.value} : {value_string} / {limit_string}'
+
+    def __repr__(self) -> str:
+        return self.__str__()
 
 def timeout_fuse(high_priority, low_priority):
     """
@@ -292,6 +317,6 @@ def timeout_fuse(high_priority, low_priority):
         L = getattr(low, attr)
         # Use low priority if the default value is used in high priority
         new_attr[attr.removeprefix('_')] = L if high._defaults[attr] else H
-        
+
     return Timeout(**new_attr)
 

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi/adapters/visa.py

@@ -6,17 +6,18 @@ from ..tools.types import to_bytes
 from typing import Union
 
 class VISA(Adapter):
-    def __init__(self, descriptor : str):
+    def __init__(self, resource : str):
         """
         USB VISA stack adapter
 
         Parameters
         ----------
-        descriptor : str
-            IP description
+        resource : str
+            resource address string
         """
+        self._resource = resource
         self._rm = ResourceManager()
-        self._inst = self._rm.open_resource(descriptor)
+        self._inst = self._rm.open_resource(self._resource)
         self._inst.write_termination = ''
         self._inst.read_termination = ''
 

{syndesi-0.2.2/syndesi/tools → syndesi-0.2.3/syndesi/cli}/shell.py

@@ -3,22 +3,45 @@
 # 30.04.2024
 from enum import Enum
 from cmd import Cmd
-from syndesi.adapters import *
+from ..adapters import *
+from ..protocols import Delimited
+from ..tools.log import set_log_file, set_log_level, LoggerAlias
 import argparse
+import logging
 import shlex
 import sys
 import os
-from colorist import ColorRGB
+#from colorist import ColorRGB
 
 VERSION = 0.1
 
 class ShellPrompt(Cmd):
+    _logger = logging.getLogger(LoggerAlias.CLI.value)
     __hiden_methods = ('do_EOF','do_clear','do_cls')
-    PROMPT_COLOR = ColorRGB(28, 90, 145)
+    #PROMPT_COLOR = ColorRGB(28, 90, 145)
 
-    prompt = f'{PROMPT_COLOR}❯ {PROMPT_COLOR.OFF}'
+    #prompt = f'{PROMPT_COLOR}❯ {PROMPT_COLOR.OFF}'
+    prompt = f'❯ '
     intro = "Welcome to the Syndesi Shell! Type ? to list commands"
 
+    common_parser = argparse.ArgumentParser(add_help=False)
+    common_parser.add_argument('-v', '--verbose', help='Print logging informations', action='store_true', default=False)
+    common_parser.add_argument('-d', '--debug', help='Print debug informations', action='store_true', default=False)
+    common_parser.add_argument('--log-file', type=str, default='')
+
+    def _parse_common_args(self, args):
+        common_args, other_args = self.common_parser.parse_known_args(args)
+        if common_args.debug:
+            set_log_level('DEBUG')
+        elif common_args.verbose:
+            set_log_level('INFO')
+        
+        if common_args.log_file != '': # TODO : test this
+            set_log_file(common_args.log_file)
+        
+        return other_args
+
+
     def get_names(self):
         return [n for n in dir(self.__class__) if n not in self.__hiden_methods]
 
@@ -31,25 +54,32 @@ class ShellPrompt(Cmd):
         self._adapter = SerialPort(**SerialPort.shell_parse(inp))
 
     def do_ip(self, inp):
-        """Open IP adapter
-    -p / --port : port number
-    --ip : ip address
-    -t / --transport : TCP or UDP
-        """
-        parser = argparse.ArgumentParser()
+        """Open IP adapter with delimited protocol (\\n at the end of each line by default)"""
+        arguments = shlex.split(inp)
+        other_arguments = self._parse_common_args(arguments)
+
+        parser = argparse.ArgumentParser(
+            prog='ip'
+        )
+        parser.add_argument('ip', type=str)
         parser.add_argument('-p', '--port', type=int, required=True)
-        parser.add_argument('--ip', type=str, required=True)
         parser.add_argument('-t', '--transport', type=str, choices=['UDP', 'TCP'], default='TCP', required=False)
+        parser.add_argument('-e', '--end', help='Newline character, \\n by default, on unix systems, use -e \'\\\\n\' to circumvent backslash substitution', default='\n', required=False)
         try:
-            args = parser.parse_args(shlex.split(inp))
+            args = parser.parse_args(other_arguments)
         except SystemExit as e:
             pass
         else:
-            self._adapter = IP(address=args.ip, port=args.port, transport=args.transport)
+            end_string : str = args.end
+            termination = end_string.encode('utf-8').decode('unicode_escape')
+            self._logger.debug(f'Opening Delimited IP with termination : {repr(termination)}')
+            self._adapter = Delimited(IP(address=args.ip, port=args.port, transport=args.transport), termination=termination)
+            self._adapter._adapter.open()
+            print(f"Successfully opened IP adapter at {args.ip}:{args.port} ({repr(termination)} termination)")
 
     def default(self, inp):
         if hasattr(self, '_adapter'):
-            cmd = inp + '\n'
+            cmd = inp
             output = self._adapter.query(cmd)
             print(output)
         else:

syndesi-0.2.3/syndesi/cli/syndesi.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+
+# Syndesi CLI
+import argparse
+from enum import Enum
+from syndesi.cli.shell import ShellPrompt
+
+class SubCommands(Enum):
+    SHELL = 'shell'
+   
+def main():
+    parser = argparse.ArgumentParser(
+        prog='syndesi',
+        description='Syndesi command line interface',
+        epilog='')
+    # Parse subcommand
+    parser.add_argument('subcommand', choices=[SubCommands.SHELL.value])
+
+    args, extra_args = parser.parse_known_args()
+
+    if args.subcommand == SubCommands.SHELL.value:
+        p = ShellPrompt()
+        if len(extra_args):
+            p.cmdqueue.append(' '.join(extra_args))
+        p.cmdloop()
+        
+
+
+if __name__ == '__main__':
+    main()

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi/protocols/delimited.py

@@ -1,12 +1,13 @@
 from .protocol import Protocol
 from ..adapters import Adapter, Timeout, Termination
 from ..tools.types import assert_byte_instance, assert_byte_instance
+from ..tools.others import DEFAULT
 from time import time
 import warnings
 
 
 class Delimited(Protocol):
-    def __init__(self, adapter : Adapter, termination='\n', format_response=True, encoding : str = 'utf-8', timeout : Timeout = None) -> None:
+    def __init__(self, adapter : Adapter, termination='\n', format_response=True, encoding : str = 'utf-8', timeout : Timeout = DEFAULT) -> None:
         """
         Protocol with delimiter, like LF, CR, etc... '\\n' is used by default
 
@@ -65,7 +66,7 @@ class Delimited(Protocol):
         self.write(command)
         return self.read()
 
-    def read(self, timeout : Timeout = None, decode : str = True) -> str:
+    def read(self, timeout : Timeout = DEFAULT, decode : str = True) -> str:
         """
         Reads command and formats it as a str
 
@@ -79,7 +80,10 @@ class Delimited(Protocol):
         # Send up to the termination
         data = self._adapter.read(timeout=timeout)
         if decode:
-            data = data.decode(self._encoding)
+            try:
+                data = data.decode(self._encoding)
+            except UnicodeDecodeError as e:
+                raise ValueError(f'Failed to decode {data} to {self._encoding} ({e})')
         if self._response_formatting:
             # Only send the fragment (no termination)
             return data

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi/protocols/protocol.py

@@ -7,6 +7,9 @@ class Protocol:
         self._adapter = auto_adapter(adapter)
         self._adapter.set_default_timeout(timeout)
 
+    def flushRead(self):
+        self._adapter.flushRead()
+
     def write(self, data):
         pass
 

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi/protocols/raw.py

@@ -1,12 +1,13 @@
 from ..adapters import Adapter, Timeout
 from .protocol import Protocol
+from ..tools.others import DEFAULT
 
 
 # Raw protocols provide the user with the binary data directly,
 # without converting it to string first
 
 class Raw(Protocol):
-    def __init__(self, adapter: Adapter, timeout : Timeout = None) -> None:
+    def __init__(self, adapter: Adapter, timeout : Timeout = DEFAULT) -> None:
         """
         Raw device, no presentation and application layers
 

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi/protocols/scpi.py

@@ -1,12 +1,13 @@
 from ..adapters import Adapter, IP, Timeout, Termination, StopCondition
 from .protocol import Protocol
 from ..tools.types import is_byte_instance
-#from ..tools.others import is_default_argument
 from ..tools.others import DEFAULT
 
+DEFAULT_TIMEOUT = Timeout(response=10, continuation=0.5, total=None, on_response='error', on_continuation='error')
+
 class SCPI(Protocol):
     DEFAULT_PORT = 5025
-    def __init__(self, adapter: Adapter, send_termination = '\n', receive_termination = None, timeout : Timeout = None, encoding : str = 'utf-8') -> None:
+    def __init__(self, adapter: Adapter, send_termination = '\n', receive_termination = None, timeout : Timeout = DEFAULT, encoding : str = 'utf-8') -> None:
         """
         SDP (Syndesi Device Protocol) compatible device
 
@@ -20,22 +21,25 @@ class SCPI(Protocol):
         timeout : Timeout/float/tuple
             Set device timeout
         """
-        super().__init__(adapter=adapter, timeout=timeout)
-
+        self._encoding = encoding
+        # Set the default timeout
+        if timeout == DEFAULT:
+            timeout = DEFAULT_TIMEOUT
+        
         if receive_termination is None:
             self._receive_termination = send_termination
         else:
             self._receive_termination = receive_termination
-
         self._send_termination = send_termination
-
-        if isinstance(self._adapter, IP):
-            self._adapter.set_default_port(self.DEFAULT_PORT)
-
-        self._adapter.set_default_timeout(timeout)
-        if self._adapter._stop_condition != DEFAULT:
-            raise ValueError('A conflicting stop-condition has been set for this adapter')
-        self._adapter._stop_condition = Termination(self._receive_termination.encode(encoding=encoding))
+        # Configure the adapter for stop-condition mode (timeouts will raise errors)
+        if not adapter._default_stop_condition:
+            raise ValueError('No stop-conditions can be set for an adapter used by SCPI protocol')
+        adapter.set_stop_condition(Termination(self._receive_termination.encode(self._encoding)))
+        adapter.set_timeout(timeout)
+        if isinstance(adapter, IP):
+            adapter.set_default_port(self.DEFAULT_PORT)
+        # Give the adapter to the Protocol base class
+        super().__init__(adapter=adapter, timeout=timeout)
 
     def _to_bytes(self, command):
         if isinstance(command, str):
@@ -65,12 +69,12 @@ class SCPI(Protocol):
         payload = self._to_bytes(self._formatCommand(command))
         self._adapter.write(payload)
 
-    def query(self, command : str, timeout : Timeout = None, stop_condition : StopCondition = None, return_metrics : bool = False) -> str:
+    def query(self, command : str, timeout : Timeout = DEFAULT, stop_condition : StopCondition = DEFAULT, return_metrics : bool = False) -> str:
         self._adapter.flushRead()
         self.write(command)
         return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
 
-    def read(self, timeout : Timeout = None, stop_condition : StopCondition = None, return_metrics : bool = False) -> str:
+    def read(self, timeout : Timeout = DEFAULT, stop_condition : StopCondition = None, return_metrics : bool = False) -> str:
         output = self._from_bytes(self._adapter.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics))
         return self._unformatCommand(output)
 

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi/proxy/proxy_api.py

@@ -4,21 +4,14 @@
 
 import sys
 from dataclasses import dataclass
+from ..adapters.stop_conditions import Length, Termination, StopCondition
+from ..adapters.timeout import Timeout
 
 from ..api.api import APICall, ACTION_ATTRIBUTE, register_api, APIItem
 
 class ProxyException(Exception):
     pass
 
-# IP specific
-@dataclass
-class IPInstanciate(APICall):
-    action = 'ip_adapter_inst'
-    address : str
-    port : int
-    transport : str
-    buffer_size : int
-
 @dataclass
 class TimeoutAPI(APIItem):
     name = 'timeout'
@@ -29,10 +22,22 @@ class TimeoutAPI(APIItem):
     on_continuation : str
     on_total : str
 
+def timeout_to_api(timeout : Timeout) -> TimeoutAPI:
+    if timeout is None:
+        return None
+    else:
+        return TimeoutAPI(
+            response=timeout._response,
+            continuation=timeout._continuation,
+            total=timeout._total,
+            on_response=timeout._on_response,
+            on_continuation=timeout._on_continuation,
+            on_total=timeout._on_total
+        )
+
 @dataclass
 class StopConditionAPI(APIItem):
     pass
-
 @dataclass
 class TerminationAPI(StopConditionAPI):
     name = 'termination'
@@ -43,6 +48,23 @@ class LengthAPI(StopConditionAPI):
     name = 'length'
     length : int
 
+def stop_condition_to_api(stop_condition : StopCondition):
+    if stop_condition is None:
+        return None
+    elif isinstance(stop_condition, Length):
+        return LengthAPI(length=stop_condition._N)
+    elif isinstance(stop_condition, Termination):
+        return TerminationAPI(sequence=stop_condition._termination)
+# IP specific
+@dataclass
+class IPInstanciate(APICall):
+    action = 'ip_adapter_inst'
+    address : str
+    port : int
+    transport : str
+    buffer_size : int
+    timeout : TimeoutAPI
+
 # Serial specific
 @dataclass
 class SerialPortInstanciate(APICall):
@@ -53,6 +75,13 @@ class SerialPortInstanciate(APICall):
     stop_condition : StopConditionAPI
     rts_cts : bool
 
+# VISA specific
+@dataclass
+class VisaInstanciate(APICall):
+    action = 'visa_instanciate'
+    resource : str
+    
+
 # Adapters common
 @dataclass
 class AdapterOpen(APICall):

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi/tools/log.py

@@ -9,9 +9,10 @@ import logging
 from typing import List, Union
 
 class LoggerAlias(Enum):
-    ADAPTER = 'adapter'
-    PROTOCOL = 'protocol'
-    PROXY_SERVER = 'proxy_server'
+    ADAPTER = 'syndesi.adapter'
+    PROTOCOL = 'syndesi.protocol'
+    PROXY_SERVER = 'syndesi.proxy_server'
+    CLI = 'syndesi.cli'
 
 default_formatter = logging.Formatter('%(asctime)s:%(name)s:%(levelname)s:%(message)s')
 
@@ -53,21 +54,19 @@ def set_log_file(file : str, level : Union[str, int], loggers : Union[List[Logge
         file_handler.setFormatter(default_formatter)
         # 3) Add to the designated loggers
         for l in LoggerAlias:
-            if l in loggers or loggers == 'all':
+            if loggers == 'all' or l.value in loggers:
                 logger = logging.getLogger(l.value)
                 logger.addHandler(file_handler)
                 logger.setLevel(level)
     else:
         file_handler = None
     
-def set_log_stream(enabled : bool, level : Union[str, int], loggers : Union[List[LoggerAlias], str] = 'all'):
+def set_log_level(level : Union[str, int], loggers : Union[List[LoggerAlias], str] = 'all'):
     """
-    Set stdout/stderr log mode
+    Set log level, everything below or equal to the given level will be outputed to stdout/stderr.
 
     Parameters
     ----------
-    enabled : bool
-        enable / disable log to stdout / stderr
     level : str or logging level
         info     : 'INFO'     or logging.INFO
         critical : 'CRITICAL' or logging.CRITICAL
@@ -75,6 +74,7 @@ def set_log_stream(enabled : bool, level : Union[str, int], loggers : Union[List
         warning  : 'WARNING'  or logging.WARNING
         info     : 'INFO'     or logging.INFO
         debug    : 'DEBUG'    or logging.DEBUG
+        None will disable logging
     loggers : list of LoggerAlias or 'all'
         Which loggers to save to the file, 'all' by default
     """
@@ -93,7 +93,7 @@ def set_log_stream(enabled : bool, level : Union[str, int], loggers : Union[List
             if isinstance(h, logging.StreamHandler):
                 logger.removeHandler(h)
         
-    if enabled:
+    if level is not None:
         # 2) Create the new stream handler
         stream_handler = logging.StreamHandler()
         stream_handler.setFormatter(default_formatter)

{syndesi-0.2.2 → syndesi-0.2.3/syndesi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: syndesi
-Version: 0.2.2
+Version: 0.2.3
 Summary: Syndesi
 Author: Sebastien Deriaz
 Author-email: sebastien.deriaz1@gmail.com

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi.egg-info/SOURCES.txt

@@ -20,6 +20,9 @@ syndesi/adapters/timeout.py
 syndesi/adapters/visa.py
 syndesi/api/__init__.py
 syndesi/api/api.py
+syndesi/cli/__init__.py
+syndesi/cli/shell.py
+syndesi/cli/syndesi.py
 syndesi/protocols/__init__.py
 syndesi/protocols/delimited.py
 syndesi/protocols/protocol.py
@@ -33,5 +36,4 @@ syndesi/tools/__init__.py
 syndesi/tools/exceptions.py
 syndesi/tools/log.py
 syndesi/tools/others.py
-syndesi/tools/shell.py
 syndesi/tools/types.py

{syndesi-0.2.2 → syndesi-0.2.3}/syndesi.egg-info/entry_points.txt

@@ -1,3 +1,3 @@
 [console_scripts]
-syndesi = syndesi.shell.syndesi:main
+syndesi = syndesi.cli.syndesi:main
 syndesi-proxy = syndesi.proxy.proxy:main