syndesi 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

syndesi/adapters/ip.py

@@ -1,34 +1,79 @@
-
 import socket
 from enum import Enum
-from .iadapter import IAdapter
-from ..tools.types import assert_byte_instance
+from .adapter import Adapter
+from ..tools.types import to_bytes
+from .timeout import Timeout
+from threading import Thread
+from .timed_queue import TimedQueue
+from typing import Union
+from time import time
+import argparse
+from ..tools import shell
+
+class IP(Adapter):
+    DEFAULT_RESPONSE_TIMEOUT = 1
+    DEFAULT_CONTINUATION_TIMEOUT = 1e-3
+    DEFAULT_TOTAL_TIMEOUT = 5
+
 
-class IP(IAdapter):
-    class Status(Enum):
-        DISCONNECTED = 0
-        CONNECTED = 1
+    DEFAULT_TIMEOUT = Timeout(
+                        response=DEFAULT_RESPONSE_TIMEOUT,
+                        continuation=DEFAULT_CONTINUATION_TIMEOUT,
+                        total=DEFAULT_TOTAL_TIMEOUT)
+    DEFAULT_BUFFER_SIZE = 1024
     class Protocol(Enum):
-        TCP = 0
-        UDP = 1
-    def __init__(self, descriptor : str, port = None, transport : Protocol = Protocol.TCP):
+        TCP = 'TCP'
+        UDP = 'UDP'
+
+    def __init__(self,
+                address : str,
+                port : int = None,
+                transport : str = 'TCP',
+                timeout : Union[Timeout, float] = DEFAULT_TIMEOUT,
+                stop_condition = None,
+                alias : str = '',
+                buffer_size : int = DEFAULT_BUFFER_SIZE,
+                _socket : socket.socket = None):
         """
         IP stack adapter
 
         Parameters
         ----------
-        descriptor : str
+        address : str
             IP description
         port : int
-            port used (optional, can be specified in descriptor)
-        transport : Transport
-            Transport protocol, TCP or UDP
+            IP port
+        transport : str
+            'TCP' or 'UDP'
+        timeout : Timeout | float
+            Specify communication timeout
+        stop_condition : StopCondition
+            Specify a read stop condition (None by default)
+        alias : str
+            Specify an alias for this adapter, '' by default
+        buffer_size : int
+            Socket buffer size, may be removed in the future
+        socket : socket.socket
+            Specify a custom socket, this is reserved for server application
         """
-        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self._socket.settimeout(5)
-        self._ip = descriptor # TODO : update this
+        super().__init__(alias=alias, timeout=timeout, stop_condition=stop_condition)
+        self._transport = self.Protocol(transport)
+        self._is_server = _socket is not None
+
+        self._logger.info(f"Setting up {self._transport.value} IP adapter ({'server' if self._is_server else 'client'})")
+
+        if self._is_server:
+            # Server
+            self._socket = _socket
+            self._status = self.Status.CONNECTED
+        elif self._transport == self.Protocol.TCP:
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        elif self._transport == self.Protocol.UDP:
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        
+        self._address = address
         self._port = port
-        self._status = self.Status.DISCONNECTED
+        self._buffer_size = buffer_size
 
     def set_default_port(self, port):
         """
@@ -44,41 +89,62 @@ class IP(IAdapter):
         if self._port is None:
             self._port = port
 
-
-    def flushRead(self):
-        return super().flushRead()
-
     def open(self):
-        self._socket.connect((self._ip, self._port))
+        if self._is_server:
+            raise SystemError("Cannot open server socket. It must be passed already opened")
+        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._socket.connect((self._address, self._port))
         self._status = self.Status.CONNECTED
+        self._logger.info(f"Adapter {self._alias} opened !")
 
     def close(self):
-        self._socket.close()
+        if hasattr(self, '_socket'):
+            self._socket.close()
+        self._logger.info("Adapter closed !")
+        self._status = self.Status.DISCONNECTED
             
-    def write(self, data : bytes):
-        assert_byte_instance(data)
+    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.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)}")
 
-    def read(self):
-        if self._status == self.Status.DISCONNECTED:
-            self.open()
+    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()
 
-        self._socket.settimeout(10)
 
-        buffer = b''
-        while True:
+    def _read_thread(self, socket : socket.socket, read_queue : TimedQueue):
+        while True: # TODO : Add stop_pipe ? Maybe it was removed ?
             try:
-                recv = self._socket.recv(10)
-                self._socket.settimeout(0.05)
-                buffer += recv
-            except socket.timeout as e:
+                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
-        return buffer
+            # If payload is empty, it means the socket has been disconnected
+            if payload == b'':
+                read_queue.put(payload)
+                break
+            read_queue.put(payload)
 
-    def query(self, data : bytes):
+    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()
-        
+        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+    
+    

syndesi/adapters/ip_server.py

@@ -0,0 +1,108 @@
+# ip_server.py
+# Sébastien Deriaz
+# 31.05.2024
+
+import socket
+from enum import Enum
+from . import IP, StopCondition, Timeout
+from time import time
+from ..tools.types import to_bytes
+from .timeout import timeout_fuse
+import logging
+from ..tools.log import LoggerAlias
+
+# NOTE : The adapter is only meant to work with a single client, thus
+# a IPServer class is made to handle the socket and generate IP adapters
+
+class IPServer:
+    DEFAULT_BUFFER_SIZE = 1024
+    class Protocol(Enum):
+        TCP = 'TCP'
+        UDP = 'UDP'
+
+    def __init__(self,
+                port : int = None,
+                transport : str = 'TCP',
+                address : str = None,
+                max_clients : int = 5,
+                stop_condition = None,
+                alias : str = '',
+                buffer_size : int = DEFAULT_BUFFER_SIZE):
+
+        """
+        IP server adapter
+
+        Parameters
+        ----------
+        port : int
+            IP port. If None, the default port set with set_default_port will be used
+        transport : str
+            'TCP' or 'UDP'
+        address : str
+            Custom socket ip, None by default
+        max_clients : int
+            Maximum number of clients, 5 by default
+        stop_condition : StopCondition
+            Specify a read stop condition (None by default)
+        alias : str
+            Specify an alias for this adapter, '' by default
+        buffer_size : int
+            Socket buffer size, may be removed in the future
+        """
+        self._alias = alias
+        self._stop_condition = stop_condition
+        self._logger = logging.getLogger(LoggerAlias.ADAPTER.value)
+        self._transport = self.Protocol(transport)
+        if self._transport == self.Protocol.TCP:
+            self._logger.info("Setting up TCP IP server adapter")
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        elif self._transport == self.Protocol.UDP:
+            self._logger.info("Setting up UDP IP server adapter")
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        else:
+            raise ValueError("Invalid protocol")
+
+        self._address = socket.gethostname() if address is None else address
+        self._port = port
+        self._max_clients = max_clients
+        self._opened = False
+        
+
+    def set_default_port(self, port):
+        """
+        Sets IP port if no port has been set yet.
+
+        This way, the user can leave the port empty
+        and the driver/protocol can specify it later
+        
+        Parameters
+        ----------
+        port : int
+        """
+        if self._port is None:
+            self._port = port
+
+
+    def open(self):
+        if self._port is None:
+            raise ValueError(f"Cannot open adapter without specifying a port")
+        self._logger.info(f"Listening to incoming connections on {self._address}:{self._port}")
+        self._socket.bind((self._address, self._port))
+        self._socket.listen(self._max_clients)
+        self._opened = True
+
+    def close(self):
+        if hasattr(self, '_socket'):
+            self._socket.close()
+        self._logger.info("Adapter closed !")
+        self._opened = False
+
+    def get_client(self, stop_condition : StopCondition = None, timeout : Timeout = None) -> IP:
+        """
+        Wait for a client to connect to the server and return the corresponding adapter
+        """
+        if not self._opened:
+            raise RuntimeError("open() must be called before getting client")
+        client_socket, address = self._socket.accept()
+        default_timeout = Timeout(response=None, continuation=IP.DEFAULT_CONTINUATION_TIMEOUT, total=None)
+        return IP(_socket=client_socket, address=address, stop_condition=stop_condition, timeout=timeout_fuse(timeout, default_timeout))

syndesi/adapters/proxy.py

@@ -0,0 +1,92 @@
+# proxy.py
+# Sébastien Deriaz
+# 09.04.2024
+#
+# The proxy adapter allows for commands to be issued on a different device
+# The goal is to istanciate a class as such :
+#
+# Only adapter :
+#   # The proxy computer is accessed with 192.168.1.1 
+#   # The device (connected to the remote computer) is accessed with 192.168.2.1
+#   my_adapter = Proxy('192.168.1.1', IP('192.168.2.1'))
+#
+# Protocol :
+#   my_protocol = SCPI(Proxy('192.168.1.1', Serial('/dev/ttyUSB0')))
+#
+#
+# Driver :
+#   my_device = Driver(Proxy('192.168.1.1', VISA('...')))
+
+from enum import Enum
+from typing import Union
+
+from .adapter import Adapter
+from . import IP, SerialPort, VISA
+from ..proxy.proxy_api import *
+from ..api.api import parse
+
+DEFAULT_PORT = 2608
+
+class Proxy(Adapter):
+    def __init__(self, proxy_adapter : Adapter, remote_adapter : Adapter):
+        """
+        Proxy adapter
+
+        Parameters
+        ----------
+        proxy_adapter : Adapter
+            Adapter to connect to the proxy server
+        remote_adapter : Adapter
+            Adapter to instanciate onto the proxy server
+        """
+        super().__init__()
+
+        self._proxy = proxy_adapter
+        self._remote = remote_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())
+        elif isinstance(self._remote, SerialPort):
+            self._proxy.query()
+
+    def check(self, status : ReturnStatus):
+        if not status.success:
+            # There is an error
+            raise ProxyException(status.error_message)
+
+    def open(self):
+        if isinstance(self._remote, IP):
+            self._proxy.query(AdapterOpen().encode())
+
+    def close(self):
+        self._proxy.query(AdapterClose().encode())
+
+    def write(self, data : Union[bytes, str]):
+        self._proxy.query(AdapterWrite(data).encode())
+
+    def read(self, timeout=None, stop_condition=None, return_metrics : bool = False):
+        output : AdapterReadReturn
+        output = parse(self._proxy.query(AdapterRead().encode()))
+        if isinstance(output, AdapterReadReturn):
+            return output.data
+        elif isinstance(output, ReturnStatus):
+            raise ProxyException(output.error_message)
+        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())))
+        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+
+    def _start_thread(self):
+        pass

syndesi/adapters/remote.py

@@ -0,0 +1,18 @@
+# remote.py
+# Sébastien Deriaz
+# 09.04.2024
+#
+# The remote adapter allows for commands to be issued on a different device through TCP
+# The goal is to istanciate a class as such :
+#
+# Only adapter :
+#   # The remote computer is accessed with 192.168.1.1
+#   # The device (connected to the remote computer) is accessed with 192.168.2.1
+#   my_adapter = Remote('192.168.1.1', IP('192.168.2.1'))
+#
+# Protocol :
+#   my_protocol = SCPI(Remote('192.168.1.1', Serial('/dev/ttyUSB0')))
+#
+#
+# Driver :
+#   my_device = Driver(Remote('192.168.1.1', VISA('...')))

syndesi/adapters/serialport.py

@@ -0,0 +1,158 @@
+import os
+import serial
+from threading import Thread
+from typing import Union
+import select
+import argparse
+#from collections.abc import Sequence
+
+from .adapter import Adapter
+from ..tools.types import to_bytes
+from .stop_conditions import *
+from .timeout import Timeout
+from .timed_queue import TimedQueue
+from ..tools import shell
+from ..tools.others import DEFAULT
+
+# From pyserial - serialposix.py
+import fcntl
+import termios
+import struct
+if hasattr(termios, 'TIOCINQ'):
+    TIOCINQ = termios.TIOCINQ
+else:
+    TIOCINQ = getattr(termios, 'FIONREAD', 0x541B)
+TIOCM_zero_str = struct.pack('I', 0)
+
+DEFAULT_TIMEOUT = Timeout(response=1, continuation=200e-3, total=None)
+
+class SerialPort(Adapter):
+    def __init__(self,  
+                port : str,
+                baudrate : int,
+                timeout : Union[Timeout, float] = DEFAULT,
+                stop_condition : StopCondition = DEFAULT,
+                rts_cts : bool = False): # rts_cts experimental
+        """
+        Serial communication adapter
+
+        Parameters
+        ----------
+        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}")
+        self._port = serial.Serial(port=port, baudrate=baudrate)
+        if self._port.isOpen():
+            self._status = self.Status.CONNECTED
+        else:
+            self._status = self.Status.DISCONNECTED
+
+        self._rts_cts = rts_cts
+        
+        self._stop_event_pipe, self._stop_event_pipe_write = os.pipe()
+
+    def flushRead(self):
+        self._port.flush()
+
+    def open(self):
+        self._port.open()
+        # Flush the input buffer
+        buf = b'0'
+        while buf:
+            buf = os.read(self._port.fd)
+        self._logger.info("Adapter opened !")
+
+    def close(self):
+        if self._thread is not None and self._thread.is_alive():
+            os.write(self._stop_event_pipe_write, b'1')
+            self._thread.join()
+        if hasattr(self, '_port'):
+            self._port.close()
+        self._logger.info("Adapter closed !")
+            
+    def write(self, data : bytes):
+        if self._rts_cts: # Experimental
+            self._port.setRTS(True)
+        data = to_bytes(data)
+        if self._status == self.Status.DISCONNECTED:
+            self.open()
+        write_start = time()
+        self._port.write(data)
+        write_duration = time() - write_start
+        self._logger.debug(f"Written [{write_duration*1e3:.3f}ms]: {repr(data)}")
+
+    def _start_thread(self):
+        """
+        Start the read thread
+        """
+        self._logger.debug("Starting read thread...")
+        if self._thread is None or not self._thread.is_alive():
+            self._thread = Thread(target=self._read_thread, daemon=True, args=(self._port, self._read_queue, self._stop_event_pipe))
+            self._thread.start()
+
+    def _read_thread(self, port : serial.Serial , read_queue : TimedQueue, stop_event_pipe):
+        while True:
+            # It looks like using the raw implementation of port.in_waiting and port.read is better, there's no more warnings
+            # Equivalent of port.in_waiting :
+            #in_waiting = struct.unpack('I', fcntl.ioctl(port.fd, TIOCINQ, TIOCM_zero_str))[0]
+            in_waiting = self._port.in_waiting # This is a temporary fix to get windows compatiblity back, an error might pop up
+            if in_waiting == 0:
+                ready, _, _ = select.select([port.fd, stop_event_pipe], [], [], None)
+                if stop_event_pipe in ready:
+                    # Stop
+                    break
+            # Else, read as many bytes as possible
+            fragment = os.read(port.fd, 1000) # simplified version of port.read()
+            if fragment:
+                read_queue.put(fragment)        
+
+    def read(self, timeout=None, stop_condition=None, return_metrics: bool = False) -> bytes:
+        """
+        Read data from the device
+
+        Parameters
+        ----------
+        timeout : Timeout or None
+            Set a custom timeout, if None (default), the adapter timeout is used
+        stop_condition : StopCondition or None
+            Set a custom stop condition, if None (Default), the adapater stop condition is used
+        return_metrics : bool
+            Return a dictionary containing information about the read operation like
+                'read_duration' : float
+                'origin' : 'timeout' or 'stop_condition'
+                'timeout' : Timeout.TimeoutType
+                'stop_condition' : Length or Termination (StopCondition class)
+                'previous_read_buffer_used' : bool
+                'n_fragments' : int  
+        """
+        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))
+        }