syndesi 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

syndesi/adapters/adapter.py

@@ -93,11 +93,12 @@ class Adapter(Component[bytes], AdapterWorker):
         event_callback: Callable[[AdapterEvent], None] | None = None,
         auto_open: bool = True,
     ) -> None:
-        super().__init__(LoggerAlias.ADAPTER)
-        self.encoding = encoding
+        Component.__init__(self, LoggerAlias.ADAPTER)
+        AdapterWorker.__init__(self, encoding)
+
         self._alias = alias
 
-        self.descriptor = descriptor
+        self._descriptor = descriptor
         self.auto_open = auto_open
 
         self._initial_event_callback = event_callback
@@ -141,22 +142,33 @@ class Adapter(Component[bytes], AdapterWorker):
         # Serialize read/write/query ordering for async callers.
         self._async_io_lock = asyncio.Lock()
 
-        self._logger.info(f"Setting up {self.descriptor} adapter ")
+        self._logger.info(f"Setting up {self._descriptor} adapter ")
         self._update_descriptor()
         self.set_stop_conditions(self._initial_stop_conditions)
         self.set_timeout(self._initial_timeout)
         self.set_event_callback(self._initial_event_callback)
 
-        if self.descriptor.is_initialized() and auto_open:
+        if self._descriptor.is_initialized() and auto_open:
             self.open()
 
         weakref.finalize(self, self._cleanup)
 
+    def get_descriptor(self) -> Descriptor:
+        """
+        Return the adapter's descriptor
+
+        Returns
+        -------
+        descriptor : Descriptor
+        """
+        return self._descriptor
+
     # ┌──────────────────────────┐
     # │ Defaults / configuration │
     # └──────────────────────────┘
 
     def _stop(self) -> None:
+        super()._stop()
         cmd = StopThreadCommand()
         self._worker_send_command(cmd)
         try:
@@ -165,7 +177,7 @@ class Adapter(Component[bytes], AdapterWorker):
             pass
 
     def _update_descriptor(self) -> None:
-        cmd = SetDescriptorCommand(self.descriptor)
+        cmd = SetDescriptorCommand(self._descriptor)
         self._worker_send_command(cmd)
         cmd.result(self.WorkerTimeout.IMMEDIATE_COMMAND.value)
 
@@ -178,27 +190,19 @@ class Adapter(Component[bytes], AdapterWorker):
         raise NotImplementedError
 
     def __str__(self) -> str:
-        return str(self.descriptor)
+        return str(self._descriptor)
 
     def __repr__(self) -> str:
         return self.__str__()
 
     def _cleanup(self) -> None:
-        # Be defensive: finalizers can run at interpreter shutdown.
         try:
             if self.is_open():
                 self.close()
         except AdapterError:
             pass
-
         self._stop()
 
-        try:
-            self._command_queue_r.close()
-            self._command_queue_w.close()
-        except AdapterError:
-            pass
-
     # ┌────────────┐
     # │ Public API │
     # └────────────┘
@@ -344,9 +348,10 @@ class Adapter(Component[bytes], AdapterWorker):
         scope: str = ReadScope.BUFFERED.value,
     ) -> AdapterFrame:
         with self._sync_io_lock:
-            return self._read_detailed_future(
+            result = self._read_detailed_future(
                 timeout=timeout, stop_conditions=stop_conditions, scope=scope
             ).result(self.WorkerTimeout.READ.value)
+        return result
 
     async def aread_detailed(
         self,
@@ -433,10 +438,12 @@ class Adapter(Component[bytes], AdapterWorker):
         scope: str = ReadScope.BUFFERED.value,
     ) -> AdapterFrame:
         async with self._async_io_lock:
-            await self.aflush_read()
-            await self.awrite(payload)
-            return await self.aread_detailed(
-                timeout=timeout, stop_conditions=stop_conditions, scope=scope
+            await asyncio.wrap_future(self._flush_read_future())
+            await asyncio.wrap_future(self._write_future(payload))
+            return await asyncio.wrap_future(
+                self._read_detailed_future(
+                    timeout=timeout, stop_conditions=stop_conditions, scope=scope
+                )
             )
 
     def query_detailed(
@@ -448,11 +455,12 @@ class Adapter(Component[bytes], AdapterWorker):
     ) -> AdapterFrame:
 
         with self._sync_io_lock:
-            self.flush_read()
-            self.write(payload)
-            return self.read_detailed(
+            self._flush_read_future().result(self.WorkerTimeout.IMMEDIATE_COMMAND.value)
+            self._write_future(payload).result(self.WorkerTimeout.WRITE.value)
+            output = self._read_detailed_future(
                 timeout=timeout, stop_conditions=stop_conditions, scope=scope
-            )
+            ).result(self.WorkerTimeout.READ.value)
+        return output
 
     # ==== Other ====
 

syndesi/adapters/adapter_worker.py

@@ -38,6 +38,7 @@ from .stop_conditions import (
     Total,
 )
 from .timeout import Timeout, TimeoutAction, any_to_timeout
+from .tracehub import tracehub
 
 
 def nmin(a: float | None, b: float | None) -> float | None:
@@ -71,22 +72,18 @@ class HasFileno(Protocol):
 # │ Adapter events │
 # └────────────────┘
 
-
 class AdapterEvent(Event):
     """Adapter event"""
 
-
 class AdapterDisconnectedEvent(AdapterEvent):
     """Adapter disconnected event"""
 
-
 @dataclass
 class AdapterFrameEvent(AdapterEvent):
     """Adapter frame event, emitted when new data is available"""
 
     frame: AdapterFrame
 
-
 @dataclass
 class FirstFragmentEvent(AdapterEvent):
     """Adapter first fragment event"""
@@ -238,7 +235,8 @@ class AdapterWorker:
     _FRAME_BUFFER_MAX = 256
     _COMMAND_READY = b"\x00"
 
-    def __init__(self) -> None:
+    def __init__(self, encoding : str) -> None:
+        self.encoding = encoding
         # Command queue (worker input)
         self._command_queue_r, self._command_queue_w = socket.socketpair()
         self._command_queue_r.setblocking(False)
@@ -270,12 +268,16 @@ class AdapterWorker:
         self._first_fragment_timestamp: float | None = None
         self._last_fragment_timestamp: float | None = None
         self._last_write_timestamp: float | None = None
-        self._timeout_origin: StopConditionType | None = None
+        self._timeout_origin: StopConditionType  = StopConditionType.TIMEOUT
         self._next_stop_condition_timeout_timestamp: float | None = None
         self._read_start_timestamp: float | None = None
 
         self._event_callback: Callable[[AdapterEvent], None] | None = None
 
+    def _stop(self) -> None:
+        self._command_queue_r.close()
+        self._command_queue_w.close()
+
     # ┌─────────────────┐
     # │ Worker plumbing │
     # └─────────────────┘
@@ -323,12 +325,18 @@ class AdapterWorker:
             self._worker_open()
             if not self._opened:
                 raise AdapterWriteError("Adapter not opened")
+        if self._worker_descriptor is not None:
+            tracehub.emit_write(str(self._worker_descriptor), data)
 
     @abstractmethod
-    def _worker_open(self) -> None: ...
+    def _worker_open(self) -> None:
+        if self._worker_descriptor is not None:
+            tracehub.emit_open(str(self._worker_descriptor))
 
     @abstractmethod
-    def _worker_close(self) -> None: ...
+    def _worker_close(self) -> None:
+        if self._worker_descriptor is not None:
+            tracehub.emit_close(str(self._worker_descriptor))
 
     # ┌──────────────────────────┐
     # │ Worker: command handling │
@@ -469,6 +477,9 @@ class AdapterWorker:
         - always emit callback event (if configured)
         """
         self._worker_emit_event(AdapterFrameEvent(frame))
+        if self._worker_descriptor is not None:
+            payload = frame.get_payload()
+            tracehub.emit_read(str(self._worker_descriptor), payload, frame.stop_condition_type)
 
         pr = self._pending_read
         if pr is not None:
@@ -516,7 +527,7 @@ class AdapterWorker:
                     AdapterFrame(
                         fragments=[Fragment(b"", time.time())],
                         stop_timestamp=None,
-                        stop_condition_type=None,
+                        stop_condition_type=StopConditionType.TIMEOUT,
                         previous_read_buffer_used=False,
                         response_delay=None,
                     )
@@ -640,7 +651,13 @@ class AdapterWorker:
 
             self.fragments.append(kept)
 
+            # If there's no stop, break here
             if stop_condition_type is None:
+                # Only upload emit a fragment event if there's no frame
+                if self._worker_descriptor is not None:
+                    tracehub.emit_fragment(str(self._worker_descriptor), kept.data)
+
+
                 break
 
             # frame complete
@@ -708,7 +725,7 @@ class AdapterWorker:
         self._last_write_timestamp = None
         self.fragments = []
         self._next_stop_condition_timeout_timestamp = None
-        self._timeout_origin = None
+        self._timeout_origin = StopConditionType.TIMEOUT
 
     def _worker_next_timeout_timestamp(self) -> float | None:
         stop_conditions = self._stop_conditions
@@ -803,6 +820,7 @@ class AdapterWorker:
 
             # Timeout wakeup: decide what timed out
             # 1) pending read response timeout (before qualifying first fragment)
+            print('Pending read')
             if (
                 self._pending_read is not None
                 and not self._pending_read.first_fragment_seen

syndesi/adapters/ip.py

@@ -10,9 +10,6 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from enum import StrEnum
 from types import EllipsisType
-from typing import cast
-
-import _socket
 
 from syndesi.adapters.adapter_worker import AdapterEvent, HasFileno
 from syndesi.adapters.stop_conditions import Continuation, StopCondition
@@ -142,7 +139,8 @@ class IP(Adapter):
             port=port,
             transport=IPDescriptor.Transport(transport.upper()),
         )
-        self._socket: _socket.socket | None = None
+        #self._socket: _socket.socket | None = None
+        self._socket : socket.socket | None = None
 
         super().__init__(
             descriptor=descriptor,
@@ -194,21 +192,16 @@ class IP(Adapter):
                 )
 
     def _worker_open(self) -> None:
+        super()._worker_open()
         self._worker_check_descriptor()
 
         # Create the socket instance
         if self._worker_descriptor.transport == IPDescriptor.Transport.TCP:
-            self._socket = cast(
-                _socket.socket,
-                socket.socket(socket.AF_INET, socket.SOCK_STREAM),
-            )
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         elif self._worker_descriptor.transport == IPDescriptor.Transport.UDP:
-            self._socket = cast(
-                _socket.socket, socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            )
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         else:
             raise AdapterOpenError("Invalid transport protocol")
-
         try:
             self._socket.settimeout(self.WorkerTimeout.OPEN.value)
             self._socket.connect(
@@ -224,9 +217,10 @@ class IP(Adapter):
         self._logger.info(f"IP Adapter {self._worker_descriptor} opened")
 
     def _worker_close(self) -> None:
+        super()._worker_close()
         if self._socket is not None:
             try:
-                self._socket.shutdown(_socket.SHUT_RDWR)
+                self._socket.shutdown(socket.SHUT_RDWR)
                 self._socket.close()
             except OSError:
                 pass

syndesi/adapters/serialport.py

@@ -8,8 +8,10 @@ the OS layers (COMx, /dev/ttyUSBx or /dev/ttyACMx)
 
 """
 
+import threading
 from collections.abc import Callable
 from dataclasses import dataclass
+from enum import StrEnum
 from types import EllipsisType
 
 import serial
@@ -25,6 +27,18 @@ from .stop_conditions import Continuation, Fragment, StopCondition
 from .timeout import Timeout
 
 
+class Parity(StrEnum):
+    """
+    SerialPort parity setting, copied from pyserial
+    """
+    NONE = "N"
+    EVEN = "E"
+    ODD = "O"
+    MARK = "M"
+    SPACE = "S"
+
+
+# pylint: disable=too-many-instance-attributes
 @dataclass
 class SerialPortDescriptor(Descriptor):
     """
@@ -34,6 +48,12 @@ class SerialPortDescriptor(Descriptor):
     DETECTION_PATTERN = r"(COM\d+|/dev[/\w\d]+):\d+"
     port: str
     baudrate: int | None = None
+    bytesize: int = 8
+    stopbits: int = 1
+    parity: str = Parity.NONE.value
+    rts_cts: bool = False
+    dsr_dtr: bool = False
+    xon_xoff: bool = False
 
     @staticmethod
     def from_string(string: str) -> "SerialPortDescriptor":
@@ -50,7 +70,7 @@ class SerialPortDescriptor(Descriptor):
         ----------
         baudrate : int
         """
-        if self.baudrate is not None:
+        if self.baudrate is None:
             self.baudrate = baudrate
             return True
 
@@ -75,6 +95,9 @@ class SerialPort(Adapter):
         Baudrate
     """
 
+    _open_ports: set[str] = set()
+    _open_ports_lock = threading.Lock()
+
     def __init__(
         self,
         port: str,
@@ -83,14 +106,29 @@ class SerialPort(Adapter):
         timeout: Timeout | NumberLike | None | EllipsisType = ...,
         stop_conditions: StopCondition | list[StopCondition] | EllipsisType = ...,
         alias: str = "",
-        rts_cts: bool = False,  # rts_cts experimental
+        bytesize: int = 8,
+        stopbits: int = 1,
+        parity: str = Parity.NONE.value,
+        rts_cts: bool = False,
+        xon_xoff: bool = False,
+        dsr_dtr: bool = False,
         event_callback: Callable[[AdapterEvent], None] | None = None,
         auto_open: bool = True,
     ) -> None:
         """
         Instanciate new SerialPort adapter
         """
-        descriptor = SerialPortDescriptor(port, baudrate)
+        self._port: serial.Serial | None = None
+        descriptor = SerialPortDescriptor(
+            port=port,
+            baudrate=baudrate,
+            bytesize=bytesize,
+            stopbits=stopbits,
+            parity=parity,
+            rts_cts=rts_cts,
+            dsr_dtr=dsr_dtr,
+            xon_xoff=xon_xoff,
+        )
         super().__init__(
             descriptor=descriptor,
             timeout=timeout,
@@ -107,11 +145,11 @@ class SerialPort(Adapter):
                 timeout={timeout} and stop_conditions={self._stop_conditions}"
         )
 
-        self._port: serial.Serial | None = None
-
-        self.open()
-
-        self._rts_cts = rts_cts
+        # self._bytesize = bytesize
+        # self._stopbits = stopbits
+        # self._parity = Parity(parity)
+        # self._xonxoff = xon_xoff
+        # self._dsrdtr = dsr_dtr
 
     def _default_timeout(self) -> Timeout:
         return Timeout(response=2, action="error")
@@ -120,6 +158,7 @@ class SerialPort(Adapter):
         return [Continuation(0.1)]
 
     def _worker_open(self) -> None:
+        super()._worker_open()
         self._worker_check_descriptor()
 
         if self._worker_descriptor.baudrate is None:
@@ -130,13 +169,26 @@ class SerialPort(Adapter):
         if self._port is not None:
             self.close()
 
+        port_name = self._worker_descriptor.port
+        with self._open_ports_lock:
+            if port_name in self._open_ports:
+                raise AdapterOpenError(f"Port '{port_name}' is already in use")
+            self._open_ports.add(port_name)
+
         try:
             self._port = serial.Serial(
                 port=self._worker_descriptor.port,
                 baudrate=self._worker_descriptor.baudrate,
-                rtscts=self._rts_cts,
+                rtscts=self._worker_descriptor.rts_cts,
+                bytesize=self._worker_descriptor.bytesize,
+                parity=self._worker_descriptor.parity,
+                stopbits=self._worker_descriptor.stopbits,
+                xonxoff=self._worker_descriptor.xon_xoff,
+                dsrdtr=self._worker_descriptor.dsr_dtr
             )
         except serial.SerialException as e:
+            with self._open_ports_lock:
+                self._open_ports.discard(port_name)
             if "No such file" in str(e):
                 raise AdapterOpenError(
                     f"Port '{self._worker_descriptor.port}' was not found"
@@ -146,13 +198,19 @@ class SerialPort(Adapter):
         if self._port.isOpen():  # type: ignore
             self._logger.info(f"Adapter {self._worker_descriptor} opened")
         else:
+            with self._open_ports_lock:
+                self._open_ports.discard(port_name)
             self._logger.error(f"Failed to open adapter {self._worker_descriptor}")
             raise AdapterOpenError("Unknown error")
 
     def _worker_close(self) -> None:
+        super()._worker_close()
         if self._port is not None:
             self._port.close()
             self._logger.info(f"Adapter {self._worker_descriptor} closed")
+            self._port = None
+            with self._open_ports_lock:
+                self._open_ports.discard(self._worker_descriptor.port)
 
     async def aflush_read(self) -> None:
         await super().aflush_read()
@@ -173,7 +231,8 @@ class SerialPort(Adapter):
             self.open()
 
     def _worker_write(self, data: bytes) -> None:
-        if self._rts_cts:  # Experimental
+        super()._worker_write(data)
+        if self._worker_descriptor.rts_cts:  # Experimental
             self._port.setRTS(True)  # type: ignore
         if self._port is not None:
             try:
@@ -188,10 +247,9 @@ class SerialPort(Adapter):
         try:
             data = self._port.read_all()
         except (OSError, PortNotOpenError):
-            self._logger.debug('Port error -> b""')
             data = None
 
-        if data is None or data != b"":
+        if data is None or data == b"":
             raise AdapterReadError(
                 f"Error while reading from {self._worker_descriptor}"
             )

syndesi/adapters/stop_conditions.py

@@ -39,12 +39,12 @@ class StopConditionType(Enum):
     """
     Stop-condition type
     """
-
     TERMINATION = "termination"
     LENGTH = "length"
     CONTINUATION = "continuation"
     TOTAL = "total"
     FRAGMENT = "fragment"
+    TIMEOUT = "timeout"
 
 
 class StopCondition:
@@ -98,21 +98,13 @@ class Termination(StopCondition):
             self._sequence = sequence.encode("utf-8")
         else:
             self._sequence = sequence
-        self._sequence_found_length = 0
-
-    # TYPE = StopConditionType.TERMINATION
 
-    # def __init__(self, sequence: bytes | str) -> None:
-    #     """
-    #     Instanciate a new Termination class
-    #     """
-    #     self.sequence: bytes
-    #     if isinstance(sequence, str):
-    #         self.sequence = sequence.encode("utf-8")
-    #     elif isinstance(sequence, bytes):
-    #         self.sequence = sequence
-    #     else:
-    #         raise ValueError(f"Invalid termination sequence type : {type(sequence)}")
+        if self._sequence == b"":
+            raise ValueError(
+                "Empty termination isn't allowed. If you wish "
+                "to stop on any received data, use Datagram stop-conditions instead"
+            )
+        self._sequence_found_length = 0
 
     def __str__(self) -> str:
         return f"Termination({repr(self._sequence)})"
@@ -202,7 +194,6 @@ class Length(StopCondition):
         deferred_fragment = raw_fragment[remaining_bytes:]
         self._counter += len(kept_fragment.data)
         remaining_bytes = self._n - self._counter
-        # TODO : remaining_bytes <= 0 ? Alongside above TODO maybe
         return remaining_bytes == 0, kept_fragment, deferred_fragment, None
 
 
@@ -250,6 +241,8 @@ class Continuation(StopCondition):
             stop = False
             next_event_timeout = None
 
+        self._last_fragment = raw_fragment.timestamp
+
         return stop, kept, deferred, next_event_timeout
 
     def type(self) -> StopConditionType:

syndesi/adapters/timeout.py

@@ -17,12 +17,10 @@ class TimeoutAction(Enum):
     """
     Action on timeout expiration
     """
-
     ERROR = "error"
     RETURN_EMPTY = "return_empty"
     RETURN_NONE = "return_none"
 
-
 class Timeout:
     """
     This class holds timeout information
@@ -60,7 +58,7 @@ class Timeout:
         self._response: EllipsisType | NumberLike | None = response
 
     def __str__(self) -> str:
-        if self._response is ...:
+        if self._response is ... or self._response is None:
             r = "..."
         else:
             r = f"{self._response:.3f}"