syndesi 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

syndesi/adapters/adapter.py

@@ -15,63 +15,86 @@
 # 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 queue
 import subprocess
 import sys
 import threading
 import time
-from typing import Any, Callable, Literal, Optional, Tuple, Union, overload
-import uuid
 import weakref
 from abc import ABC, abstractmethod
-from multiprocessing.connection import Client
-
-from syndesi.tools.types import DEFAULT, DefaultType, NumberLike, is_number
-
-from ..tools.backend_api import BACKEND_PORT, Action, BackendResponse, _default_host, is_event
+from collections.abc import Callable
+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,
+    Action,
+    BackendResponse,
+    default_host,
+    raise_if_error,
+    EXTRA_BUFFER_RESPONSE_TIME
+)
 from ..tools.log_settings import LoggerAlias
-from .backend.adapter_backend import AdapterDisconnected, AdapterReadInit, AdapterReadPayload, AdapterSignal
-from .stop_condition import StopCondition, TimeoutStopCondition
+from .backend.adapter_backend import (
+    AdapterDisconnected,
+    AdapterResponseTimeout,
+    AdapterReadPayload,
+    AdapterSignal,
+)
+from .backend.descriptors import Descriptor
+from .stop_condition import StopCondition, Continuation, 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 = 5
-
-SHUTDOWN_DELAY = 2
+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
 
-#from enum import Enum, auto
+class SignalQueue(queue.Queue[AdapterSignal]):
+    def __init__(self) -> None:
+        self._read_payload_counter = 0
+        super().__init__(0)
 
-from ..tools.backend_api import raise_if_error
-from .backend.descriptors import Descriptor
+    def has_read_payload(self) -> bool:
+        return self._read_payload_counter > 0
 
 
-# class CallbackEvent(Enum):
-#     DATA_READY = auto()
-#     ADAPTER_DISCONNECTED = auto()
+    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)
+        if isinstance(signal, AdapterReadPayload):
+            self._read_payload_counter -= 1
+        return signal
 
 
-def is_backend_running(address : Optional[str] = None, port : Optional[int] = None) -> bool:
+def is_backend_running(address: str, port: int) -> bool:
 
     try:
-        conn = Client((
-            _default_host if address is None else address,
-            BACKEND_PORT if port is None else port
-            ))
+        conn = Client((address, port))
     except ConnectionRefusedError:
         return False
     else:
         conn.close()
         return True
 
-
-def start_backend(port : Optional[int] = None) -> None:
-    subprocess.Popen(
-        [
+def start_backend(port: int | None = None) -> None:
+    arguments = [
             sys.executable,
             "-m",
             "syndesi.adapters.backend.backend",
@@ -79,26 +102,57 @@ def start_backend(port : Optional[int] = None) -> None:
             str(SHUTDOWN_DELAY),
             "-q",
             "-p",
-            str(BACKEND_PORT if port is None else port)
+            str(BACKEND_PORT if port is None else port),
         ]
-    )
+    
+    stdin  = subprocess.DEVNULL
+    stdout = subprocess.DEVNULL
+    stderr = subprocess.DEVNULL
+
+    if os.name == "posix":
+        subprocess.Popen(
+            arguments,
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+            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 # 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
+
+        creationflags = CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS | CREATE_NO_WINDOW
+
+        subprocess.Popen(
+            arguments,
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+            creationflags=creationflags,
+            close_fds=True,
+        )
 
+class ReadScope(Enum):
+    NEXT = 'next'
+    BUFFERED = 'buffered'
 
 class Adapter(ABC):
-    ADDITIONNAL_RESPONSE_DELAY = 1
-    BACKEND_REQUEST_DEFAULT_TIMEOUT = 1
-
     def __init__(
         self,
         descriptor: Descriptor,
         alias: str = "",
-        stop_condition: Optional[Union[StopCondition, DefaultType]] = DEFAULT,
-        timeout: Optional[Union[Timeout, DefaultType, NumberLike]] = DEFAULT,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+        timeout: Timeout | EllipsisType | NumberLike | None = ...,
         encoding: str = "utf-8",
-        event_callback : Optional[Callable[[AdapterSignal], None]] = None,
-        auto_open : bool = True,
-        backend_address : Optional[str] = None,
-        backend_port : Optional[int] = None
+        event_callback: Callable[[AdapterSignal], None] | None = None,
+        auto_open: bool = True,
+        backend_address: str | None = None,
+        backend_port: int | None = None,
     ) -> None:
         """
         Adapter instance
@@ -118,61 +172,57 @@ class Adapter(ABC):
         super().__init__()
         self._logger = logging.getLogger(LoggerAlias.ADAPTER.value)
         self.encoding = encoding
-        self._event_queue : queue.Queue[BackendResponse] = queue.Queue()
-        self.event_callback : Optional[Callable[[AdapterSignal], None]] = event_callback
+        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()
-        self._make_backend_request_queue : queue.Queue[BackendResponse] = queue.Queue()
+        self._make_backend_request_queue: queue.Queue[BackendResponse] = queue.Queue()
         self._make_backend_request_flag = threading.Event()
         self.opened = False
+        self._alias = alias
 
-        if is_backend_running(backend_address, backend_port):
-            self._logger.info("Backend already running")
-        elif backend_address is not None:
-            raise RuntimeError(f"Cannot connect to backend {backend_address}")
+        if backend_address is None:
+            self._backend_address = default_host
         else:
-            self._logger.info("Starting backend...")
-            start_backend(backend_port)
-            start = time.time()
-            while time.time() < (start + START_TIMEOUT):
-                if is_backend_running():
-                    self._logger.info("Backend started")
-                    break
-                time.sleep(0.1)
-            else:
-                # Backend could not start
-                self._logger.error("Could not start backend")
+            self._backend_address = backend_address
+        if backend_port is None:
+            self._backend_port = BACKEND_PORT
+        else:
+            self._backend_port = backend_port
+
+        # There a two possibilities here
+        # A) The descriptor is fully initialized
+        #    -> The adapter can be connected directly
+        # B) The descriptor is not fully initialized
+        #    -> Wait for the protocol to set defaults and then connect the adapter
 
         assert isinstance(
             descriptor, Descriptor
         ), "descriptor must be a Descriptor class"
         self.descriptor = descriptor
+        self.auto_open = auto_open
 
-        # Open the connection with the backend
-        try:
-            self.backend_connection = Client((_default_host, BACKEND_PORT))
-        except ConnectionRefusedError:
-            raise RuntimeError("Failed to connect to backend")
-        self._read_thread = threading.Thread(
-            target=self.read_thread,
-            args=(self._event_queue, self._make_backend_request_queue),
-            daemon=True,
-        )
-        self._read_thread.start()
-
-        # Identify ourselves
-        self._make_backend_request(Action.SET_ROLE_ADAPTER)
-
-        # Set the adapter
-        self._make_backend_request(Action.SELECT_ADAPTER, str(self.descriptor))
-
-        self._alias = alias
+        # Set the stop-condition
+        self._stop_conditions: list[StopCondition]
+        if stop_conditions is ...:
+            self._default_stop_condition = True
+            self._stop_conditions = [DEFAULT_STOP_CONDITION]
+        else:
+            self._default_stop_condition = False
+            if isinstance(stop_conditions, StopCondition):
+                self._stop_conditions = [stop_conditions]
+            elif isinstance(stop_conditions, list):
+                self._stop_conditions = stop_conditions
+            else:
+                raise ValueError('Invalid stop_conditions')
 
         # Set the timeout
         self.is_default_timeout = False
-        self._timeout : Optional[Timeout]
+        self._timeout: Timeout | None
         if timeout is Ellipsis:
             # Not set
             self.is_default_timeout = True
+            self._timeout = DEFAULT_TIMEOUT
         elif isinstance(timeout, Timeout):
             self._timeout = timeout
         elif is_number(timeout):
@@ -180,41 +230,82 @@ class Adapter(ABC):
         elif timeout is None:
             self._timeout = timeout
 
-
-        # Set the stop-condition
-        self._stop_condition : Optional[StopCondition]
-        if stop_condition is DEFAULT:
-            self._default_stop_condition = True
-            self._stop_condition = DEFAULT_STOP_CONDITION
-        else:
-            self._default_stop_condition = False
-            self._stop_condition = stop_condition
-
         # Buffer for data that has been pulled from the queue but
         # not used because of termination or length stop condition
         self._previous_buffer = b""
 
+        if self.descriptor.is_initialized():
+            self.connect()
+
         weakref.finalize(self, self._cleanup)
         self._init_ok = True
-        self.auto_open = auto_open
-        if auto_open:
+
+        # We can auto-open only if auto_open is enabled and if
+        # connection with the backend has been made (descriptor initialized)
+        if self.auto_open and self.backend_connection is not None:
             self.open()
 
-    def _make_backend_request(self, action: Action, *args : Any) -> BackendResponse:
+    def connect(self) -> None:
+        if self.backend_connection is not None:
+            # No need to connect, everything has been done already
+            return
+        if not self.descriptor.is_initialized():
+            raise RuntimeError("Descriptor wasn't initialized fully")
+
+        if is_backend_running(self._backend_address, self._backend_port):
+            self._logger.info("Backend already running")
+        else:
+            self._logger.info("Starting backend...")
+            start_backend(self._backend_port)
+            start = time.time()
+            while time.time() < (start + START_TIMEOUT):
+                if is_backend_running(self._backend_address, self._backend_port):
+                    self._logger.info("Backend started")
+                    break
+                time.sleep(0.1)
+            else:
+                # Backend could not start
+                self._logger.error("Could not start backend")
+
+        # Create the client to communicate with the backend
+        try:
+            self.backend_connection = Client((default_host, BACKEND_PORT))
+        except ConnectionRefusedError as err:
+            raise RuntimeError("Failed to connect to backend") from err
+        self._read_thread = threading.Thread(
+            target=self.read_thread,
+            args=(self._signal_queue, self._make_backend_request_queue),
+            daemon=True,
+        )
+        self._read_thread.start()
+
+        # Identify ourselves
+        self._make_backend_request(Action.SET_ROLE_ADAPTER)
+
+        # Set the adapter
+        self._make_backend_request(Action.SELECT_ADAPTER, str(self.descriptor))
+
+        if self.auto_open:
+            self.open()
+
+    def _make_backend_request(self, action: Action, *args: Any) -> BackendResponse:
         """
         Send a request to the backend and return the arguments
         """
 
         with self._backend_connection_lock:
-            self.backend_connection.send((action.value, *args))
+            if self.backend_connection is not None:
+                self.backend_connection.send((action.value, *args))
 
         self._make_backend_request_flag.set()
         try:
             response = self._make_backend_request_queue.get(
-                timeout=self.BACKEND_REQUEST_DEFAULT_TIMEOUT
+                timeout=BACKEND_REQUEST_DEFAULT_TIMEOUT
             )
-        except queue.Empty:
-            raise RuntimeError(f"Failed to receive response from backend to {action}")
+        except queue.Empty as err:
+            raise RuntimeError(
+                f"Failed to receive response from backend to {action}"
+            ) from err
 
         assert (
             isinstance(response, tuple) and len(response) > 0
@@ -223,23 +314,33 @@ class Adapter(ABC):
 
         return response[1:]
 
-    def read_thread(self, event_queue: queue.Queue[BackendResponse], request_queue: queue.Queue[BackendResponse]) -> None:
+    def read_thread(
+        self,
+        signal_queue: SignalQueue,
+        request_queue: queue.Queue[BackendResponse],
+    ) -> None:
         while True:
             try:
-                response : Tuple[Any,...] = self.backend_connection.recv()
+                if self.backend_connection is None:
+                    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:
                 if not isinstance(response, tuple):
                     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)
 
@@ -247,7 +348,7 @@ class Adapter(ABC):
     def _default_timeout(self) -> Timeout:
         pass
 
-    def set_timeout(self, timeout: Optional[Timeout]) -> None:
+    def set_timeout(self, timeout: Timeout | None) -> None:
         """
         Overwrite timeout
 
@@ -257,7 +358,7 @@ class Adapter(ABC):
         """
         self._timeout = timeout
 
-    def set_default_timeout(self, default_timeout: Optional[Timeout]) -> None:
+    def set_default_timeout(self, default_timeout: Timeout | None) -> None:
         """
         Set the default timeout for this adapter. If a previous timeout has been set, it will be fused
 
@@ -269,7 +370,7 @@ class Adapter(ABC):
             self._logger.debug(f"Setting default timeout to {default_timeout}")
             self._timeout = default_timeout
 
-    def set_stop_condition(self, stop_condition: Optional[StopCondition]) -> None:
+    def set_stop_conditions(self, stop_conditions: StopCondition | None | list[StopCondition]) -> None:
         """
         Overwrite the stop-condition
 
@@ -277,17 +378,16 @@ class Adapter(ABC):
         ----------
         stop_condition : StopCondition
         """
-        self._stop_condition = stop_condition
-        #payload : Optional[str]
-        if self._stop_condition is None:
-            payload = None
-        else:
-            payload = self._stop_condition.compose_json()
-        self._make_backend_request(
-            Action.SET_STOP_CONDITION, payload
-        )
+        if isinstance(stop_conditions, list):
+            self._stop_conditions = stop_conditions
+        elif isinstance(stop_conditions, StopCondition):
+            self._stop_conditions = [stop_conditions]
+        elif stop_conditions is None:
+            self._stop_conditions = []
+
+        self._make_backend_request(Action.SET_STOP_CONDITION, self._stop_conditions)
 
-    def set_default_stop_condition(self, stop_condition : StopCondition) -> None:
+    def set_default_stop_condition(self, stop_condition: StopCondition) -> None:
         """
         Set the default stop condition for this adapter.
 
@@ -296,7 +396,7 @@ class Adapter(ABC):
         stop_condition : StopCondition
         """
         if self._default_stop_condition:
-            self.set_stop_condition(stop_condition)
+            self.set_stop_conditions(stop_condition)
 
     def flushRead(self) -> None:
         """
@@ -305,6 +405,12 @@ class Adapter(ABC):
         self._make_backend_request(
             Action.FLUSHREAD,
         )
+        while True:
+            try:
+                self._signal_queue.get(block=False)
+            except queue.Empty:
+                break
+            
 
     def previous_read_buffer_empty(self) -> bool:
         """
@@ -320,14 +426,7 @@ class Adapter(ABC):
         """
         Start communication with the device
         """
-        if self._stop_condition is None:
-            payload = None
-        else:
-            payload = self._stop_condition.compose_json()
-        self._make_backend_request(
-            Action.OPEN,
-            payload
-        )
+        self._make_backend_request(Action.OPEN, self._stop_conditions)
         self._logger.info("Adapter opened")
         self.opened = True
 
@@ -335,14 +434,15 @@ 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:
-            self.backend_connection.close()
+            if self.backend_connection is not None:
+                self.backend_connection.close()
 
         self.opened = False
 
@@ -358,29 +458,13 @@ class Adapter(ABC):
         if isinstance(data, str):
             data = data.encode(self.encoding)
         self._make_backend_request(Action.WRITE, data)
-    
-    @overload
-    def read( #type: ignore (default arguments mess everything up)
-        self,
-        timeout: Union[Timeout, DefaultType, None] = DEFAULT,
-        stop_condition: Union[StopCondition, DefaultType, None] = DEFAULT,
-        full_output: Literal[True] = True,
-    ) -> Tuple[bytes, AdapterSignal]: ...
 
-    @overload
-    def read(
+    def read_detailed(
         self,
-        timeout: Union[Timeout, DefaultType, None] = DEFAULT,
-        stop_condition: Union[StopCondition, DefaultType, None] = DEFAULT,
-        full_output: Literal[False] = False,
-    ) -> bytes: ...
-    
-    def read(
-        self,
-        timeout: Union[None, Timeout, DefaultType] = DEFAULT,
-        stop_condition: Optional[Union[StopCondition, DefaultType]] = DEFAULT,
-        full_output: bool = False,
-    ) -> Union[bytes, Tuple[bytes, AdapterSignal]]:
+        timeout: Timeout | EllipsisType | None = ...,
+        stop_condition: StopCondition | EllipsisType | None = ...,
+        scope : str = ReadScope.BUFFERED.value,
+    ) -> AdapterReadPayload | None:
         """
         Read data from the device
 
@@ -390,117 +474,192 @@ class Adapter(ABC):
             Temporary timeout
         stop_condition : StopCondition
             Temporary stop condition
-        full_output : bool
-            If True, return read information as well as data
+        scope : str
+            Return previous data ('buffered') or only future data ('next')
         Returns
         -------
         data : bytes
-        metrics : dict
-            Only if full_output is True
+        signal : AdapterReadPayload
         """
-            
-        if timeout is DEFAULT:
-            read_timeout = self._timeout
+        t = time.time()
+        _scope = ReadScope(scope)
+        output_signal = None
+
+        # 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:
-            read_timeout = any_to_timeout(timeout)
+            # 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 timeout is ...:
+                read_timeout = self._timeout
+            else:
+                read_timeout = any_to_timeout(timeout)
 
-        output = None
+            if read_timeout is not None:
+                if not read_timeout.is_initialized():
+                    raise RuntimeError("Timeout needs to be initialized")
 
-        response_received = False
+                _response = read_timeout.response()
 
-        if read_timeout is None:
-            queue_timeout_timestamp = None
-        elif read_timeout.response is None:
-            queue_timeout_timestamp = None
-        else:
-            if read_timeout.response is DEFAULT:
-                raise RuntimeError('Timeout needs to be initialized')
-            
-            queue_timeout_timestamp = (
-                time.time() + read_timeout.response + self.ADDITIONNAL_RESPONSE_DELAY
-            )
+                read_init_time = time.time()
+                start_read_id = self._make_backend_request(Action.START_READ, _response)[0]
 
-        start_read_uuid = uuid.uuid1()
-        # Send a read signal to the backend
-        self._make_backend_request(
-            Action.START_READ,
-            read_timeout.response if read_timeout is not None else None,
-            start_read_uuid
-        )
+                if _response is None:
+                    # Wait indefinitely
+                    read_stop_timestamp = None
+                else:
+                    # Wait for the response time + a bit more
+                    read_stop_timestamp = read_init_time + _response
 
-        while True:
-            if queue_timeout_timestamp is None or response_received:
-                queue_timeout = None
             else:
-                queue_timeout = queue_timeout_timestamp - time.time()
-                if queue_timeout < 0:
-                    queue_timeout = 0
+                start_read_id = None
+                read_init_time = None
 
-            try:
-                response = self._event_queue.get(block=True, timeout=queue_timeout)
-                signal = response[1]
-            except queue.Empty:
-                raise RuntimeError(
-                    "Failed to receive response confirmation from backend"
-                )
-            else:
+            
+            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_received:
-                        output = signal.data()
-                        break
-                elif isinstance(signal, AdapterReadInit):
-                    #signal: AdapterReadInit = response[1]
-                    # Check if it's the right read_init with the uuid, otherwise ignore it
-                    if signal.uuid == start_read_uuid:
-                        if signal.received_response_in_time:
-                            response_received = True
-                        else:
-                            if self._timeout is None:
-                                raise RuntimeError('Failed to receive data in time but timeout is None')
-                            else:
-                                if self._timeout.action == TimeoutAction.RETURN:
-                                    output = b""
-                                    break
-                                elif self._timeout.action == TimeoutAction.ERROR:
-                                    raise TimeoutError(
-                                        f"No response received from device within {self._timeout.response} seconds"
-                                    )
+                    output_signal = signal
+                    break
                 elif isinstance(signal, AdapterDisconnected):
                     raise RuntimeError("Adapter disconnected")
+                elif isinstance(signal, AdapterResponseTimeout):
+                    if start_read_id == signal.identifier:
+                        output_signal = None
+                        break
+                    # Otherwise ignore it
+
+
+        if output_signal is None:
+            # TODO : Make read_timeout always Timeout, never None ?
+            match read_timeout.action:
+                case TimeoutAction.RETURN:
+                    return None
+                case TimeoutAction.ERROR:
+                    raise TimeoutError(
+                        f"No response received from device within {read_timeout.response()} seconds"
+                    )
+                case _:
+                    raise NotImplementedError()
+        
+        else:
+            return output_signal
+
+
+        # 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
+
+
+        # # 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
+
+        # 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
+
+        # output_signal : AdapterReadPayload | None
+        # # This delay is given by the backend when a fragment is received. It basically says
+        # # "I've received something, wait at most x seconds before raising an error"
+        # read_init_end_delay : float | None = None
+
+        # # Ready to read payloads
+        # while True:
+        #     if read_init_end_delay is not None:
+        #         # Find the next timeout
+        #         queue_timeout = read_init_end_delay + 0.1 # TODO : Make this clean, this is the delay to let data arrive to the frontend
+        #     elif queue_timeout_timestamp is None:
+        #         queue_timeout = None
+        #     else:
+        #         queue_timeout = queue_timeout_timestamp - time.time()
+        #         if queue_timeout < 0:
+        #             queue_timeout = 0
+
+        #     try:
+        #         response = self._signal_queue.peek(block=True, timeout=queue_timeout)
+        #         signal = response[1]
+
+        #         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._signal_queue.get()
+        #                 continue
+
+        #             if response_delay is not None:
+        #                 if signal.response_timestamp - backend_read_start_time > response_delay:
+        #                     self._signal_queue.get()
+        #                     output_signal = None
+        #                     break
+                    
+        #             # Other wise the payload is valid
+        #             self._signal_queue.get()
+        #             output_signal = signal
+        #             break
+        #         elif isinstance(signal, AdapterReadInit):
+        #             read_init_end_delay = signal.end_delay
+        #             self._signal_queue.get()
+        #         elif isinstance(signal, AdapterDisconnected):
+        #             self._signal_queue.get()
+                    
+
+        #     except queue.Empty:
+        #         output_signal = None
+        #         break
 
-        if full_output:
-            return output, signal
+    def read(
+        self,
+        timeout: Timeout | EllipsisType | None = ...,
+        stop_condition: StopCondition | EllipsisType | None = ...,
+    ) -> bytes:
+        signal = self.read_detailed(timeout=timeout, stop_condition=stop_condition)
+        if signal is None:
+            return None
         else:
-            return output
+            return signal.data()
 
     def _cleanup(self) -> None:
         if self._init_ok and self.opened:
             self.close()
 
-    @overload
-    def query(
-        self,
-        data: Union[bytes, str],
-        timeout: Optional[Union[Timeout, DefaultType]] = DEFAULT,
-        stop_condition: Optional[Union[StopCondition, DefaultType]] = DEFAULT,
-        full_output: Literal[True] = True,
-    ) -> Tuple[bytes, AdapterSignal]: ...
-    @overload
-    def query(
-        self,
-        data: Union[bytes, str],
-        timeout: Optional[Union[Timeout, DefaultType]] = DEFAULT,
-        stop_condition: Optional[Union[StopCondition, DefaultType]] = DEFAULT,
-        full_output: Literal[False] = False,
-    ) -> bytes: ...
-    
-    def query(
+    def query_detailed(
         self,
-        data: Union[bytes, str],
-        timeout: Optional[Union[Timeout, DefaultType]] = DEFAULT,
-        stop_condition: Optional[Union[StopCondition, DefaultType]] = DEFAULT,
-        full_output: bool = False,
-    ) -> Union[bytes, Tuple[bytes, AdapterSignal]]:
+        data: bytes | str,
+        timeout: Timeout | EllipsisType | None = ...,
+        stop_condition: StopCondition | EllipsisType | None = ...,
+    ) -> tuple[bytes, AdapterReadPayload | None]:
         """
         Shortcut function that combines
         - flush_read
@@ -509,16 +668,23 @@ class Adapter(ABC):
         """
         self.flushRead()
         self.write(data)
-        output, signal = self.read(
-            timeout=timeout, stop_condition=stop_condition, full_output=True
-        )
+        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)
 
-        if full_output:
-            return output, signal
+    def query(
+        self,
+        data: bytes | str,
+        timeout: Timeout | EllipsisType | None = ...,
+        stop_condition: StopCondition | EllipsisType | None = ...,
+    ) -> bytes:
+        signal = self.query_detailed(
+            data=data, timeout=timeout, stop_condition=stop_condition
+        )
+        if signal is None:
+            return None
         else:
-            return output
+            return signal.data()
 
-    def set_event_callback(self, callback : Callable[[AdapterSignal], None]) -> None:
+    def set_event_callback(self, callback: Callable[[AdapterSignal], None]) -> None:
         self.event_callback = callback
 
     def __str__(self) -> str: