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

syndesi/adapters/backend/ip_backend.py

@@ -10,7 +10,13 @@ from typing import cast
 
 import _socket
 
-from ...tools.backend_api import AdapterBackendStatus, Fragment
+from syndesi.tools.errors import AdapterConfigurationError, AdapterFailedToOpen
+
+from ...tools.backend_api import (
+    DEFAULT_ADAPTER_OPEN_TIMEOUT,
+    AdapterBackendStatus,
+    Fragment,
+)
 from .adapter_backend import AdapterBackend, HasFileno
 from .descriptors import IPDescriptor
 
@@ -55,42 +61,37 @@ class IPBackend(AdapterBackend):
     def selectable(self) -> HasFileno | None:
         return self._socket
 
-    def open(self) -> bool:
-        output = False
-        if self._status == AdapterBackendStatus.DISCONNECTED:
-            if self.descriptor.port is None:  # TODO : Check if this is even possible
-                raise ValueError("Cannot open adapter without specifying a port")
-
-            if self._socket is None:
-                if self.descriptor.transport == IPDescriptor.Transport.TCP:
-                    self._socket = cast(
-                        _socket.socket,
-                        socket.socket(socket.AF_INET, socket.SOCK_STREAM),
-                    )
-                elif self.descriptor.transport == IPDescriptor.Transport.UDP:
-                    self._socket = cast(
-                        _socket.socket, socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-                    )
-                else:
-                    raise ValueError(
-                        f"Invalid transport protocol : {self.descriptor.transport}"
-                    )
-            try:
-                self._socket.settimeout(
-                    0.5
-                )  # TODO : Configure this cleanly, it has to be less than the receive timeout of the frontend
-                self._socket.connect((self.descriptor.address, self.descriptor.port))
-            except OSError as e:  # TODO : Maybe change the exception ?
-                self._logger.error(f"Failed to open adapter {self.descriptor} : {e}")
+    def open(self):
+        if self._status == AdapterBackendStatus.CONNECTED:
+            self._logger.warning(f"Adapter {self.descriptor} already openend")
+            return
+        
+        if self.descriptor.port is None:
+            raise AdapterConfigurationError("Cannot open adapter without specifying a port")
+
+        if self._socket is None:
+            if self.descriptor.transport == IPDescriptor.Transport.TCP:
+                self._socket = cast(
+                    _socket.socket,
+                    socket.socket(socket.AF_INET, socket.SOCK_STREAM),
+                )
+            elif self.descriptor.transport == IPDescriptor.Transport.UDP:
+                self._socket = cast(
+                    _socket.socket, socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+                )
             else:
-                self._status = AdapterBackendStatus.CONNECTED
-                self._logger.info(f"IP Adapter {self.descriptor} opened")
-                output = True
+                raise AdapterConfigurationError(
+                    f"Invalid transport protocol : {self.descriptor.transport}"
+                )
+        try:
+            self._socket.settimeout(DEFAULT_ADAPTER_OPEN_TIMEOUT)
+            self._socket.connect((self.descriptor.address, self.descriptor.port))
+        except OSError as e:
+            self._logger.error(f"Failed to open adapter {self.descriptor} : {e}")
+            raise AdapterFailedToOpen(str(e))
         else:
-            self._logger.info(f"Adapter {self.descriptor} already openend")
-            output = True
-
-        return output
+            self._status = AdapterBackendStatus.CONNECTED
+            self._logger.info(f"IP Adapter {self.descriptor} opened")
 
     def close(self) -> bool:
         super().close()
@@ -118,14 +119,16 @@ class IPBackend(AdapterBackend):
             self._logger.error(f"Cannot write to closed adapter {self.descriptor}")
             return False
         try:
-            self._socket.send(data)
-        except (BrokenPipeError, OSError) as e:
+            ok = self._socket.send(data) == len(data)
+        except (BrokenPipeError, OSError):
             # Socket has been disconnected by the remote peer
-            self._logger.error(f"Failed to write to adapter {self.descriptor} ({e})")
+            ok = False
+
+        if not ok:
+            self._logger.error(f"Failed to write to adapter {self.descriptor}")
             self.close()
-            return False
-        else:
-            return True
+
+        return ok
 
     def _socket_read(self) -> Fragment:
         # This function is called only if the socket was ready

syndesi/adapters/backend/serialport_backend.py

@@ -7,9 +7,10 @@
 import time
 
 import serial
-from serial.serialutil import PortNotOpenError
+from serial.serialutil import PortNotOpenError, SerialException
 
 from syndesi.tools.backend_api import AdapterBackendStatus, Fragment
+from syndesi.tools.errors import AdapterConfigurationError, AdapterFailedToOpen
 
 from .adapter_backend import AdapterBackend, HasFileno
 from .descriptors import SerialPortDescriptor
@@ -31,8 +32,6 @@ class SerialPortBackend(AdapterBackend):
         self._port: serial.Serial | None = None
         self._rts_cts = False
 
-        self.open()
-
     def set_baudrate(self, baudrate: int) -> None:
         """
         Set baudrate
@@ -72,27 +71,33 @@ class SerialPortBackend(AdapterBackend):
             self.close()
             self.open()
 
-    def open(self) -> bool:
+    def open(self) -> None:
         if self.descriptor.baudrate is None:
-            raise ValueError("Baudrate must be set, please use set_baudrate")
+            raise AdapterConfigurationError("Baudrate must be set, please use set_baudrate")
 
         if self._port is None:
-            self._port = serial.Serial(
-                port=self.descriptor.port,
-                baudrate=self.descriptor.baudrate,
-                rtscts=self._rts_cts,
-            )
+            try:
+                self._port = serial.Serial(
+                    port=self.descriptor.port,
+                    baudrate=self.descriptor.baudrate,
+                    rtscts=self._rts_cts,
+                )
+            except SerialException as e:
+                if 'No such file' in str(e):
+                    raise AdapterFailedToOpen(f"No such file or directory '{self.descriptor.port}'") from e
+                else:
+                    raise AdapterFailedToOpen('Unknown error') from e
+            
         elif not self._port.isOpen():  # type: ignore
             self._port.open()
 
         if self._port.isOpen():  # type: ignore
             self._logger.info(f"Adapter {self.descriptor} opened")
             self._status = AdapterBackendStatus.CONNECTED
-            return True
         else:
             self._logger.error(f"Failed to open adapter {self.descriptor}")
             self._status = AdapterBackendStatus.DISCONNECTED
-            return False
+            raise AdapterFailedToOpen('Unknown error')
 
     def close(self) -> bool:
         super().close()

syndesi/adapters/backend/stop_condition_backend.py

@@ -63,9 +63,12 @@ class StopConditionBackend:
 
 
 class TerminationBackend(StopConditionBackend):
-    def __init__(self, sequence: bytes) -> None:
+    def __init__(self, sequence: bytes | str) -> None:
         super().__init__()
-        self._sequence = sequence
+        if isinstance(sequence, str):
+            self._sequence = sequence.encode('utf-8')
+        else:
+            self._sequence = sequence
         self._sequence_found_length = 0
 
     def initiate_read(self) -> None:
@@ -210,10 +213,10 @@ def stop_condition_to_backend(stop_condition: StopCondition) -> StopConditionBac
     if isinstance(stop_condition, Termination):
         return TerminationBackend(stop_condition.sequence)
     elif isinstance(stop_condition, Length):
-        return LengthBackend(stop_condition.N)
+        return LengthBackend(stop_condition.n)
     elif isinstance(stop_condition, Continuation):
-        return ContinuationBackend(stop_condition.continuation)
+        return ContinuationBackend(stop_condition.time)
     elif isinstance(stop_condition, Total):
-        return TotalBackend(stop_condition.total)
+        return TotalBackend(stop_condition.time)
     else:
         raise RuntimeError(f"Invalid stop condition : {stop_condition}")

syndesi/adapters/backend/visa_backend.py

@@ -16,7 +16,7 @@ from typing import TYPE_CHECKING
 from ...tools.backend_api import AdapterBackendStatus, Fragment
 from .adapter_backend import (
     AdapterBackend,
-    AdapterDisconnected,
+    AdapterDisconnectedSignal,
     AdapterSignal,
     HasFileno,
 )
@@ -143,7 +143,7 @@ class VisaBackend(AdapterBackend):
         self._notify_recv.recv(1)
         if not self._event_queue.empty():
             event = self._event_queue.get()
-            if isinstance(event, AdapterDisconnected):
+            if isinstance(event, AdapterDisconnectedSignal):
                 return Fragment(b"", None)
 
         with self._fragment_lock:
@@ -181,7 +181,7 @@ class VisaBackend(AdapterBackend):
                     # Tell the session that there's data (write to a virtual socket)
                     self._notify_send.send(b"1")
             except (TypeError, pyvisa.InvalidSession, BrokenPipeError):
-                event_queue.put(AdapterDisconnected())
+                event_queue.put(AdapterDisconnectedSignal())
                 self._notify_send.send(b"1")
             with self._stop_lock:
                 if self.stop:

syndesi/adapters/ip.py

@@ -1,10 +1,10 @@
 # File : ip.py
 # Author : Sébastien Deriaz
 # License : GPL
-#
-# IP adapter, communicates with TCP or UDP
-
 
+"""
+IP adapter, communicates with TCP or UDP
+"""
 from collections.abc import Callable
 from types import EllipsisType
 
@@ -18,10 +18,33 @@ from .timeout import Timeout
 
 # TODO : Server ? create an adapter from a socket ?
 
-# TODO : Manage opening and closing, modes ? open at instance or at write/read ? close after read ? error if already opened before / strict mode ?
+# TODO : Manage opening and closing, modes ? open at instance or at write/read ?
+# close after read ? error if already opened before / strict mode ?
 
 
 class IP(Adapter):
+    """
+    IP Adapter, allows for communication with IP devices through UDP or TCP
+    
+    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
+    
+    
+    """
     DEFAULT_PROTOCOL = IPDescriptor.Transport.TCP
 
     def __init__(
@@ -29,6 +52,7 @@ class IP(Adapter):
         address: str,
         port: int | None = None,
         transport: str = DEFAULT_PROTOCOL.value,
+        *,
         timeout: Timeout | NumberLike | None | EllipsisType = ...,
         stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
         alias: str = "",
@@ -39,25 +63,7 @@ class IP(Adapter):
         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
-
+        Instanciate new IP adapter
         """
         super().__init__(
             descriptor=IPDescriptor(
@@ -107,4 +113,4 @@ class IP(Adapter):
         transport : str | IPDescriptor.Transport
         """
         if self.descriptor.transport is None:
-            self.descriptor.transport = IPDescriptor.Transport(transport)
+            self.descriptor.transport = IPDescriptor.Transport(transport)

syndesi/adapters/ip_server.py

@@ -91,12 +91,18 @@
 #         self._logger.info("Adapter closed !")
 #         self._opened = False
 
-#     def get_client(self, stop_condition : StopConditionBackend = None, timeout : Timeout = None) -> IP:
+#     def get_client(self,
+#           stop_condition : StopConditionBackend = 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))
+#         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/serialport.py

@@ -2,6 +2,12 @@
 # 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 types import EllipsisType
 
@@ -15,10 +21,21 @@ from .timeout import Timeout
 
 
 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 = "",
@@ -28,12 +45,7 @@ class SerialPort(Adapter):
         backend_port: int | None = None,
     ) -> None:
         """
-        Serial communication adapter
-
-        Parameters
-        ----------
-        port : str
-            Serial port (COMx or ttyACMx)
+        Instanciate new SerialPort adapter
         """
         descriptor = SerialPortDescriptor(port, baudrate)
         super().__init__(
@@ -48,7 +60,8 @@ class SerialPort(Adapter):
         self.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.open()

syndesi/adapters/stop_condition.py

@@ -2,89 +2,113 @@
 # Author : Sébastien Deriaz
 # License : GPL
 
-from abc import abstractmethod
+"""
+Stop-condition module
+
+This is the frontend of the stop-conditions, the part that is imported by the user
+"""
+
+#from abc import abstractmethod
 from enum import Enum
+from dataclasses import dataclass
+
 
 class StopConditionType(Enum):
+    """
+    Stop-condition type
+    """
     TERMINATION = "termination"
     LENGTH = "length"
     TIMEOUT = "timeout"
 
+@dataclass
 class StopCondition:
-    @abstractmethod
-    def type(self) -> StopConditionType:
-        pass
-
-    def __init__(self) -> None:
-        """
-        A condition to stop reading from a device
-
-        Cannot be used on its own
-        """
-
-
-class Termination(StopCondition):
-    def __init__(self, sequence: bytes | str) -> None:
-        """
-        Stop reading once the desired sequence is detected
-
-        Parameters
-        ----------
-        sequence : bytes
-        """
-        self.sequence: bytes
-        if isinstance(sequence, str):
-            self.sequence = sequence.encode("utf-8")
-        elif isinstance(sequence, bytes):
-            self.sequence = sequence
-        else:
-            raise ValueError(f"Invalid termination sequence type : {type(sequence)}")
+    """
+    Stop-condition base class, cannot be used on its own
+    """
+    # @abstractmethod
+    # def type(self) -> StopConditionType:
+    #     pass
 
     def __repr__(self) -> str:
         return self.__str__()
 
+@dataclass
+class Termination(StopCondition):
+    """
+    Termination stop-condition, used to stop when a specified sequence is received
+
+    Parameters
+    ----------
+    sequence : bytes | str
+    """
+    #TYPE = StopConditionType.TERMINATION
+    sequence : bytes | str
+    # def __init__(self, sequence: bytes | str) -> None:
+    #     """
+    #     Instanciate a new Termination class
+    #     """
+    #     self.sequence: bytes
+    #     if isinstance(sequence, str):
+    #         self.sequence = sequence.encode("utf-8")
+    #     elif isinstance(sequence, bytes):
+    #         self.sequence = sequence
+    #     else:
+    #         raise ValueError(f"Invalid termination sequence type : {type(sequence)}")
+
     def __str__(self) -> str:
         return f"Termination({repr(self.sequence)})"
 
-    def type(self) -> StopConditionType:
-        return StopConditionType.TERMINATION
-
 
+@dataclass
 class Length(StopCondition):
-    def __init__(self, N: int) -> None:
-        """
-        Stop condition when the desired number of bytes is reached or passed
-
-        Parameters
-        ----------
-        N : int
-            Number of bytes
-        """
-        self.N = N
-
-    def __repr__(self) -> str:
-        return self.__str__()
+    """
+    Length stop-condition, used to stop when the specified number of bytes (or more) have been read
+    
+    Parameters
+    ----------
+    N : int
+        Number of bytes
+    """
+    #TYPE = StopConditionType.LENGTH
+    n : int
 
     def __str__(self) -> str:
-        return f"Length({self.N})"
-
-    def type(self) -> StopConditionType:
-        return StopConditionType.LENGTH
+        return f"Length({self.n})"
 
+    # def type(self) -> StopConditionType:
+    #     return StopConditionType.LENGTH
 
+@dataclass
 class Continuation(StopCondition):
-    def __init__(self, time: float) -> None:
-        super().__init__()
-        self.continuation = time
+    """
+    Continuation stop-condition, used to stop reading when data has already been received
+    and nothing has been received since then for the specified amount of time
 
-    def type(self) -> StopConditionType:
-        return StopConditionType.TIMEOUT
+    Parameters
+    ----------
+    time : float
+    """
+    #TYPE = StopConditionType.TIMEOUT
+    time : float
 
 
-class Total(StopCondition):
-    def __init__(self, time: float) -> None:
-        super().__init__()
-        self.total = time
 
-    def type(self) -> StopConditionType:
-        return StopConditionType.TIMEOUT
+    # def type(self) -> StopConditionType:
+    #     return StopConditionType.TIMEOUT
+
+@dataclass
+class Total(StopCondition):
+    """
+    Total stop-condition, used to stop reading when data has already been received
+    and the total read time exceeds the specified amount
+    
+    """
+    #TYPE = StopConditionType.TIMEOUT
+    time : float
+    # def __init__(self, time: float) -> None:
+    #     super().__init__()
+    #     self.total = time
+
+    # def type(self) -> StopConditionType:
+    #     return StopConditionType.TIMEOUT

syndesi/adapters/timeout.py

@@ -8,6 +8,7 @@ from typing import Any, Protocol
 
 from ..tools.types import NumberLike, is_number
 
+
 class TimeoutAction(Enum):
     ERROR = "error"
     RETURN_EMPTY = "return_empty"

syndesi/adapters/visa.py

@@ -1,8 +1,10 @@
 # File : visa.py
 # Author : Sébastien Deriaz
 # License : GPL
-#
-# VISA adatper, uses a VISA backend like pyvisa-py or NI to communicate with instruments
+
+"""
+VISA adatper, uses a VISA backend like pyvisa-py or NI to communicate with instruments
+"""
 
 from collections.abc import Callable
 from types import EllipsisType
@@ -16,9 +18,15 @@ from .timeout import Timeout
 
 
 class Visa(Adapter):
+    """
+    VISA Adapter, allows for communication with VISA-compatible devices.
+    It uses pyvisa under the hood 
+    
+    """
     def __init__(
         self,
         descriptor: str,
+        *,
         alias: str = "",
         stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
         timeout: None | float | Timeout | EllipsisType = ...,
@@ -28,7 +36,7 @@ class Visa(Adapter):
         backend_port: int | None = None,
     ) -> None:
         super().__init__(
-            VisaDescriptor.from_string(descriptor),
+            descriptor=VisaDescriptor.from_string(descriptor),
             alias=alias,
             stop_conditions=stop_conditions,
             timeout=timeout,

syndesi/cli/console.py

@@ -225,4 +225,4 @@ class Shell:
     def ask(self, question: str, callback: Callable[[str], None]) -> None:
         self.ask_event.set()
         self.ask_callback = callback
-        self.reprompt(question)
+        self.reprompt(question)

syndesi/cli/shell.py

@@ -8,7 +8,7 @@ from enum import Enum
 
 from syndesi.adapters.adapter import Adapter
 from syndesi.adapters.backend.adapter_backend import (
-    AdapterDisconnected,
+    AdapterDisconnectedSignal,
     AdapterReadPayload,
     AdapterSignal,
 )
@@ -214,7 +214,7 @@ class AdapterShell:
         self._protocol.write(command)
 
     def event(self, signal: AdapterSignal) -> None:
-        if isinstance(signal, AdapterDisconnected):
+        if isinstance(signal, AdapterDisconnectedSignal):
 
             def f(answer: str) -> None:
                 if answer.lower() == "y":