syndesi 0.3.2__tar.gz → 0.4.0__tar.gz

{syndesi-0.3.2/syndesi.egg-info → syndesi-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syndesi
-Version: 0.3.2
+Version: 0.4.0
 Summary: Syndesi
 Author-email: Sébastien Deriaz <sebastien.deriaz1@gmail.com>
 License: GPL
@@ -17,6 +17,7 @@ License-File: LICENSE
 Requires-Dist: prompt_toolkit
 Requires-Dist: pyserial
 Requires-Dist: rich
+Requires-Dist: platformdirs
 Dynamic: license-file
 
 # Syndesi Python Implementation

{syndesi-0.3.2 → syndesi-0.4.0}/pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
     "Operating System :: MacOS :: MacOS X",
     "Operating System :: Microsoft :: Windows",
 ]
-dependencies = ['prompt_toolkit', 'pyserial', 'rich']
+dependencies = ['prompt_toolkit', 'pyserial', 'rich', 'platformdirs']
 
 #[project.optional-dependencies]
 #extra = [""]

{syndesi-0.3.2 → syndesi-0.4.0}/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
@@ -39,71 +38,49 @@ from ..tools.backend_api import (
     Action,
     BackendResponse,
     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, 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
+class SignalQueue(queue.Queue[AdapterSignal]):
+    def __init__(self) -> None:
+        self._read_payload_counter = 0
+        super().__init__(0)
 
-T = TypeVar("T")
+    def has_read_payload(self) -> bool:
+        return self._read_payload_counter > 0
 
-class PeekQueue(queue.Queue, Generic[T]):
-    def peek(self, block: bool = True, timeout: float | None = None) -> T:
-        """
-        Return (without removing) the head item.
 
-        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 +105,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 +130,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 +146,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 +172,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 +180,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 +203,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 +274,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 +316,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 +325,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 +333,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 +370,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,10 +385,6 @@ 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)
 
     def set_default_stop_condition(self, stop_condition: StopCondition) -> None:
@@ -442,7 +407,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 +434,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:
@@ -499,7 +464,7 @@ class Adapter(ABC):
         timeout: Timeout | EllipsisType | None = ...,
         stop_condition: StopCondition | EllipsisType | None = ...,
         scope : str = ReadScope.BUFFERED.value,
-    ) -> tuple[bytes, AdapterReadPayload | None]:
+    ) -> AdapterReadPayload | None:
         """
         Read data from the device
 
@@ -516,111 +481,174 @@ class Adapter(ABC):
         data : bytes
         signal : AdapterReadPayload
         """
+        t = time.time()
         _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
 
-        # 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
+        # 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)
 
-        if read_timeout is not None:
-            if not read_timeout.is_initialized():
-                raise RuntimeError("Timeout needs to be initialized")
+            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
+                _response = read_timeout.response()
 
-        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
+                read_init_time = time.time()
+                start_read_id = self._make_backend_request(Action.START_READ, _response)[0]
 
-        output_signal : AdapterReadPayload | None
+                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
 
-        # Ready to read payloads
-        while True:
-            if 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._event_queue.peek(block=True, timeout=queue_timeout)
-                signal = response[1]
+                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 = 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 _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
+        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
 
-                elif isinstance(signal, AdapterDisconnected):
-                    self._event_queue.get()
-                    raise RuntimeError("Adapter disconnected")
 
-            except queue.Empty:
-                output_signal = None
-                break    
+        # 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 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
+        # If not timeout is specified, use the default one
 
-        
-        return data, output_signal
+        # 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 = ...,
     ) -> bytes:
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)[0]
+        signal = self.read_detailed(timeout=timeout, stop_condition=stop_condition)
+        if signal is None:
+            return None
+        else:
+            return signal.data()
 
     def _cleanup(self) -> None:
         if self._init_ok and self.opened:
@@ -648,9 +676,13 @@ class Adapter(ABC):
         timeout: Timeout | EllipsisType | None = ...,
         stop_condition: StopCondition | EllipsisType | None = ...,
     ) -> bytes:
-        return self.query_detailed(
+        signal = self.query_detailed(
             data=data, timeout=timeout, stop_condition=stop_condition
-        )[0]
+        )
+        if signal is None:
+            return None
+        else:
+            return signal.data()
 
     def set_event_callback(self, callback: Callable[[AdapterSignal], None]) -> None:
         self.event_callback = callback