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

syndesi/__init__.py

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

syndesi/_version.py

@@ -0,0 +1 @@
+__version__ = '0.2.3'

syndesi/adapters/adapter.py

@@ -29,9 +29,7 @@ import socket
 import logging
 from time import time
 from dataclasses import dataclass
-from ..tools.others import DEFAULT
 
-DEFAULT_TIMEOUT = Timeout(response=5, continuation=200e-3, total=None)
 DEFAULT_STOP_CONDITION = None
 
 
@@ -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
 
@@ -86,13 +84,21 @@ class Adapter(ABC):
             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
@@ -103,16 +109,12 @@ class Adapter(ABC):
         # not used because of termination or length stop condition
         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):
         """
@@ -132,7 +134,7 @@ 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:
@@ -203,8 +205,32 @@ class Adapter(ABC):
         """
         pass
 
+    @abstractmethod
+    def read(self, timeout : Timeout = ..., stop_condition : StopCondition = ..., return_metrics : bool = False) -> bytes:
+        pass
+    
+
+    @abstractmethod
+    def _start_thread(self):
+        self._logger.debug("Starting read thread...")
+
+    def __del__(self):
+        self.close()
+
+    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)
+    
 
-    def read(self, timeout=DEFAULT, stop_condition=DEFAULT, return_metrics : bool = False) -> bytes:
+class StreamAdapter(Adapter):
+    def read(self, timeout=..., stop_condition=..., return_metrics : bool = False) -> bytes:
         """
         Read data from the device
 
@@ -220,22 +246,21 @@ class Adapter(ABC):
         if self._status == self.Status.DISCONNECTED:
             self.open()
 
-        # Use adapter values if no custom value is specified
-        if timeout == DEFAULT:
+        # 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 == DEFAULT:
+        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_buffer) > 0)
 
         if stop_condition is not None:
@@ -337,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/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/adapters/ip.py

@@ -1,6 +1,6 @@
 import socket
 from enum import Enum
-from .adapter import Adapter, AdapterDisconnected
+from .adapter import StreamAdapter, AdapterDisconnected
 from ..tools.types import to_bytes
 from .timeout import Timeout, timeout_fuse
 from .stop_conditions import StopCondition
@@ -10,18 +10,10 @@ from typing import Union
 from time import time
 import argparse
 #from ..cli import shell
-from ..tools.others import DEFAULT
 import select
 
-class IP(Adapter):
-    DEFAULT_TIMEOUT = Timeout(
-                        response=2,
-                        on_response='error',
-                        continuation=100e-3,
-                        on_continuation='return',
-                        total=5,
-                        on_total='error')
-    DEFAULT_BUFFER_SIZE = 1024
+class IP(StreamAdapter):
+    _DEFAULT_BUFFER_SIZE = 1024
     class Protocol(Enum):
         TCP = 'TCP'
         UDP = 'UDP'
@@ -30,10 +22,10 @@ class IP(Adapter):
                 address : str,
                 port : int = None,
                 transport : str = 'TCP',
-                timeout : Union[Timeout, float] = DEFAULT,
-                stop_condition : StopCondition = DEFAULT,
+                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
@@ -56,13 +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
-        """
-        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
 
@@ -81,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.
@@ -101,9 +104,12 @@ 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):
@@ -122,7 +128,7 @@ 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)
@@ -130,18 +136,14 @@ class IP(Adapter):
         self._logger.debug(f"Write [{write_duration*1e3:.3f}ms]: {repr(data)}")
 
     def _start_thread(self):
-        self._logger.debug("Starting read thread...")
+        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()
 
-    # # EXPERIMENTAL
-    # def read_thread_alive(self):
-    #     return self._thread.is_alive()
-
     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 ?
+        while True:
             
             try:
                 ready, _, _ = select.select([socket, stop], [], [])
@@ -172,8 +174,6 @@ class IP(Adapter):
     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/adapters/serialport.py

@@ -8,31 +8,19 @@ import socket
 import sys
 #from collections.abc import Sequence
 
-from .adapter import Adapter, AdapterDisconnected
+from .adapter import Adapter, StreamAdapter, AdapterDisconnected
 from ..tools.types import to_bytes
 from .stop_conditions import *
-from .timeout import Timeout
+from .timeout import Timeout, timeout_fuse
 from .timed_queue import TimedQueue
-#from ..cli import shell
-from ..tools.others import DEFAULT
 
-DEFAULT_TIMEOUT = Timeout(
-                    response=1,
-                    on_response='error',
-                    continuation=200e-3,
-                    on_continuation='return',
-                    total=None,
-                    on_total='error')
-
-
-
-
-class SerialPort(Adapter):
+class SerialPort(StreamAdapter):
     def __init__(self,  
                 port : str,
-                baudrate : int,
-                timeout : Union[Timeout, float] = DEFAULT,
-                stop_condition : StopCondition = DEFAULT,
+                baudrate : int = ...,
+                timeout : Union[Timeout, float] = ...,
+                stop_condition : StopCondition = ...,
+                alias : str = '',
                 rts_cts : bool = False): # rts_cts experimental
         """
         Serial communication adapter
@@ -41,32 +29,87 @@ class SerialPort(Adapter):
         ----------
         port : str
             Serial port (COMx or ttyACMx)
-        """
-        if timeout == DEFAULT:
-            timeout = DEFAULT_TIMEOUT
-            
-        super().__init__(timeout=timeout, stop_condition=stop_condition)
-        self._logger.info(f"Setting up SerialPort adapter timeout:{timeout}, stop_condition:{stop_condition}")
+        """            
+        super().__init__(timeout=timeout, stop_condition=stop_condition, alias=alias)
+
         self._port_name = port
+        self._baudrate_set = baudrate is not ...
         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._logger.info(f"Setting up SerialPort adapter on {self._port_name} with baudrate={baudrate}, timeout={timeout} and stop_condition={stop_condition}")
+        self._port = None
+
+        self.open()
+        
 
         self._rts_cts = rts_cts
 
+    def _default_timeout(self):
+        return Timeout(
+                    response=2,
+                    on_response='error',
+                    continuation=100e-3,
+                    on_continuation='return',
+                    total=None,
+                    on_total='error')
+
+    def __str__(self) -> str:
+        return f'Serial({self._port_name}:{self._baudrate})'
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def set_baudrate(self, baudrate):
+        """
+        Set baudrate
+
+        Parameters
+        ----------
+        baudrate : int
+        """
+        is_connected = self._status == self.Status.CONNECTED
+
+        if is_connected:
+            self.close()
+
+        self._baudrate = baudrate
+
+        if is_connected:
+            self.open()
+
+    def set_default_baudrate(self, baudrate):
+        """
+        Sets the default baudrate
+
+        Parameters
+        ----------
+        baudrate : int
+        """
+        if not self._baudrate_set:
+            self._baudrate = baudrate
+
     def flushRead(self):
         self._port.flush()
+        super().flushRead()
 
     def open(self):
-        self._port.open()
-        # Flush the input buffer
-        buf = b'0'
-        while buf:
-            buf = os.read(self._port.fd)
+        if self._baudrate is ...:
+            raise ValueError('Baudrate must be set, please use set_baudrate')
+
+        if self._port is None:
+            self._port = serial.Serial(port=self._port_name, baudrate=self._baudrate)
+        elif not self._port.isOpen():
+            self._port.open()
+        # # Flush the input buffer
+        self.flushRead()
+
+        if self._port.isOpen():
+            self._status = self.Status.CONNECTED
+        else:
+            self._status = self.Status.DISCONNECTED
+
         self._logger.info("Adapter opened !")
+        if self._thread is None or not self._thread.is_alive():
+            self._start_thread()
 
     def close(self):
         super().close()
@@ -96,7 +139,7 @@ class SerialPort(Adapter):
         """
         Start the read thread
         """
-        self._logger.debug("Starting read thread...")
+        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._port, self._read_queue, self._thread_stop_read))
             self._thread.start()
@@ -116,8 +159,8 @@ class SerialPort(Adapter):
                 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:
+                    fragment = port.read()
+                    if len(fragment) > 0:
                         read_queue.put(fragment)
             else:
                 ready, _, _ = select.select([self._port.fd, stop], [], [])
@@ -133,9 +176,9 @@ class SerialPort(Adapter):
                     else:
                         fragment = port.read(in_waiting)
                         if fragment:
-                            read_queue.put(fragment) 
+                            read_queue.put(fragment)
 
-    def read(self, timeout=DEFAULT, stop_condition=DEFAULT, return_metrics: bool = False) -> bytes:
+    def read(self, timeout=..., stop_condition=..., return_metrics: bool = False) -> bytes:
         """
         Read data from the device
 
@@ -157,26 +200,4 @@ class SerialPort(Adapter):
         output = super().read(timeout, stop_condition, return_metrics)
         if self._rts_cts: # Experimental
             self._port.setRTS(False)
-        return output
-
-    def query(self, data : Union[bytes, str], timeout=None, stop_condition=None, return_metrics : bool = False):
-        self.flushRead()
-        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))
-    #     }
+        return output

syndesi/adapters/stop_conditions.py

@@ -1,4 +1,4 @@
-from typing import Union, Tuple
+from typing import Union, Tuple, Callable
 from enum import Enum
 from time import time
 
@@ -140,6 +140,7 @@ class Termination(StopCondition):
     def __str__(self) -> str:
         return f'Termination({repr(self._termination)})'
 
+# TODO : Add a "allow_longer" parameter ? If more than N data is received, keep it instead of raising an error ?
 class Length(StopCondition):
     def __init__(self, N : int) -> None:
         """
@@ -164,10 +165,46 @@ class Length(StopCondition):
         deferred_fragment = data[remaining_bytes:]
         self._counter += len(kept_fragment)
         remaining_bytes = self._N - self._counter
+        # TODO : remaining_bytes <= 0 ? Alongside above TODO maybe
         return remaining_bytes == 0, kept_fragment, deferred_fragment
 
     def __repr__(self) -> str:
         return self.__str__()
         
     def __str__(self) -> str:
-        return f'Length({self._N})'
+        return f'Length({self._N})'
+
+
+
+# class Lambda(StopCondition):
+#     class LambdaReturn:
+#         ERROR = 'error' # Discard everything and raise an error
+#         VALID = 'valid' # Return everything
+#         KEEP_N = 'keep_n' # Keep the first N bytes
+#         CONTINUE = 'continue' # Keep reading
+
+#     def __init__(self, _lambda : Callable) -> None:
+#         super().__init__()
+#         self._lambda = _lambda
+
+#     def initiate_read(self) -> Union[float, None]:
+#         return None
+    
+#     def evaluate(self, fragment: bytes) -> Tuple[bool, Union[float, None]]:
+#         lambda_return, N = self._lambda(fragment)
+#         match lambda_return:
+#             case self.LambdaReturn.ERROR:
+#                 raise RuntimeError(f"Couldn't apply Lambda condition on fragment : {fragment}")
+#             case self.LambdaReturn.VALID:
+#                 return True, fragment, b''
+#             case self.LambdaReturn.KEEP_N:
+#                 return True, fragment[:N], fragment[N:]
+#             case self.LambdaReturn.CONTINUE:
+#                 return False, fragment, b'' # TODO : Check this
+
+#     def __repr__(self) -> str:
+#         return self.__str__()
+    
+#     def __str__(self) -> str:
+#         return f'Lambda(...)'
+