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

syndesi/adapters/adapter.py

@@ -15,8 +15,8 @@
 # An adapter is meant to work with bytes objects but it can accept strings.
 # Strings will automatically be converted to bytes using utf-8 encoding
 
-from enum import Enum
 import logging
+import os
 import queue
 import subprocess
 import sys
@@ -25,43 +25,44 @@ import time
 import weakref
 from abc import ABC, abstractmethod
 from collections.abc import Callable
+from enum import Enum
 from multiprocessing.connection import Client, Connection
 from types import EllipsisType
 from typing import Any
-import os
 
-from .backend.backend_tools import BACKEND_REQUEST_DEFAULT_TIMEOUT
 from syndesi.tools.types import NumberLike, is_number
 
 from ..tools.backend_api import (
     BACKEND_PORT,
+    EXTRA_BUFFER_RESPONSE_TIME,
     Action,
     BackendResponse,
     Fragment,
     default_host,
     raise_if_error,
-    EXTRA_BUFFER_RESPONSE_TIME
 )
 from ..tools.log_settings import LoggerAlias
 from .backend.adapter_backend import (
     AdapterDisconnected,
-    AdapterResponseTimeout,
     AdapterReadPayload,
+    AdapterResponseTimeout,
     AdapterSignal,
 )
+from .backend.backend_tools import BACKEND_REQUEST_DEFAULT_TIMEOUT
 from .backend.descriptors import Descriptor
-from .stop_condition import StopCondition, Continuation, StopConditionType, Total
+from .stop_condition import Continuation, StopCondition, StopConditionType
 from .timeout import Timeout, TimeoutAction, any_to_timeout
 
 DEFAULT_STOP_CONDITION = Continuation(time=0.1)
 
-DEFAULT_TIMEOUT = Timeout(response=5, action='error')
+DEFAULT_TIMEOUT = Timeout(response=5, action="error")
 
 # Maximum time to let the backend start
 START_TIMEOUT = 2
 # Time to shutdown the backend
 SHUTDOWN_DELAY = 2
 
+
 class SignalQueue(queue.Queue[AdapterSignal]):
     def __init__(self) -> None:
         self._read_payload_counter = 0
@@ -70,12 +71,12 @@ class SignalQueue(queue.Queue[AdapterSignal]):
     def has_read_payload(self) -> bool:
         return self._read_payload_counter > 0
 
-
-    def put(self, signal: AdapterSignal, block: bool = True, timeout: float | None = None) -> None:
+    def put(
+        self, signal: AdapterSignal, block: bool = True, timeout: float | None = None
+    ) -> None:
         if isinstance(signal, AdapterReadPayload):
             self._read_payload_counter += 1
         return super().put(signal, block, timeout)
-    
 
     def get(self, block: bool = True, timeout: float | None = None) -> AdapterSignal:
         signal = super().get(block, timeout)
@@ -94,19 +95,20 @@ def is_backend_running(address: str, port: int) -> bool:
         conn.close()
         return True
 
+
 def start_backend(port: int | None = None) -> None:
     arguments = [
-            sys.executable,
-            "-m",
-            "syndesi.adapters.backend.backend",
-            "-s",
-            str(SHUTDOWN_DELAY),
-            "-q",
-            "-p",
-            str(BACKEND_PORT if port is None else port),
-        ]
-    
-    stdin  = subprocess.DEVNULL
+        sys.executable,
+        "-m",
+        "syndesi.adapters.backend.backend",
+        "-s",
+        str(SHUTDOWN_DELAY),
+        "-q",
+        "-p",
+        str(BACKEND_PORT if port is None else port),
+    ]
+
+    stdin = subprocess.DEVNULL
     stdout = subprocess.DEVNULL
     stderr = subprocess.DEVNULL
 
@@ -122,8 +124,8 @@ def start_backend(port: int | None = None) -> None:
 
     else:
         # Windows: detach from the parent's console so keyboard Ctrl+C won't propagate.
-        CREATE_NEW_PROCESS_GROUP = subprocess.CREATE_NEW_PROCESS_GROUP # type: ignore
-        DETACHED_PROCESS = 0x00000008          # not exposed by subprocess on all Pythons
+        CREATE_NEW_PROCESS_GROUP = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore
+        DETACHED_PROCESS = 0x00000008  # not exposed by subprocess on all Pythons
         # Optional: CREATE_NO_WINDOW (no window even for console apps)
         CREATE_NO_WINDOW = 0x08000000
 
@@ -138,9 +140,11 @@ def start_backend(port: int | None = None) -> None:
             close_fds=True,
         )
 
+
 class ReadScope(Enum):
-    NEXT = 'next'
-    BUFFERED = 'buffered'
+    NEXT = "next"
+    BUFFERED = "buffered"
+
 
 class Adapter(ABC):
     def __init__(
@@ -215,7 +219,7 @@ class Adapter(ABC):
             elif isinstance(stop_conditions, list):
                 self._stop_conditions = stop_conditions
             else:
-                raise ValueError('Invalid stop_conditions')
+                raise ValueError("Invalid stop_conditions")
 
         # Set the timeout
         self.is_default_timeout = False
@@ -335,7 +339,7 @@ class Adapter(ABC):
                 action = Action(response[0])
 
                 if action == Action.ADAPTER_SIGNAL:
-                #if is_event(action):
+                    # if is_event(action):
                     if len(response) <= 1:
                         raise RuntimeError(f"Invalid event response : {response}")
                     signal: AdapterSignal = response[1]
@@ -371,7 +375,9 @@ class Adapter(ABC):
             self._logger.debug(f"Setting default timeout to {default_timeout}")
             self._timeout = default_timeout
 
-    def set_stop_conditions(self, stop_conditions: StopCondition | None | list[StopCondition]) -> None:
+    def set_stop_conditions(
+        self, stop_conditions: StopCondition | None | list[StopCondition]
+    ) -> None:
         """
         Overwrite the stop-condition
 
@@ -411,7 +417,6 @@ class Adapter(ABC):
                 self._signal_queue.get(block=False)
             except queue.Empty:
                 break
-            
 
     def previous_read_buffer_empty(self) -> bool:
         """
@@ -464,7 +469,7 @@ class Adapter(ABC):
         self,
         timeout: Timeout | EllipsisType | None = ...,
         stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
-        scope : str = ReadScope.BUFFERED.value,
+        scope: str = ReadScope.BUFFERED.value,
     ) -> AdapterReadPayload:
         """
         Read data from the device
@@ -490,13 +495,13 @@ class Adapter(ABC):
             read_timeout = self._timeout
         else:
             read_timeout = any_to_timeout(timeout)
-            
+
         if read_timeout is None:
             raise RuntimeError("Cannot read without setting a timeout")
 
         if stop_conditions is not ...:
             if isinstance(stop_conditions, StopCondition):
-                stop_conditions = [stop_conditions]    
+                stop_conditions = [stop_conditions]
             self._make_backend_request(Action.SET_STOP_CONDITIONs, stop_conditions)
 
         # First, we check if data is in the buffer and if the scope if set to BUFFERED
@@ -525,21 +530,21 @@ class Adapter(ABC):
                 # Wait for the response time + a bit more
                 read_stop_timestamp = read_init_time + _response
 
-            # else:
-            #     start_read_id = None
-            #     read_init_time = None
-
-            
             while True:
                 try:
                     if read_stop_timestamp is None:
                         queue_timeout = None
                     else:
-                        queue_timeout = max(0, read_stop_timestamp - time.time() + EXTRA_BUFFER_RESPONSE_TIME)
+                        queue_timeout = max(
+                            0,
+                            read_stop_timestamp
+                            - time.time()
+                            + EXTRA_BUFFER_RESPONSE_TIME,
+                        )
 
                     signal = self._signal_queue.get(timeout=queue_timeout)
-                except queue.Empty:
-                    raise RuntimeError('Failed to receive response from backend')
+                except queue.Empty as e:
+                    raise RuntimeError("Failed to receive response from backend") from e
                 if isinstance(signal, AdapterReadPayload):
                     output_signal = signal
                     break
@@ -552,17 +557,16 @@ class Adapter(ABC):
                     # Otherwise ignore it
 
         if output_signal is None:
-            # TODO : Make read_timeout always Timeout, never None ?
             match read_timeout.action:
                 case TimeoutAction.RETURN_EMPTY:
                     t = time.time()
                     return AdapterReadPayload(
-                        fragments=[Fragment(b'', t)],
+                        fragments=[Fragment(b"", t)],
                         stop_timestamp=t,
                         stop_condition_type=StopConditionType.TIMEOUT,
                         previous_read_buffer_used=False,
                         response_timestamp=None,
-                        response_delay=None
+                        response_delay=None,
                     )
                 case TimeoutAction.ERROR:
                     raise TimeoutError(
@@ -570,7 +574,7 @@ class Adapter(ABC):
                     )
                 case _:
                     raise NotImplementedError()
-        
+
         else:
             return output_signal
 

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:
@@ -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
 
@@ -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([])
 
@@ -263,7 +263,10 @@ class AdapterBackend(ABC):
             self.close()
             yield AdapterDisconnected()
         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,9 +11,11 @@ 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.adapters.backend.stop_condition_backend import (
+    stop_condition_to_backend,
+)
 from syndesi.tools.errors import make_error_description
 from syndesi.tools.types import NumberLike
 
@@ -21,9 +23,6 @@ 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,12 +99,10 @@ class AdapterSession(threading.Thread):
             self._shutdown_counter_top = None
             self._shutdown_counter = None
 
-        #self._timeout_events: list[tuple[TimeoutEvent, float]] = []
+        # 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)
@@ -142,13 +140,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 +164,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 +178,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 +251,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(
@@ -280,7 +277,7 @@ class AdapterSession(threading.Thread):
                                 response_action = Action.OPEN
                             else:
                                 response_action = Action.ERROR_FAILED_TO_OPEN
-                            extra_arguments = ("",)                            
+                            extra_arguments = ("",)
                         case Action.WRITE:
                             data = request[1]
                             if self._adapter.is_opened():
@@ -302,9 +299,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 +312,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_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

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