syndesi 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

syndesi/adapters/auto.py

@@ -1,37 +1,71 @@
 # File : auto.py
 # Author : Sébastien Deriaz
 # License : GPL
-#
-# Automatic adapter function
-# This function is used to automatically choose an adapter based on the user's input
-# 192.168.1.1 -> IP
-# COM4 -> Serial
-# /dev/tty* -> Serial
-# etc...
-# If an adapter class is supplied, it is passed through
-#
-# Additionnaly, it is possible to do COM4:115200 so as to make the life of the user easier
-# Same with /dev/ttyACM0:115200
 
+"""
+Automatic adapter function
+This function is used to automatically choose an adapter based on the user's input
+192.168.1.1 -> IP
+COM4 -> Serial
+/dev/tty* -> Serial
+etc...
+If an adapter class is supplied, it is passed through
+
+Additionnaly, it is possible to do COM4:115200 so as to make the life of the user easier
+Same with /dev/ttyACM0:115200
+"""
+
+
+import re
+
+from syndesi.component import Descriptor
 
 from .adapter import Adapter
-from .backend.descriptors import (
-    IPDescriptor,
+from .ip import IP, IPDescriptor
+from .serialport import SerialPort, SerialPortDescriptor
+from .visa import Visa, VisaDescriptor
+
+descriptors: list[type[Descriptor]] = [
     SerialPortDescriptor,
+    IPDescriptor,
     VisaDescriptor,
-    adapter_descriptor_by_string,
-)
-from .ip import IP
-from .serialport import SerialPort
-from .visa import Visa
+]
+
+
+def adapter_descriptor_by_string(string_descriptor: str) -> Descriptor:
+    """
+    Return a corresponding adapter descriptor from a string
+
+    Parameters
+    ----------
+    string_descriptor : str
+
+    Returns
+    -------
+    descriptor : Descriptor
+    """
+    for descriptor in descriptors:
+        if re.match(descriptor.DETECTION_PATTERN, string_descriptor):
+            x = descriptor.from_string(string_descriptor)
+            return x
+    raise ValueError(f"Could not parse descriptor string : {string_descriptor}")
 
 
 def auto_adapter(adapter_or_string: Adapter | str) -> Adapter:
+    """
+    Create an adapter from a string or an adapter
+
+    - <int>.<int>.<int>.<int>[:<int>] -> IP
+    - x.y[:<int>] -> IP
+    - COM<int> -> SerialPort
+    - /dev/tty[ACM|USB]<int> -> SerialPort
+
+    """
     if isinstance(adapter_or_string, Adapter):
         # Simply return it
         return adapter_or_string
 
-    elif isinstance(adapter_or_string, str):
+    if isinstance(adapter_or_string, str):
         descriptor = adapter_descriptor_by_string(adapter_or_string)
         if isinstance(descriptor, IPDescriptor):
             return IP(
@@ -39,12 +73,11 @@ def auto_adapter(adapter_or_string: Adapter | str) -> Adapter:
                 port=descriptor.port,
                 transport=descriptor.transport.value,
             )
-        elif isinstance(descriptor, SerialPortDescriptor):
+        if isinstance(descriptor, SerialPortDescriptor):
             return SerialPort(port=descriptor.port, baudrate=descriptor.baudrate)
-        elif isinstance(descriptor, VisaDescriptor):
+        if isinstance(descriptor, VisaDescriptor):
             return Visa(descriptor=descriptor.descriptor)
-        else:
-            raise RuntimeError(f"Invalid descriptor : {descriptor}")
 
-    else:
-        raise ValueError(f"Invalid adapter : {adapter_or_string}")
+        raise RuntimeError(f"Invalid descriptor : {descriptor}")
+
+    raise ValueError(f"Invalid adapter : {adapter_or_string}")

syndesi/adapters/descriptors.py

@@ -0,0 +1,38 @@
+# # File : descriptors.py
+# # Author : Sébastien Deriaz
+# # License : GPL
+# """
+# Descriptors are classes that describe how an adapter is connected to its device.
+# Depending on the protocol, they can hold strings, integers or enums
+# """
+
+# import re
+# from abc import abstractmethod
+# from dataclasses import dataclass
+# from enum import Enum
+
+
+# descriptors: list[type[Descriptor]] = [
+#     SerialPortDescriptor,
+#     IPDescriptor,
+#     VisaDescriptor,
+# ]
+
+
+# def adapter_descriptor_by_string(string_descriptor: str) -> Descriptor:
+#     """
+#     Return a corresponding adapter descriptor from a string
+
+#     Parameters
+#     ----------
+#     string_descriptor : str
+
+#     Returns
+#     -------
+#     descriptor : Descriptor
+#     """
+#     for descriptor in descriptors:
+#         if re.match(descriptor.DETECTION_PATTERN, string_descriptor):
+#             x = descriptor.from_string(string_descriptor)
+#             return x
+#     raise ValueError(f"Could not parse descriptor string : {string_descriptor}")

syndesi/adapters/ip.py

@@ -1,110 +1,242 @@
 # File : ip.py
 # Author : Sébastien Deriaz
 # License : GPL
-#
-# IP adapter, communicates with TCP or UDP
-
+"""
+IP Adapter, used to communicate with IP targets using the socket module
+"""
 
+import socket
 from collections.abc import Callable
+from dataclasses import dataclass
+from enum import StrEnum
 from types import EllipsisType
+from typing import cast
+
+import _socket
 
-from syndesi.adapters.backend.adapter_backend import AdapterSignal
-from syndesi.tools.types import NumberLike
+from syndesi.adapters.adapter_worker import AdapterEvent, HasFileno
+from syndesi.adapters.stop_conditions import Continuation, StopCondition
+from syndesi.adapters.timeout import Timeout
+from syndesi.component import Descriptor
+from syndesi.tools.errors import AdapterOpenError, AdapterWriteError
 
 from .adapter import Adapter
-from .backend.descriptors import IPDescriptor
-from .stop_condition import StopCondition
-from .timeout import Timeout
+from .stop_conditions import Fragment
+
+
+@dataclass
+class IPDescriptor(Descriptor):
+    """
+    IP descriptor that holds ip address and port
+    """
 
-# TODO : Server ? create an adapter from a socket ?
+    class Transport(StrEnum):
+        """
+        IP Transport protocol
+        """
+
+        TCP = "TCP"
+        UDP = "UDP"
+
+        @classmethod
+        def from_str(cls, transport: str) -> "IPDescriptor":
+            """
+            Create a Transport class from a string
+
+            Parameters
+            ----------
+            transport : str
+            """
+            for member in cls:
+                if member.value.lower() == transport.lower():
+                    return member  # type: ignore # TODO : Check this
+            raise ValueError(f"{transport} is not a valid {cls.__name__}")
+
+    DETECTION_PATTERN = r"(\d+.\d+.\d+.\d+|[\w\.]+):\d+:(UDP|TCP)"
+    address: str
+    transport: Transport
+    port: int | None = None
+
+    @staticmethod
+    def from_string(string: str) -> "IPDescriptor":
+        parts = string.split(":")
+        address = parts[0]
+        port = int(parts[1])
+        transport = IPDescriptor.Transport(parts[2])
+        return IPDescriptor(address, transport, port)
+
+    def __str__(self) -> str:
+        return f"{self.address}:{self.port}:{self.Transport(self.transport).value}"
+
+    def is_initialized(self) -> bool:
+        """
+        Return True if all attributes has been defined (not None)
+        """
 
-# TODO : Manage opening and closing, modes ? open at instance or at write/read ? close after read ? error if already opened before / strict mode ?
+        return self.port is not None and self.transport is not None
 
 
 class IP(Adapter):
-    DEFAULT_PROTOCOL = IPDescriptor.Transport.TCP
+    """
+    IP stack adapter. The IP Adapter reads and writes bytes units (frames)
+
+    Parameters
+    ----------
+    address : str
+        IP address
+    port : int or None, default : None
+        IP port
+    transport : {'TCP', 'UDP'}
+        Transport layer
+    timeout : Timeout or float
+        Specify communication timeout, the time it takes for the target to respond
+    stop_conditions : list[StopCondition] or StopCondition
+        Stop coniditions are used to decide when a read data block is finished
+        and should be returned
+
+        These include
+
+        * Termination : stop on a specific sequence like ``\\n`` at the end of the data
+        * Length : stop when a specific number of bytes has been received
+        * Continuation : stop when no data has been received for a
+        specified amount of time
+        * Total : stop if the time since the first piece of data received exceeds
+        a given amount of time
+        * FragmentStopCondition : Return each piece of data individually as received
+        by the low-level communication layer
+
+        Multiple stop conditions can be used to create more complex behaviours
+    encoding : str
+        Used to convert str to bytes if the user chooses to send
+    alias : str
+        Name of the adapter, may be removed in the future
+    event_callback : f(event : AdapterEvent)
+        Function called when an event is received by the adapter worker thread.
+        The event can be either one of :
+
+        * ``AdapterDisconnectedEvent``
+        * ``AdapterFrameEvent``
+        * ``FirstFragmentEvent``
+    auto_open : bool, default to True
+        Automatically open the adapter after instanciation
+    """
+
+    BUFFER_SIZE = 65507
 
     def __init__(
         self,
         address: str,
         port: int | None = None,
-        transport: str = DEFAULT_PROTOCOL.value,
-        timeout: Timeout | NumberLike | None | EllipsisType = ...,
-        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
-        alias: str = "",
+        transport: str = IPDescriptor.Transport.TCP.value,
+        *,
+        timeout: Timeout | float | EllipsisType = ...,
+        stop_conditions: list[StopCondition] | StopCondition | EllipsisType = ...,
         encoding: str = "utf-8",
-        event_callback: Callable[[AdapterSignal], None] | None = None,
+        alias: str = "",
+        event_callback: Callable[[AdapterEvent], None] | None = None,
         auto_open: bool = True,
-        backend_address: str | None = None,
-        backend_port: int | None = None,
     ):
-        """
-        IP adapter
 
-        Parameters
-        ----------
-        address : str
-            IP description
-        port : int
-            IP port
-        transport : str
-            'TCP' or 'UDP'
-        timeout : Timeout | float
-            Specify communication timeout
-        stop_condition : StopCondition
-            Specify a read stop condition (None by default)
-        auto_open : bool
-            Automatically open the adapter
-        socket : socket.socket
-            Specify a custom socket, this is reserved for server application
+        descriptor = IPDescriptor(
+            address=address,
+            port=port,
+            transport=IPDescriptor.Transport(transport.upper()),
+        )
+        self._socket: _socket.socket | None = None
 
-        """
         super().__init__(
-            descriptor=IPDescriptor(
-                address=address,
-                port=port,
-                transport=IPDescriptor.Transport(transport.upper()),
-            ),
-            alias=alias,
-            timeout=timeout,
+            descriptor=descriptor,
             stop_conditions=stop_conditions,
+            timeout=timeout,
             encoding=encoding,
+            alias=alias,
             event_callback=event_callback,
             auto_open=auto_open,
-            backend_address=backend_address,
-            backend_port=backend_port,
         )
-        self.descriptor: IPDescriptor
-
-        # if self.descriptor.transport is not None:
-        self._logger.info(f"Setting up {self.descriptor.transport.value} IP adapter")
-
-        self.set_default_timeout(self._default_timeout())
-
-    def _default_timeout(self) -> Timeout:
-        return Timeout(response=5, action="error")
+        self._descriptor: IPDescriptor
+        self._worker_descriptor: IPDescriptor
 
     def set_default_port(self, port: int) -> None:
         """
-        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
+        Set the default port number
 
         Parameters
         ----------
         port : int
         """
-        if self.descriptor.port is None:
-            self.descriptor.port = port
-
-    def set_default_transport(self, transport: str | IPDescriptor.Transport) -> None:
-        """
-        Sets the default IP transport protocol
+        if self._descriptor.port is None:
+            self._descriptor.port = port
+            self._update_descriptor()
+
+    def _worker_read(self, fragment_timestamp: float) -> Fragment:
+        if self._socket is None:
+            return Fragment(b"", fragment_timestamp)
+
+        try:
+            data = self._socket.recv(self.BUFFER_SIZE)
+        except (ConnectionRefusedError, OSError):
+            fragment = Fragment(b"", fragment_timestamp)
+        else:
+            if data == b"":
+                self._logger.warning("Socket disconnected")
+                self._worker_close()
+            fragment = Fragment(data, fragment_timestamp)
+        return fragment
+
+    def _worker_write(self, data: bytes) -> None:
+        super()._worker_write(data)
+
+        if self._socket is not None:
+            if self._socket.send(data) != len(data):
+                raise AdapterWriteError(
+                    f"Adapter {self._worker_descriptor} couldn't write"
+                    " all of the data to the socket"
+                )
+
+    def _worker_open(self) -> None:
+        self._worker_check_descriptor()
+
+        # Create the socket instance
+        if self._worker_descriptor.transport == IPDescriptor.Transport.TCP:
+            self._socket = cast(
+                _socket.socket,
+                socket.socket(socket.AF_INET, socket.SOCK_STREAM),
+            )
+        elif self._worker_descriptor.transport == IPDescriptor.Transport.UDP:
+            self._socket = cast(
+                _socket.socket, socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            )
+        else:
+            raise AdapterOpenError("Invalid transport protocol")
+
+        try:
+            self._socket.settimeout(self.WorkerTimeout.OPEN.value)
+            self._socket.connect(
+                (self._worker_descriptor.address, self._worker_descriptor.port)
+            )
+        except (OSError, ConnectionRefusedError, socket.gaierror) as e:
+            self._opened = False
+            msg = f"Failed to open adapter {self._worker_descriptor} : {e}"
+            self._logger.error(msg)
+            raise AdapterOpenError(msg) from None
+
+        self._opened = True
+        self._logger.info(f"IP Adapter {self._worker_descriptor} opened")
+
+    def _worker_close(self) -> None:
+        if self._socket is not None:
+            try:
+                self._socket.shutdown(_socket.SHUT_RDWR)
+                self._socket.close()
+            except OSError:
+                pass
+            self._socket = None
+
+    def _selectable(self) -> HasFileno | None:
+        return self._socket
+
+    def _default_stop_conditions(self) -> list[StopCondition]:
+        return [Continuation(continuation=0.2)]
 
-        Parameters
-        ----------
-        transport : str | IPDescriptor.Transport
-        """
-        if self.descriptor.transport is None:
-            self.descriptor.transport = IPDescriptor.Transport(transport)
+    def _default_timeout(self) -> Timeout:
+        return Timeout(response=1, action="error")

syndesi/adapters/serialport.py

@@ -2,38 +2,93 @@
 # Author : Sébastien Deriaz
 # License : GPL
 
+"""
+SerialPort module, allows communication with serial devices using
+the OS layers (COMx, /dev/ttyUSBx or /dev/ttyACMx)
+
+"""
+
 from collections.abc import Callable
+from dataclasses import dataclass
 from types import EllipsisType
 
-from syndesi.adapters.backend.adapter_backend import AdapterSignal
+import serial
+from serial.serialutil import PortNotOpenError
+
+from syndesi.adapters.adapter_worker import AdapterEvent, HasFileno
+from syndesi.component import Descriptor
+from syndesi.tools.errors import AdapterOpenError, AdapterReadError
 from syndesi.tools.types import NumberLike
 
 from .adapter import Adapter
-from .backend.descriptors import SerialPortDescriptor
-from .stop_condition import StopCondition
+from .stop_conditions import Continuation, Fragment, StopCondition
 from .timeout import Timeout
 
 
+@dataclass
+class SerialPortDescriptor(Descriptor):
+    """
+    SerialPort descriptor that holds location (COMx or /dev/ttyx) and baudrate
+    """
+
+    DETECTION_PATTERN = r"(COM\d+|/dev[/\w\d]+):\d+"
+    port: str
+    baudrate: int | None = None
+
+    @staticmethod
+    def from_string(string: str) -> "SerialPortDescriptor":
+        parts = string.split(":")
+        port = parts[0]
+        baudrate = int(parts[1])
+        return SerialPortDescriptor(port, baudrate)
+
+    def set_default_baudrate(self, baudrate: int) -> bool:
+        """
+        Set the baudrate if it has not be defined before
+
+        Parameters
+        ----------
+        baudrate : int
+        """
+        if self.baudrate is not None:
+            self.baudrate = baudrate
+            return True
+
+        return False
+
+    def __str__(self) -> str:
+        return f"{self.port}:{self.baudrate}"
+
+    def is_initialized(self) -> bool:
+        return self.baudrate is not None
+
+
 class SerialPort(Adapter):
+    """
+    Serial communication adapter
+
+    Parameters
+    ----------
+    port : str
+        Serial port (COMx or ttyACMx)
+    baudrate : int
+        Baudrate
+    """
+
     def __init__(
         self,
         port: str,
         baudrate: int | None = None,
+        *,
         timeout: Timeout | NumberLike | None | EllipsisType = ...,
         stop_conditions: StopCondition | list[StopCondition] | EllipsisType = ...,
         alias: str = "",
         rts_cts: bool = False,  # rts_cts experimental
-        event_callback: Callable[[AdapterSignal], None] | None = None,
-        backend_address: str | None = None,
-        backend_port: int | None = None,
+        event_callback: Callable[[AdapterEvent], None] | None = None,
+        auto_open: bool = True,
     ) -> None:
         """
-        Serial communication adapter
-
-        Parameters
-        ----------
-        port : str
-            Serial port (COMx or ttyACMx)
+        Instanciate new SerialPort adapter
         """
         descriptor = SerialPortDescriptor(port, baudrate)
         super().__init__(
@@ -42,15 +97,18 @@ class SerialPort(Adapter):
             stop_conditions=stop_conditions,
             alias=alias,
             event_callback=event_callback,
-            backend_address=backend_address,
-            backend_port=backend_port,
+            auto_open=auto_open,
         )
-        self.descriptor: SerialPortDescriptor
+        self._descriptor: SerialPortDescriptor
+        self._worker_descriptor: SerialPortDescriptor
 
         self._logger.info(
-            f"Setting up SerialPort adapter {self.descriptor}, timeout={timeout} and stop_conditions={self._stop_conditions}"
+            f"Setting up SerialPort adapter {self._descriptor}, \
+                timeout={timeout} and stop_conditions={self._stop_conditions}"
         )
 
+        self._port: serial.Serial | None = None
+
         self.open()
 
         self._rts_cts = rts_cts
@@ -58,7 +116,50 @@ class SerialPort(Adapter):
     def _default_timeout(self) -> Timeout:
         return Timeout(response=2, action="error")
 
-    def set_baudrate(self, baudrate: int) -> None:
+    def _default_stop_conditions(self) -> list[StopCondition]:
+        return [Continuation(0.1)]
+
+    def _worker_open(self) -> None:
+        self._worker_check_descriptor()
+
+        if self._worker_descriptor.baudrate is None:
+            raise AdapterOpenError(
+                "Descriptor must be fully initialized to open the adapter"
+            )
+
+        if self._port is not None:
+            self.close()
+
+        try:
+            self._port = serial.Serial(
+                port=self._worker_descriptor.port,
+                baudrate=self._worker_descriptor.baudrate,
+                rtscts=self._rts_cts,
+            )
+        except serial.SerialException as e:
+            if "No such file" in str(e):
+                raise AdapterOpenError(
+                    f"Port '{self._worker_descriptor.port}' was not found"
+                ) from e
+            raise AdapterOpenError("Unknown error") from e
+
+        if self._port.isOpen():  # type: ignore
+            self._logger.info(f"Adapter {self._worker_descriptor} opened")
+        else:
+            self._logger.error(f"Failed to open adapter {self._worker_descriptor}")
+            raise AdapterOpenError("Unknown error")
+
+    def _worker_close(self) -> None:
+        if self._port is not None:
+            self._port.close()
+            self._logger.info(f"Adapter {self._worker_descriptor} closed")
+
+    async def aflush_read(self) -> None:
+        await super().aflush_read()
+        if self._port is not None:
+            self._port.flush()
+
+    def set_default_baudrate(self, baudrate: int) -> None:
         """
         Set baudrate
 
@@ -66,15 +167,43 @@ class SerialPort(Adapter):
         ----------
         baudrate : int
         """
-        if self.descriptor.set_default_baudrate(baudrate):
+        if self._descriptor.set_default_baudrate(baudrate):
+            self._update_descriptor()
             self.close()
             self.open()
 
-    def open(self) -> None:
-        if self.descriptor.baudrate is None:
-            raise ValueError("Baudrate must be set, please use set_baudrate")
-        super().open()
+    def _worker_write(self, data: bytes) -> None:
+        if self._rts_cts:  # Experimental
+            self._port.setRTS(True)  # type: ignore
+        if self._port is not None:
+            try:
+                self._port.write(data)
+            except (OSError, PortNotOpenError):
+                pass
+
+    def _worker_read(self, fragment_timestamp: float) -> Fragment:
+        if self._port is None:
+            raise AdapterReadError("Cannot read from non-initialized port")
+
+        try:
+            data = self._port.read_all()
+        except (OSError, PortNotOpenError):
+            self._logger.debug('Port error -> b""')
+            data = None
+
+        if data is None or data != b"":
+            raise AdapterReadError(
+                f"Error while reading from {self._worker_descriptor}"
+            )
+
+        return Fragment(data, fragment_timestamp)
+
+    def _selectable(self) -> HasFileno | None:
+        return self._port
+
+    # def is_opened(self) -> bool:
+    #     if self._port is not None:
+    #         if self._port.isOpen():  # type: ignore
+    #             return True
 
-    def close(self, force: bool = False) -> None:
-        super().close(force)
-        self._logger.info("Adapter closed")
+    #     return False