syndesi 0.2.2__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: syndesi
-Version: 0.2.2
+Version: 0.2.4
 Summary: Syndesi
 Author: Sebastien Deriaz
 Author-email: sebastien.deriaz1@gmail.com
@@ -12,7 +12,6 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Description-Content-Type: text/markdown
-License-File: LICENSE
 
 # Syndesi Python Implementation
 
@@ -40,7 +39,7 @@ To instantiate a device, one must import the device and a suitable adapter
 
 ```python
 # 1) Import the device
-from syndesi.drivers.instruments.mutlimeters.siglent.SDM3055 import SDM3055
+from syndesi.drivers.instruments.multimeters.siglent.SDM3055 import SDM3055
 # 2) Import the adapter
 from syndesi.adapters import IP
 

{syndesi-0.2.2 → syndesi-0.2.4}/README.md

@@ -24,7 +24,7 @@ To instantiate a device, one must import the device and a suitable adapter
 
 ```python
 # 1) Import the device
-from syndesi.drivers.instruments.mutlimeters.siglent.SDM3055 import SDM3055
+from syndesi.drivers.instruments.multimeters.siglent.SDM3055 import SDM3055
 # 2) Import the adapter
 from syndesi.adapters import IP
 

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

@@ -1,15 +1,19 @@
 from setuptools import setup, find_packages
 
-VERSION = '0.2.2'
 DESCRIPTION = 'Syndesi'
 
+__version__ : str
+# Load __version__ from file
+with open('syndesi/version.py', 'r', encoding='utf-8') as f:
+    exec(f.read())
+
 with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 
 # Setting up
 setup(
     name="syndesi",
-    version=VERSION,
+    version=__version__,
     author="Sebastien Deriaz",
     author_email="sebastien.deriaz1@gmail.com",
     description=DESCRIPTION,
@@ -17,7 +21,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.4/syndesi/__init__.py

@@ -0,0 +1,4 @@
+from .tools.log import log_settings
+
+from .adapters import IP, SerialPort
+from .protocols import Modbus, Delimited, Raw, SCPI

{syndesi-0.2.2 → syndesi-0.2.4}/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,11 @@ 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_STOP_CONDITION = None
 
 
@@ -48,7 +46,7 @@ STOP_DESIGNATORS = {
         Termination : 'ST',
         Length : 'SL'
     },
-    'previous-read-buffer' : 'RB'
+    'previous-buffer' : 'PB'
 }
 
 class Origin(Enum):
@@ -72,7 +70,7 @@ class Adapter(ABC):
         DISCONNECTED = 0
         CONNECTED = 1
 
-    def __init__(self, alias : str = '', stop_condition : Union[StopCondition, None] = DEFAULT, timeout : Union[float, Timeout] = DEFAULT) -> None:
+    def __init__(self, alias : str = '', stop_condition : Union[StopCondition, None] = ..., timeout : Union[float, Timeout] = ...) -> None:
         """
         Adapter instance
 
@@ -81,37 +79,52 @@ 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
         """
         super().__init__()
+
         self._alias = alias
 
-        self._default_stop_condition = stop_condition == DEFAULT
+        self.is_default_timeout = timeout is Ellipsis
+        if self.is_default_timeout:
+            self._timeout = self._default_timeout()
+        else:
+            self._timeout = timeout_fuse(timeout, self._default_timeout())
+
+        self._default_stop_condition = stop_condition is Ellipsis
         if self._default_stop_condition:
             self._stop_condition = DEFAULT_STOP_CONDITION
         else:
             self._stop_condition = stop_condition
+
         self._read_queue = TimedQueue()
         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:
-            self._timeout = DEFAULT_TIMEOUT
-        else:
-            if is_number(timeout):
-                self._timeout = Timeout(response=timeout, continuation=100e-3)
-            elif isinstance(timeout, Timeout):
-                self._timeout = timeout
-            else:
-                raise ValueError(f"Invalid timeout type : {type(timeout)}")
+        if not isinstance(self._timeout, Timeout):
+            raise ValueError('Timeout must be defined to initialize an Adapter base class')
+
+    @abstractmethod
+    def _default_timeout(self):
+        pass
+
+    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]):
         """
@@ -121,10 +134,23 @@ class Adapter(ABC):
         ----------
         default_timeout : Timeout or tuple or float
         """
-        if self._default_timeout:
+        if self.is_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 +168,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 +187,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 +204,33 @@ class Adapter(ABC):
         data : bytes or str
         """
         pass
+
+    @abstractmethod
+    def read(self, timeout : Timeout = ..., stop_condition : StopCondition = ..., return_metrics : bool = False) -> bytes:
+        pass
     
-    # TODO : Return None or b'' when read thread is killed while reading
-    # This is to detect if a server socket has been closed
 
+    @abstractmethod
+    def _start_thread(self):
+        self._logger.debug("Starting read thread...")
+
+    def __del__(self):
+        self.close()
 
-    def read(self, timeout=None, stop_condition=None, return_metrics : bool = False) -> bytes:
+    def query(self, data : Union[bytes, str], timeout : Timeout = ..., stop_condition : StopCondition = ..., return_metrics : bool = False) -> bytes:
+        """
+        Shortcut function that combines
+        - flush_read
+        - write
+        - read
+        """
+        self.flushRead()
+        self.write(data)
+        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+    
+
+class StreamAdapter(Adapter):
+    def read(self, timeout=..., stop_condition=..., return_metrics : bool = False) -> bytes:
         """
         Read data from the device
 
@@ -189,35 +246,40 @@ class Adapter(ABC):
         if self._status == self.Status.DISCONNECTED:
             self.open()
 
-        # Use adapter values if no custom value is specified
-        if timeout is None:
+        # 29.08.24 Change timeout behavior
+        if timeout is ...:
+            # Use the class timeout
             timeout = self._timeout
-        elif isinstance(timeout, float):
-            timeout = Timeout(timeout)
-        
+        else:
+            # Fuse it
+            timeout = timeout_fuse(timeout, self._timeout)
         
-        if stop_condition is None:
+        if stop_condition is ...:
             stop_condition = self._stop_condition
 
         # If the adapter is closed, open it
         if self._status == self.Status.DISCONNECTED:
             self.open()
 
-        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 +293,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 +310,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 +329,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 +341,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}')
 
@@ -300,22 +362,4 @@ class Adapter(ABC):
                 total_time=timeout.total_time
             )
         else:
-            return output
-
-    @abstractmethod
-    def _start_thread(self):
-        pass
-
-    def __del__(self):
-        self.close()
-
-    @abstractmethod
-    def query(self, data : Union[bytes, str], timeout=None, stop_condition=None, return_metrics : bool = False) -> bytes:
-        """
-        Shortcut function that combines
-        - flush_read
-        - write
-        - read
-        """
-        pass
-    
+            return output

{syndesi-0.2.2 → syndesi-0.2.4}/syndesi/adapters/auto.py

@@ -17,7 +17,7 @@ from typing import Union
 import re
 from . import Adapter, IP, SerialPort
 
-IP_PATTERN = '([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(:[0-9]+)*'
+IP_PATTERN = '([0-9]+.[0-9]+.[0-9]+.[0-9]+)(:[0-9]+)*'
 
 WINDOWS_SERIAL_PATTERN = '(COM[0-9]+)(:[0-9]+)*'
 LINUX_SERIAL_PATTERN = '(/dev/tty[a-zA-Z0-9]+)(:[0-9]+)*'

{syndesi-0.2.2 → syndesi-0.2.4}/syndesi/adapters/ip.py

@@ -1,26 +1,19 @@
 import socket
 from enum import Enum
-from .adapter import Adapter
+from .adapter import StreamAdapter, 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
+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)
-    DEFAULT_BUFFER_SIZE = 1024
+class IP(StreamAdapter):
+    _DEFAULT_BUFFER_SIZE = 1024
     class Protocol(Enum):
         TCP = 'TCP'
         UDP = 'UDP'
@@ -29,10 +22,10 @@ class IP(Adapter):
                 address : str,
                 port : int = None,
                 transport : str = 'TCP',
-                timeout : Union[Timeout, float] = DEFAULT_TIMEOUT,
-                stop_condition = None,
+                timeout : Union[Timeout, float] = ...,
+                stop_condition : StopCondition = ...,
                 alias : str = '',
-                buffer_size : int = DEFAULT_BUFFER_SIZE,
+                buffer_size : int = _DEFAULT_BUFFER_SIZE,
                 _socket : socket.socket = None):
         """
         IP stack adapter
@@ -55,8 +48,9 @@ class IP(Adapter):
             Socket buffer size, may be removed in the future
         socket : socket.socket
             Specify a custom socket, this is reserved for server application
-        """
+        """        
         super().__init__(alias=alias, timeout=timeout, stop_condition=stop_condition)
+
         self._transport = self.Protocol(transport)
         self._is_server = _socket is not None
 
@@ -75,6 +69,21 @@ class IP(Adapter):
         self._port = port
         self._buffer_size = buffer_size
 
+    def __str__(self) -> str:
+        return f'IP({self._address}:{self._port})'
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def _default_timeout(self):
+        return Timeout(
+                response=5,
+                on_response='error',
+                continuation=100e-3,
+                on_continuation='return',
+                total=5,
+                on_total='error')
+
     def set_default_port(self, port):
         """
         Sets IP port if no port has been set yet.
@@ -95,12 +104,22 @@ class IP(Adapter):
         if self._port is None:
             raise ValueError(f"Cannot open adapter without specifying a port")
 
-        self._logger.debug(f"Adapter {self._alias} connect to ({self._address}, {self._port})")
+        self._logger.debug(f"Adapter {self._alias + ' ' if self._alias != '' else ''}connect to ({self._address}, {self._port})")
         self._socket.connect((self._address, self._port))
         self._status = self.Status.CONNECTED
+        if self._thread is None or not self._thread.is_alive():
+            self._start_thread()
+
         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 !")
@@ -109,42 +128,52 @@ class IP(Adapter):
     def write(self, data : Union[bytes, str]):
         data = to_bytes(data)
         if self._status == self.Status.DISCONNECTED:
-            self._logger.info(f"Adapter {self._alias} is closed, opening...")
+            self._logger.info(f"Adapter {self._alias + ' ' if self._alias != '' else ''}is closed, opening...")
             self.open()
         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()
-
-
-    def _read_thread(self, socket : socket.socket, read_queue : TimedQueue):
-        while True: # TODO : Add stop_pipe ? Maybe it was removed ?
+        super()._start_thread()
+        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()
+
+    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:
+            
             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:
             raise SystemError("Cannot query on server adapters")
-        self.flushRead()
-        self.write(data)
-        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+        return super().query(data=data, timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
     
     

{syndesi-0.2.2 → syndesi-0.2.4}/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())))