syndesi 0.4.0__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,42 +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, 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
@@ -69,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)
@@ -93,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
 
@@ -121,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
 
@@ -137,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__(
@@ -214,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
@@ -334,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]
@@ -370,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
 
@@ -385,7 +392,7 @@ class Adapter(ABC):
         elif stop_conditions is None:
             self._stop_conditions = []
 
-        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:
         """
@@ -410,7 +417,6 @@ class Adapter(ABC):
                 self._signal_queue.get(block=False)
             except queue.Empty:
                 break
-            
 
     def previous_read_buffer_empty(self) -> bool:
         """
@@ -462,9 +468,9 @@ class Adapter(ABC):
     def read_detailed(
         self,
         timeout: Timeout | EllipsisType | None = ...,
-        stop_condition: StopCondition | EllipsisType | None = ...,
-        scope : str = ReadScope.BUFFERED.value,
-    ) -> AdapterReadPayload | None:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+        scope: str = ReadScope.BUFFERED.value,
+    ) -> AdapterReadPayload:
         """
         Read data from the device
 
@@ -481,9 +487,22 @@ class Adapter(ABC):
         data : bytes
         signal : AdapterReadPayload
         """
-        t = time.time()
         _scope = ReadScope(scope)
         output_signal = None
+        read_timeout = None
+
+        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():
@@ -495,42 +514,37 @@ class Adapter(ABC):
         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 timeout is ...:
-                read_timeout = self._timeout
-            else:
-                read_timeout = any_to_timeout(timeout)
 
-            if read_timeout is not None:
-                if not read_timeout.is_initialized():
-                    raise RuntimeError("Timeout needs to be initialized")
+            if not read_timeout.is_initialized():
+                raise RuntimeError("Timeout needs to be initialized")
 
-                _response = read_timeout.response()
+            _response = read_timeout.response()
 
-                read_init_time = time.time()
-                start_read_id = self._make_backend_request(Action.START_READ, _response)[0]
-
-                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
+            read_init_time = time.time()
+            start_read_id = self._make_backend_request(Action.START_READ, _response)[0]
 
+            if _response is None:
+                # Wait indefinitely
+                read_stop_timestamp = None
             else:
-                start_read_id = None
-                read_init_time = None
+                # Wait for the response time + a bit more
+                read_stop_timestamp = read_init_time + _response
 
-            
             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
@@ -542,113 +556,35 @@ class Adapter(ABC):
                         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.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()
-        
+
         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
-
     def read(
         self,
         timeout: Timeout | EllipsisType | None = ...,
-        stop_condition: StopCondition | EllipsisType | None = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
     ) -> bytes:
-        signal = self.read_detailed(timeout=timeout, stop_condition=stop_condition)
-        if signal is None:
-            return None
-        else:
-            return signal.data()
+        signal = self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        return signal.data()
 
     def _cleanup(self) -> None:
         if self._init_ok and self.opened:
@@ -658,8 +594,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
@@ -668,21 +604,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:
         signal = self.query_detailed(
-            data=data, timeout=timeout, stop_condition=stop_condition
+            data=data, timeout=timeout, stop_conditions=stop_conditions
         )
-        if signal is None:
-            return None
-        else:
-            return signal.data()
+        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)

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([])
 
@@ -260,11 +260,13 @@ class AdapterBackend(ABC):
         else:
             fragment_delta_t = float("nan")
         if fragment.data == b"":
-            self._logger.debug('Empty data -> close')
             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()
 
@@ -273,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
 
@@ -288,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)
 
@@ -304,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,
@@ -319,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:
@@ -342,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:
@@ -367,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
@@ -377,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:
@@ -389,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)
@@ -403,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