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

syndesi/adapters/backend/adapter_backend.py

@@ -7,19 +7,18 @@
 
 import logging
 import socket
+import time
 from abc import ABC, abstractmethod
 from collections.abc import Generator
 from dataclasses import dataclass
 from enum import Enum
 from multiprocessing.connection import Connection
 from threading import Thread
-import time
-from typing import Protocol, cast
-
-from syndesi.tools.types import NumberLike
+from typing import Protocol
 
 from ...tools.backend_api import AdapterBackendStatus, Fragment
 from ...tools.log_settings import LoggerAlias
+from ..stop_condition import StopConditionType
 from .descriptors import Descriptor
 from .stop_condition_backend import (
     ContinuationBackend,
@@ -27,8 +26,6 @@ from .stop_condition_backend import (
     TotalBackend,
 )
 
-from ..stop_condition import Continuation, StopConditionType
-
 
 class HasFileno(Protocol):
     def fileno(self) -> int:
@@ -64,7 +61,7 @@ class AdapterSignal:
     pass
 
 
-class AdapterDisconnected(AdapterSignal):
+class AdapterDisconnectedSignal(AdapterSignal):
     def __str__(self) -> str:
         return "Adapter disconnected"
 
@@ -82,12 +79,13 @@ class AdapterDisconnected(AdapterSignal):
 #     def __repr__(self) -> str:
 #         return self.__str__()
 
+
 @dataclass
 class AdapterResponseTimeout(AdapterSignal):
-    identifier : int
+    identifier: int
 
     def __str__(self) -> str:
-        return f"Response timeout"
+        return "Response timeout"
 
     def __repr__(self) -> str:
         return self.__str__()
@@ -99,9 +97,9 @@ class AdapterReadPayload(AdapterSignal):
     stop_timestamp: float
     stop_condition_type: StopConditionType
     previous_read_buffer_used: bool
-    response_timestamp : float | None
+    response_timestamp: float | None
     # Only used by client and set by frontend
-    response_delay : float | None = None
+    response_delay: float | None = None
 
     def data(self) -> bytes:
         return b"".join([f.data for f in self.fragments])
@@ -118,9 +116,10 @@ class AdapterReadPayload(AdapterSignal):
 @dataclass
 class ResponseRequest:
     timestamp: float
-    identifier : int
+    identifier: int
+
 
-def nmin(a : float | None, b : float | None) -> float | None:
+def nmin(a: float | None, b: float | None) -> float | None:
     if a is None and b is None:
         return None
     elif a is None:
@@ -130,6 +129,7 @@ def nmin(a : float | None, b : float | None) -> float | None:
     else:
         return min(a, b)
 
+
 class AdapterBackend(ABC):
     class ThreadCommands(Enum):
         STOP = b"0"
@@ -168,7 +168,7 @@ class AdapterBackend(ABC):
         # None : No ask
         # float : Ask for a response to happen at the specified value at max
         self._response_request: ResponseRequest | None = None
-        self._response_request_start : float | None = None
+        self._response_request_start: float | None = None
 
         self._first_fragment = True
 
@@ -211,7 +211,7 @@ class AdapterBackend(ABC):
         return self._previous_buffer.data == b""
 
     @abstractmethod
-    def open(self) -> bool:
+    def open(self) -> None:
         """
         Start communication with the device
         """
@@ -246,10 +246,10 @@ class AdapterBackend(ABC):
     @abstractmethod
     def _socket_read(self) -> Fragment:
         raise NotImplementedError
-    
-    def _fragments_to_string(self, fragments : list[Fragment]) -> str:
+
+    def _fragments_to_string(self, fragments: list[Fragment]) -> str:
         if len(fragments) > 0:
-            return '+'.join(repr(f.data) for f in fragments)
+            return "+".join(repr(f.data) for f in fragments)
         else:
             return str([])
 
@@ -261,9 +261,12 @@ class AdapterBackend(ABC):
             fragment_delta_t = float("nan")
         if fragment.data == b"":
             self.close()
-            yield AdapterDisconnected()
+            yield AdapterDisconnectedSignal()
         else:
-            self._logger.debug(f"New fragment {fragment_delta_t:+.3f} {fragment}" + (" (first)" if self._first_fragment else ""))
+            self._logger.debug(
+                f"New fragment {fragment_delta_t:+.3f} {fragment}"
+                + (" (first)" if self._first_fragment else "")
+            )
             if self._status == AdapterBackendStatus.CONNECTED:
                 t = time.time()
 
@@ -272,7 +275,9 @@ class AdapterBackend(ABC):
 
                 if self._response_request is not None:
                     for stop_condition in self._stop_conditions:
-                        if isinstance(stop_condition, (ContinuationBackend, TotalBackend)):
+                        if isinstance(
+                            stop_condition, (ContinuationBackend, TotalBackend)
+                        ):
                             self._response_request = None
                             break
 
@@ -287,15 +292,18 @@ class AdapterBackend(ABC):
                     kept = fragment
 
                     # Run each stop condition one after the other, if a stop is reached, stop evaluating
-                    stop_condition_type : StopConditionType
+                    stop_condition_type: StopConditionType
                     for stop_condition in self._stop_conditions:
-                        stop, kept, self._previous_buffer, self._next_timeout_timestamp = \
-                            stop_condition.evaluate(kept)
+                        (
+                            stop,
+                            kept,
+                            self._previous_buffer,
+                            self._next_timeout_timestamp,
+                        ) = stop_condition.evaluate(kept)
                         if stop:
                             stop_condition_type = stop_condition.type()
                             break
 
-                    
                     # if kept.data != b'':
                     #     self.fragments.append(kept)
 
@@ -303,14 +311,22 @@ class AdapterBackend(ABC):
 
                     if stop:
                         self._first_fragment = True
-                        self._logger.debug(f"Payload {self._fragments_to_string(self.fragments)} ({stop_condition_type.value})")
-                        if self._response_request_start is None or len(self.fragments) == 0:
+                        self._logger.debug(
+                            f"Payload {self._fragments_to_string(self.fragments)} ({stop_condition_type.value})"
+                        )
+                        if (
+                            self._response_request_start is None
+                            or len(self.fragments) == 0
+                        ):
                             response_delay = None
                         else:
                             if self.fragments[0].timestamp is None:
                                 response_delay = None
                             else:
-                                response_delay = self.fragments[0].timestamp - self._response_request_start
+                                response_delay = (
+                                    self.fragments[0].timestamp
+                                    - self._response_request_start
+                                )
                             self._response_request_start = None
                         yield AdapterReadPayload(
                             fragments=self.fragments,
@@ -318,9 +334,9 @@ class AdapterBackend(ABC):
                             stop_condition_type=stop_condition_type,
                             previous_read_buffer_used=False,
                             response_timestamp=self.fragments[0].timestamp,
-                            response_delay=response_delay
+                            response_delay=response_delay,
                         )
-                        self._next_timeout_timestamp = None # Experiment !
+                        self._next_timeout_timestamp = None  # Experiment !
                         self.fragments.clear()
 
                     if len(self._previous_buffer.data) > 0 and stop:
@@ -341,8 +357,9 @@ class AdapterBackend(ABC):
         """
         self._response_request_start = time.time()
         self._logger.debug(f"Setup read [{identifier}] in {response_time:.3f} s")
-        self._response_request = ResponseRequest(self._response_request_start + response_time, identifier)
-        
+        self._response_request = ResponseRequest(
+            self._response_request_start + response_time, identifier
+        )
 
     @abstractmethod
     def is_opened(self) -> bool:
@@ -366,7 +383,9 @@ class AdapterBackend(ABC):
                 response_delay = None
             else:
                 if self.fragments[0].timestamp is not None:
-                    response_delay = self.fragments[0].timestamp - self._response_request_start
+                    response_delay = (
+                        self.fragments[0].timestamp - self._response_request_start
+                    )
                 else:
                     response_delay = None
                 self._response_request_start = None
@@ -376,8 +395,10 @@ class AdapterBackend(ABC):
                 stop_condition_type=StopConditionType.TIMEOUT,
                 previous_read_buffer_used=False,
                 fragments=self.fragments,
-                response_timestamp=self.fragments[0].timestamp if len(self.fragments) > 0 else None,
-                response_delay=response_delay
+                response_timestamp=(
+                    self.fragments[0].timestamp if len(self.fragments) > 0 else None
+                ),
+                response_delay=response_delay,
             )
             # Reset response request
             if self._response_request is not None:
@@ -388,8 +409,7 @@ class AdapterBackend(ABC):
             return output
 
         elif (
-            self._next_timeout_origin
-            == self.AdapterTimeoutEventOrigin.RESPONSE_REQUEST
+            self._next_timeout_origin == self.AdapterTimeoutEventOrigin.RESPONSE_REQUEST
         ):
             if self._response_request is not None:
                 signal = AdapterResponseTimeout(self._response_request.identifier)
@@ -402,8 +422,6 @@ class AdapterBackend(ABC):
         min_timestamp = None
         self._next_timeout_origin = None
 
-        t = time.time()
-
         if self._next_timeout_timestamp is not None:
             min_timestamp = self._next_timeout_timestamp
             self._next_timeout_origin = self.AdapterTimeoutEventOrigin.TIMEOUT

syndesi/adapters/backend/adapter_session.py

@@ -11,19 +11,18 @@ import threading
 import time
 from enum import Enum
 from multiprocessing.connection import Pipe, wait
-from typing import Any, Tuple
+from typing import Any
 
-from syndesi.adapters.backend.stop_condition_backend import StopConditionBackend, stop_condition_to_backend
-from syndesi.tools.errors import make_error_description
+from syndesi.adapters.backend.stop_condition_backend import (
+    stop_condition_to_backend,
+)
+from syndesi.tools.errors import AdapterError, make_error_description
 from syndesi.tools.types import NumberLike
 
 from ...tools.backend_api import Action, frontend_send
 from ...tools.log_settings import LoggerAlias
 from .adapter_backend import (
     AdapterBackend,
-    AdapterDisconnected,
-    #AdapterReadInit,
-    AdapterReadPayload,
     Selectable,
     nmin,
 )
@@ -37,15 +36,16 @@ from .descriptors import (
 )
 from .ip_backend import IPBackend
 from .serialport_backend import SerialPortBackend
-#from .stop_condition_backend import stop_condition_from_list
+
+# from .stop_condition_backend import stop_condition_from_list
 from .visa_backend import VisaBackend
-from pathlib import Path
 
 
 class TimeoutEvent(Enum):
     MONITORING = 0
     ADAPTER = 1
-    #CONNECTIONS = 2
+    # CONNECTIONS = 2
+
 
 def get_adapter(descriptor: Descriptor) -> AdapterBackend:
     # The adapter doesn't exist, create it
@@ -99,18 +99,12 @@ class AdapterSession(threading.Thread):
             self._shutdown_counter_top = None
             self._shutdown_counter = None
 
-        #self._timeout_events: list[tuple[TimeoutEvent, float]] = []
-
         self._read_init_id = 0
 
-
-
     def add_connection(self, conn: NamedConnection) -> None:
         with self._connections_lock:
             self.connections.append(conn)
-            # os.write(self._new_connection_w, b"\x00")
             self._new_connection_w.send(b"\x00")
-            self._logger.info(f"New client : {conn.remote()}")
 
     def _remove_connection(self, conn: NamedConnection) -> None:
         with self._connections_lock:
@@ -142,13 +136,12 @@ class AdapterSession(threading.Thread):
             except Exception as e:
                 error_message = make_error_description(e)
 
-
                 self._logger.critical(
                     f"Error in {self._adapter.descriptor} session loop : {error_message}"
                 )
                 try:
                     error_message = make_error_description(e)
-                        
+
                     for conn in self.connections:
                         frontend_send(conn.conn, Action.ERROR_GENERIC, error_message)
                 except Exception:
@@ -167,15 +160,13 @@ class AdapterSession(threading.Thread):
         # The wait has a timeout set by the adapter, it corresponds to the current continuation/total timeout
 
         # Create a list of what is awaited
-        wait_list: list[Selectable] = [
-            conn.conn for conn in self.connections
-        ]
+        wait_list: list[Selectable] = [conn.conn for conn in self.connections]
         adapter_fd = self._adapter.selectable()
         if adapter_fd is not None and adapter_fd.fileno() >= 0:
             wait_list.append(adapter_fd)
 
         wait_list.append(self._new_connection_r)
-    
+
         timeout_timestamp = None
         event = None
 
@@ -183,8 +174,11 @@ class AdapterSession(threading.Thread):
         if adapter_timestamp is not None:
             timeout_timestamp = nmin(timeout_timestamp, adapter_timestamp)
             event = TimeoutEvent.ADAPTER
-        
-        if timeout_timestamp is None or self._next_monitoring_timestamp < timeout_timestamp:
+
+        if (
+            timeout_timestamp is None
+            or self._next_monitoring_timestamp < timeout_timestamp
+        ):
             timeout_timestamp = self._next_monitoring_timestamp
             event = TimeoutEvent.MONITORING
 
@@ -253,7 +247,6 @@ class AdapterSession(threading.Thread):
             return
         try:
             request = conn.conn.recv()
-            request_timestamp = time.time()
         except (EOFError, ConnectionResetError) as e:
             # Probably a ping or an error
             self._logger.warning(
@@ -275,12 +268,15 @@ class AdapterSession(threading.Thread):
                             self._adapter.set_stop_conditions(
                                 [stop_condition_to_backend(sc) for sc in request[1]]
                             )
-                            if self._adapter.open():
+                            try:
+                                self._adapter.open()
+                            except AdapterError as e:
                                 # Success !
-                                response_action = Action.OPEN
-                            else:
                                 response_action = Action.ERROR_FAILED_TO_OPEN
-                            extra_arguments = ("",)                            
+                                extra_arguments = (str(e),)
+                            else:
+                                response_action = Action.OPEN
+                                extra_arguments = ("",)
                         case Action.WRITE:
                             data = request[1]
                             if self._adapter.is_opened():
@@ -302,9 +298,9 @@ class AdapterSession(threading.Thread):
                         case Action.PING:
                             response_action, extra_arguments = Action.PING, ()
                         case Action.SET_STOP_CONDITIONs:
-                            self._adapter.set_stop_conditions([
-                                stop_condition_to_backend(sc) for sc in request[1]
-                                ])
+                            self._adapter.set_stop_conditions(
+                                [stop_condition_to_backend(sc) for sc in request[1]]
+                            )
                             response_action, extra_arguments = (
                                 Action.SET_STOP_CONDITIONs,
                                 (),
@@ -315,7 +311,9 @@ class AdapterSession(threading.Thread):
                         case Action.START_READ:
                             response_time = float(request[1])
                             self._adapter.start_read(response_time, self._read_init_id)
-                            response_action, extra_arguments = Action.START_READ, (self._read_init_id,)
+                            response_action, extra_arguments = Action.START_READ, (
+                                self._read_init_id,
+                            )
                             self._read_init_id += 1
 
                         # case Action.GET_BACKEND_TIME:

syndesi/adapters/backend/backend.py

@@ -98,6 +98,8 @@ def is_request(x: object) -> TypeGuard[tuple[str, object]]:
 
 class Backend:
     MONITORING_DELAY = 0.5
+    NEW_CLIENT_REQUEST_TIMEOUT = 0.5
+
     _session_shutdown_delay: NumberLike | None
     _backend_shutdown_delay: NumberLike | None
     _backend_shutdown_timestamp: NumberLike | None
@@ -278,7 +280,9 @@ class Backend:
         # Wait for adapter
         # ready = wait([client.conn], timeout=0.1)
         # selectors to work on Unix and Windows
-        ready, _, _ = select.select([client.conn], [], [], 0.1)
+        ready, _, _ = select.select(
+            [client.conn], [], [], self.NEW_CLIENT_REQUEST_TIMEOUT
+        )
         if len(ready) == 0:
             client.conn.close()
             return
@@ -290,6 +294,7 @@ class Backend:
         action = Action(adapter_request[0])
         if action == Action.SELECT_ADAPTER:
             adapter_descriptor = adapter_request[1]
+            self._logger.info(f"New client for {adapter_descriptor}")
             # If the session exists but it is dead, delete it
             if (
                 adapter_descriptor in self.adapter_sessions
@@ -299,7 +304,7 @@ class Backend:
 
             if adapter_descriptor not in self.adapter_sessions:
                 # Create the adapter backend thread
-                self._logger.info(f"Creating adapter session for {adapter_descriptor}")
+                # self._logger.info(f"Creating adapter session for {adapter_descriptor}")
                 thread = AdapterSession(
                     adapter_descriptor, shutdown_delay=self._session_shutdown_delay
                 )  # TODO : Put another delay here ?

syndesi/adapters/backend/backend_tools.py

@@ -1,9 +1,9 @@
 import socket
 from multiprocessing.connection import Connection
 
-
 BACKEND_REQUEST_DEFAULT_TIMEOUT = 0.5
 
+
 def get_conn_addresses(conn: Connection) -> tuple[tuple[str, int], tuple[str, int]]:
     try:
         fd = conn.fileno()

syndesi/adapters/backend/descriptors.py

@@ -71,7 +71,7 @@ class IPDescriptor(Descriptor):
     address: str
     transport: Transport
     port: int | None = None
-    #transport: Transport | None = None
+    # transport: Transport | None = None
 
     @staticmethod
     def from_string(string: str) -> "IPDescriptor":

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
@@ -140,7 +143,7 @@ class IPBackend(AdapterBackend):
 
             if fragment.data == b"":
                 # Socket disconnected
-                self._logger.debug('## Socket disconnected')
+                self._logger.debug("## Socket disconnected")
                 self.close()
 
         return fragment