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

syndesi/adapters/adapter.py

@@ -22,13 +22,12 @@ import subprocess
 import sys
 import threading
 import time
-import uuid
 import weakref
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from multiprocessing.connection import Client, Connection
 from types import EllipsisType
-from typing import Any, cast
+from typing import Any
 import os
 
 from .backend.backend_tools import BACKEND_REQUEST_DEFAULT_TIMEOUT
@@ -38,72 +37,51 @@ from ..tools.backend_api import (
     BACKEND_PORT,
     Action,
     BackendResponse,
+    Fragment,
     default_host,
-    is_event,
     raise_if_error,
+    EXTRA_BUFFER_RESPONSE_TIME
 )
 from ..tools.log_settings import LoggerAlias
 from .backend.adapter_backend import (
     AdapterDisconnected,
-    AdapterReadInit,
+    AdapterResponseTimeout,
     AdapterReadPayload,
     AdapterSignal,
 )
 from .backend.descriptors import Descriptor
-from .stop_condition import StopCondition, TimeoutStopCondition
+from .stop_condition import StopCondition, Continuation, StopConditionType, Total
 from .timeout import Timeout, TimeoutAction, any_to_timeout
 
-DEFAULT_STOP_CONDITION = [TimeoutStopCondition(continuation=0.1)]
+DEFAULT_STOP_CONDITION = Continuation(time=0.1)
 
 DEFAULT_TIMEOUT = Timeout(response=5, action='error')
 
-SHUTDOWN_DELAY = 2
-
 # Maximum time to let the backend start
 START_TIMEOUT = 2
+# Time to shutdown the backend
+SHUTDOWN_DELAY = 2
 
-# from enum import Enum, auto
-
-
-# class CallbackEvent(Enum):
-#     DATA_READY = auto()
-#     ADAPTER_DISCONNECTED = auto()
-
-import time
-import queue
-from typing import TypeVar, Generic
-
-T = TypeVar("T")
+class SignalQueue(queue.Queue[AdapterSignal]):
+    def __init__(self) -> None:
+        self._read_payload_counter = 0
+        super().__init__(0)
 
-class PeekQueue(queue.Queue, Generic[T]):
-    def peek(self, block: bool = True, timeout: float | None = None) -> T:
-        """
-        Return (without removing) the head item.
+    def has_read_payload(self) -> bool:
+        return self._read_payload_counter > 0
 
-        Args:
-            block: If False, raise queue.Empty immediately if empty.
-            timeout: Max seconds to wait if block=True. None means wait forever.
 
-        Raises:
-            queue.Empty: if no item is available within constraints.
-        """
-        with self.not_empty:
-            if not block:
-                if not self._qsize():
-                    raise queue.Empty
-                return self.queue[0]  # type: ignore[attr-defined]
-
-            end = None if timeout is None else time.monotonic() + timeout
-            while not self._qsize():
-                if timeout is None:
-                    self.not_empty.wait()
-                else:
-                    remaining = end - time.monotonic()
-                    if remaining <= 0:
-                        raise queue.Empty
-                    self.not_empty.wait(remaining)
+    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)
+    
 
-            return self.queue[0]  # type: ignore[attr-defined]
+    def get(self, block: bool = True, timeout: float | None = None) -> AdapterSignal:
+        signal = super().get(block, timeout)
+        if isinstance(signal, AdapterReadPayload):
+            self._read_payload_counter -= 1
+        return signal
 
 
 def is_backend_running(address: str, port: int) -> bool:
@@ -128,29 +106,23 @@ def start_backend(port: int | None = None) -> None:
             str(BACKEND_PORT if port is None else port),
         ]
     
-    # Always sever stdio — if you leave any of these inherited,
-    # you can keep an implicit console/TTY attachment.
     stdin  = subprocess.DEVNULL
     stdout = subprocess.DEVNULL
     stderr = subprocess.DEVNULL
 
     if os.name == "posix":
-        # New session == new process group, no longer the terminal's foreground PG.
-        # This prevents keyboard SIGINT/SIGTSTP from the parent's TTY.
         subprocess.Popen(
             arguments,
-            # cwd=None,
-            # env=None,
             stdin=stdin,
             stdout=stdout,
             stderr=stderr,
-            start_new_session=True,   # safer than preexec_fn=os.setsid in threaded parents
-            close_fds=True,           # ensure we don't leak any FDs that tie us to the parent
+            start_new_session=True,
+            close_fds=True,
         )
 
     else:
         # Windows: detach from the parent's console so keyboard Ctrl+C won't propagate.
-        CREATE_NEW_PROCESS_GROUP = subprocess.CREATE_NEW_PROCESS_GROUP
+        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
@@ -159,13 +131,11 @@ def start_backend(port: int | None = None) -> None:
 
         subprocess.Popen(
             arguments,
-            # cwd=cwd,
-            # env=env,
             stdin=stdin,
             stdout=stdout,
             stderr=stderr,
             creationflags=creationflags,
-            close_fds=True,  # break handle inheritance (important with DETACHED_PROCESS)
+            close_fds=True,
         )
 
 class ReadScope(Enum):
@@ -177,7 +147,7 @@ class Adapter(ABC):
         self,
         descriptor: Descriptor,
         alias: str = "",
-        stop_conditions: StopCondition | EllipsisType | list = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
         timeout: Timeout | EllipsisType | NumberLike | None = ...,
         encoding: str = "utf-8",
         event_callback: Callable[[AdapterSignal], None] | None = None,
@@ -203,7 +173,7 @@ class Adapter(ABC):
         super().__init__()
         self._logger = logging.getLogger(LoggerAlias.ADAPTER.value)
         self.encoding = encoding
-        self._event_queue: PeekQueue[BackendResponse] = PeekQueue()
+        self._signal_queue: SignalQueue = SignalQueue()
         self.event_callback: Callable[[AdapterSignal], None] | None = event_callback
         self.backend_connection: Connection | None = None
         self._backend_connection_lock = threading.Lock()
@@ -211,7 +181,6 @@ class Adapter(ABC):
         self._make_backend_request_flag = threading.Event()
         self.opened = False
         self._alias = alias
-        self._read_buffer = []
 
         if backend_address is None:
             self._backend_address = default_host
@@ -235,10 +204,10 @@ class Adapter(ABC):
         self.auto_open = auto_open
 
         # Set the stop-condition
-        self._stop_conditions: list[StopCondition | None]
+        self._stop_conditions: list[StopCondition]
         if stop_conditions is ...:
             self._default_stop_condition = True
-            self._stop_conditions = DEFAULT_STOP_CONDITION
+            self._stop_conditions = [DEFAULT_STOP_CONDITION]
         else:
             self._default_stop_condition = False
             if isinstance(stop_conditions, StopCondition):
@@ -306,7 +275,7 @@ class Adapter(ABC):
             raise RuntimeError("Failed to connect to backend") from err
         self._read_thread = threading.Thread(
             target=self.read_thread,
-            args=(self._event_queue, self._make_backend_request_queue),
+            args=(self._signal_queue, self._make_backend_request_queue),
             daemon=True,
         )
         self._read_thread.start()
@@ -348,7 +317,7 @@ class Adapter(ABC):
 
     def read_thread(
         self,
-        event_queue: queue.Queue[BackendResponse],
+        signal_queue: SignalQueue,
         request_queue: queue.Queue[BackendResponse],
     ) -> None:
         while True:
@@ -357,7 +326,7 @@ class Adapter(ABC):
                     raise RuntimeError("Backend connection wasn't initialized")
                 response: tuple[Any, ...] = self.backend_connection.recv()
             except (EOFError, TypeError, OSError):
-                event_queue.put((Action.ERROR_BACKEND_DISCONNECTED,))
+                signal_queue.put(AdapterDisconnected())
                 request_queue.put((Action.ERROR_BACKEND_DISCONNECTED,))
                 break
             else:
@@ -365,13 +334,14 @@ class Adapter(ABC):
                     raise RuntimeError(f"Invalid response from backend : {response}")
                 action = Action(response[0])
 
-                if is_event(action):
+                if action == Action.ADAPTER_SIGNAL:
+                #if is_event(action):
                     if len(response) <= 1:
                         raise RuntimeError(f"Invalid event response : {response}")
+                    signal: AdapterSignal = response[1]
                     if self.event_callback is not None:
-                        signal: AdapterSignal = response[1]
                         self.event_callback(signal)
-                    event_queue.put(response)
+                    signal_queue.put(signal)
                 else:
                     request_queue.put(response)
 
@@ -401,7 +371,7 @@ 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) -> None:
+    def set_stop_conditions(self, stop_conditions: StopCondition | None | list[StopCondition]) -> None:
         """
         Overwrite the stop-condition
 
@@ -416,11 +386,7 @@ class Adapter(ABC):
         elif stop_conditions is None:
             self._stop_conditions = []
 
-        # if self._stop_conditions is None:
-        #     payload = None
-        # else:
-        #     payload = self._stop_conditions.compose_json()
-        self._make_backend_request(Action.SET_STOP_CONDITION, self._stop_conditions)
+        self._make_backend_request(Action.SET_STOP_CONDITIONs, self._stop_conditions)
 
     def set_default_stop_condition(self, stop_condition: StopCondition) -> None:
         """
@@ -442,7 +408,7 @@ class Adapter(ABC):
         )
         while True:
             try:
-                self._event_queue.get(block=False)
+                self._signal_queue.get(block=False)
             except queue.Empty:
                 break
             
@@ -469,11 +435,11 @@ class Adapter(ABC):
         """
         Stop communication with the device
         """
-        self._logger.debug("Closing adapter frontend")
-        self._make_backend_request(Action.CLOSE)
         if force:
+            self._logger.debug("Closing adapter frontend")
+        else:
             self._logger.debug("Force closing adapter backend")
-            self._make_backend_request(Action.FORCE_CLOSE)
+        self._make_backend_request(Action.CLOSE, force)
 
         with self._backend_connection_lock:
             if self.backend_connection is not None:
@@ -497,9 +463,9 @@ class Adapter(ABC):
     def read_detailed(
         self,
         timeout: Timeout | EllipsisType | None = ...,
-        stop_condition: StopCondition | EllipsisType | None = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
         scope : str = ReadScope.BUFFERED.value,
-    ) -> tuple[bytes, AdapterReadPayload | None]:
+    ) -> AdapterReadPayload:
         """
         Read data from the device
 
@@ -517,110 +483,104 @@ class Adapter(ABC):
         signal : AdapterReadPayload
         """
         _scope = ReadScope(scope)
-        # Okay idea : Remove the start read and instead ask for the time of the backend.
-        # Then we read whatever payload comes from the backend and compare that to the time
-        # If it doesn't match our criteria, we trash it
-        # When waiting for the backend payload, we wait +0.5s so make sure we received everything
-        # This 0.5s could be changed if we're local or not by the way
-
+        output_signal = None
+        read_timeout = None
 
-        # First, ask for the backend time, this is the official start of the read 
-        backend_read_start_time = cast(NumberLike, self._make_backend_request(Action.GET_BACKEND_TIME)[0])
-
-        # If not timeout is specified, use the default one
         if timeout is ...:
             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]    
+            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
+        while _scope == ReadScope.BUFFERED and self._signal_queue.has_read_payload():
+            signal = self._signal_queue.get()
+            if isinstance(signal, AdapterReadPayload):
+                output_signal = signal
+                break
+            # TODO : Implement disconnect ?
+        else:
+            # Nothing was found, ask the backend with a START_READ request. The backend will
+            # respond at most after the response_time with either data or a RESPONSE_TIMEOUT
 
-        if read_timeout is not None:
             if not read_timeout.is_initialized():
                 raise RuntimeError("Timeout needs to be initialized")
 
-        # Calculate last_valid_timestamp, the limit at which a payload is not accepted anymore
-        # Calculate the queue timeout (time for a response + small delay)
-        #last_valid_timestamp = None
-        queue_timeout_timestamp = None
-        if read_timeout is not None:
-            response_delay = read_timeout.response()
-        else:
-            response_delay = None
-
-        if response_delay is not None:
-            #last_valid_timestamp = backend_read_start_time + response_delay
-            queue_timeout_timestamp = time.time() + response_delay + BACKEND_REQUEST_DEFAULT_TIMEOUT
+            _response = read_timeout.response()
 
-        output_signal : AdapterReadPayload | None
+            read_init_time = time.time()
+            start_read_id = self._make_backend_request(Action.START_READ, _response)[0]
 
-        # Ready to read payloads
-        while True:
-            if queue_timeout_timestamp is None:
-                queue_timeout = None
+            if _response is None:
+                # Wait indefinitely
+                read_stop_timestamp = None
             else:
-                queue_timeout = queue_timeout_timestamp - time.time()
-                if queue_timeout < 0:
-                    queue_timeout = 0
+                # Wait for the response time + a bit more
+                read_stop_timestamp = read_init_time + _response
 
-            try:
-                response = self._event_queue.peek(block=True, timeout=queue_timeout)
-                signal = response[1]
+            # 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)
+
+                    signal = self._signal_queue.get(timeout=queue_timeout)
+                except queue.Empty:
+                    raise RuntimeError('Failed to receive response from backend')
                 if isinstance(signal, AdapterReadPayload):
-                    if response_delay is not None and signal.response_timestamp - backend_read_start_time > response_delay:
-                        # This signal happened after the max response time, act as if a timeout occured
-                        # and do not pop it out of the queue
-                        # TODO : Make _timeout always Timeout, never None ?
-                        output_signal = None
-                        break
-
-                    if _scope == ReadScope.NEXT and signal.response_timestamp < backend_read_start_time:
-                        # The payload happened before the read start
-                        self._event_queue.get()
-                        continue
-
-                    if response_delay is not None:
-                        if signal.response_timestamp - backend_read_start_time > response_delay:
-                            self._event_queue.get()
-                            output_signal = None
-                            break
-                    
-                    # Other wise the payload is valid
-                    self._event_queue.get()
                     output_signal = signal
                     break
-
                 elif isinstance(signal, AdapterDisconnected):
-                    self._event_queue.get()
                     raise RuntimeError("Adapter disconnected")
-
-            except queue.Empty:
-                output_signal = None
-                break    
-
-
+                elif isinstance(signal, AdapterResponseTimeout):
+                    if start_read_id == signal.identifier:
+                        output_signal = None
+                        break
+                    # Otherwise ignore it
 
         if output_signal is None:
-            # TODO : Make _timeout always Timeout, never None ?
-            if read_timeout.action == TimeoutAction.RETURN:
-                data = b""
-                output_signal = None
-            elif read_timeout.action == TimeoutAction.ERROR:
-                raise TimeoutError(
-                    f"No response received from device within {read_timeout.response()} seconds"
-                )
-        else:
-            data = output_signal.data()
-            output_signal.response_delay = output_signal.response_timestamp - backend_read_start_time
-
+            # 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)],
+                        stop_timestamp=t,
+                        stop_condition_type=StopConditionType.TIMEOUT,
+                        previous_read_buffer_used=False,
+                        response_timestamp=None,
+                        response_delay=None
+                    )
+                case TimeoutAction.ERROR:
+                    raise TimeoutError(
+                        f"No response received from device within {read_timeout.response()} seconds"
+                    )
+                case _:
+                    raise NotImplementedError()
         
-        return data, output_signal
+        else:
+            return output_signal
 
     def read(
         self,
         timeout: Timeout | EllipsisType | None = ...,
-        stop_condition: StopCondition | EllipsisType | None = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
     ) -> bytes:
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)[0]
+        signal = self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        return signal.data()
 
     def _cleanup(self) -> None:
         if self._init_ok and self.opened:
@@ -630,8 +590,8 @@ class Adapter(ABC):
         self,
         data: bytes | str,
         timeout: Timeout | EllipsisType | None = ...,
-        stop_condition: StopCondition | EllipsisType | None = ...,
-    ) -> tuple[bytes, AdapterReadPayload | None]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> AdapterReadPayload:
         """
         Shortcut function that combines
         - flush_read
@@ -640,17 +600,18 @@ class Adapter(ABC):
         """
         self.flushRead()
         self.write(data)
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)
+        return self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
 
     def query(
         self,
         data: bytes | str,
         timeout: Timeout | EllipsisType | None = ...,
-        stop_condition: StopCondition | EllipsisType | None = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
     ) -> bytes:
-        return self.query_detailed(
-            data=data, timeout=timeout, stop_condition=stop_condition
-        )[0]
+        signal = self.query_detailed(
+            data=data, timeout=timeout, stop_conditions=stop_conditions
+        )
+        return signal.data()
 
     def set_event_callback(self, callback: Callable[[AdapterSignal], None]) -> None:
         self.event_callback = callback

syndesi/adapters/auto.py

@@ -37,7 +37,7 @@ def auto_adapter(adapter_or_string: Adapter | str) -> Adapter:
             return IP(
                 address=descriptor.address,
                 port=descriptor.port,
-                transport=descriptor.transport,
+                transport=descriptor.transport.value,
             )
         elif isinstance(descriptor, SerialPortDescriptor):
             return SerialPort(port=descriptor.port, baudrate=descriptor.baudrate)