syndesi 0.4.0__tar.gz → 0.4.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syndesi
-Version: 0.4.0
+Version: 0.4.1
 Summary: Syndesi
 Author-email: Sébastien Deriaz <sebastien.deriaz1@gmail.com>
 License: GPL

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/adapters/adapter.py

@@ -37,6 +37,7 @@ from ..tools.backend_api import (
     BACKEND_PORT,
     Action,
     BackendResponse,
+    Fragment,
     default_host,
     raise_if_error,
     EXTRA_BUFFER_RESPONSE_TIME
@@ -49,7 +50,7 @@ from .backend.adapter_backend import (
     AdapterSignal,
 )
 from .backend.descriptors import Descriptor
-from .stop_condition import StopCondition, Continuation, Total
+from .stop_condition import StopCondition, Continuation, StopConditionType, Total
 from .timeout import Timeout, TimeoutAction, any_to_timeout
 
 DEFAULT_STOP_CONDITION = Continuation(time=0.1)
@@ -385,7 +386,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:
         """
@@ -462,9 +463,9 @@ class Adapter(ABC):
     def read_detailed(
         self,
         timeout: Timeout | EllipsisType | None = ...,
-        stop_condition: StopCondition | EllipsisType | None = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
         scope : str = ReadScope.BUFFERED.value,
-    ) -> AdapterReadPayload | None:
+    ) -> AdapterReadPayload:
         """
         Read data from the device
 
@@ -481,9 +482,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,30 +509,25 @@ 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
+
+            # else:
+            #     start_read_id = None
+            #     read_init_time = None
 
             
             while True:
@@ -542,12 +551,19 @@ 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"
@@ -558,97 +574,13 @@ class Adapter(ABC):
         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 +590,8 @@ class Adapter(ABC):
         self,
         data: bytes | str,
         timeout: Timeout | EllipsisType | None = ...,
-        stop_condition: StopCondition | EllipsisType | None = ...,
-    ) -> tuple[bytes, AdapterReadPayload | None]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> AdapterReadPayload:
         """
         Shortcut function that combines
         - flush_read
@@ -668,21 +600,18 @@ class Adapter(ABC):
         """
         self.flushRead()
         self.write(data)
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)
+        return self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
 
     def query(
         self,
         data: bytes | str,
         timeout: Timeout | EllipsisType | None = ...,
-        stop_condition: StopCondition | EllipsisType | None = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
     ) -> bytes:
         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-0.4.0 → syndesi-0.4.1}/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-0.4.0 → syndesi-0.4.1}/syndesi/adapters/backend/adapter_backend.py

@@ -260,7 +260,6 @@ class AdapterBackend(ABC):
         else:
             fragment_delta_t = float("nan")
         if fragment.data == b"":
-            self._logger.debug('Empty data -> close')
             self.close()
             yield AdapterDisconnected()
         else:

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/adapters/backend/adapter_session.py

@@ -301,12 +301,12 @@ class AdapterSession(threading.Thread):
                                 self._logger.error("Could not write, adapter is closed")
                         case Action.PING:
                             response_action, extra_arguments = Action.PING, ()
-                        case Action.SET_STOP_CONDITION:
+                        case Action.SET_STOP_CONDITIONs:
                             self._adapter.set_stop_conditions([
                                 stop_condition_to_backend(sc) for sc in request[1]
                                 ])
                             response_action, extra_arguments = (
-                                Action.SET_STOP_CONDITION,
+                                Action.SET_STOP_CONDITIONs,
                                 (),
                             )
                         case Action.FLUSHREAD:

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/adapters/backend/descriptors.py

@@ -69,8 +69,9 @@ class IPDescriptor(Descriptor):
 
     DETECTION_PATTERN = r"(\d+.\d+.\d+.\d+|[\w\.]+):\d+:(UDP|TCP)"
     address: str
+    transport: Transport
     port: int | None = None
-    transport: Transport | None = None
+    #transport: Transport | None = None
 
     @staticmethod
     def from_string(string: str) -> "IPDescriptor":
@@ -78,7 +79,7 @@ class IPDescriptor(Descriptor):
         address = parts[0]
         port = int(parts[1])
         transport = IPDescriptor.Transport(parts[2])
-        return IPDescriptor(address, port, transport)
+        return IPDescriptor(address, transport, port)
 
     def __str__(self) -> str:
         return f"{self.address}:{self.port}:{self.Transport(self.transport).value}"

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/adapters/backend/ip_backend.py

@@ -140,6 +140,7 @@ class IPBackend(AdapterBackend):
 
             if fragment.data == b"":
                 # Socket disconnected
+                self._logger.debug('## Socket disconnected')
                 self.close()
 
         return fragment

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/adapters/backend/serialport_backend.py

@@ -6,7 +6,7 @@
 
 import time
 
-import serial  # type: ignore
+import serial
 from serial.serialutil import PortNotOpenError
 
 from syndesi.tools.backend_api import AdapterBackendStatus, Fragment
@@ -83,10 +83,10 @@ class SerialPortBackend(AdapterBackend):
                 baudrate=self.descriptor.baudrate,
                 rtscts=self._rts_cts,
             )
-        elif not self._port.isOpen():
+        elif not self._port.isOpen(): # type: ignore
             self._port.open()
 
-        if self._port.isOpen():
+        if self._port.isOpen(): # type: ignore
             self._logger.info(f"Adapter {self.descriptor} opened")
             self._status = AdapterBackendStatus.CONNECTED
             return True
@@ -112,7 +112,7 @@ class SerialPortBackend(AdapterBackend):
             return False
         else:
             if self._rts_cts:  # Experimental
-                self._port.setRTS(True)  # type : ignore
+                self._port.setRTS(True)  # type: ignore
             # TODO : Implement auto open
             # if self._status == AdapterBackendStatus.DISCONNECTED:
             #     self.open()
@@ -230,7 +230,7 @@ class SerialPortBackend(AdapterBackend):
 
     def is_opened(self) -> bool:
         if self._port is not None:
-            if self._port.isOpen():  # type : ignore
+            if self._port.isOpen():  # type: ignore
                 return True
 
         return False

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/adapters/backend/visa_backend.py

@@ -24,14 +24,14 @@ from .descriptors import VisaDescriptor
 
 # --- Typing-only imports so mypy knows pyvisa symbols without requiring it at runtime
 if TYPE_CHECKING:
-    import pyvisa
-    from pyvisa.resources import Resource
+    import pyvisa # type: ignore
+    from pyvisa.resources import Resource # type: ignore
 
 # --- Runtime optional import
 try:
     import pyvisa as _pyvisa_runtime
 except Exception:
-    _pyvisa_runtime = None  # type:ignore
+    _pyvisa_runtime = None
 
 pyvisa: ModuleType | None = _pyvisa_runtime  # type: ignore
 
@@ -105,8 +105,8 @@ class VisaBackend(AdapterBackend):
 
         if self._status == AdapterBackendStatus.DISCONNECTED:
             # These attributes exist on pyvisa resources
-            self._inst.write_termination = ""  # type: ignore[attr-defined]
-            self._inst.read_termination = None  # type: ignore[attr-defined]
+            self._inst.write_termination = ""
+            self._inst.read_termination = None
 
             self._inst_lock = threading.Lock()
             self._status = AdapterBackendStatus.CONNECTED
@@ -136,7 +136,7 @@ class VisaBackend(AdapterBackend):
         super().write(data)
         with self._inst_lock:
             if self._inst is not None:
-                self._inst.write_raw(data)  # type: ignore[attr-defined]
+                self._inst.write_raw(data)
         return True
 
     def _socket_read(self) -> Fragment:
@@ -169,7 +169,7 @@ class VisaBackend(AdapterBackend):
             try:
                 while True:
                     # Read up to an error
-                    payload += inst.read_bytes(1)  # type: ignore[attr-defined]
+                    payload += inst.read_bytes(1)
                     inst.timeout = 0
             except pyvisa.VisaIOError:
                 # Timeout

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/adapters/ip.py

@@ -28,9 +28,9 @@ class IP(Adapter):
         self,
         address: str,
         port: int | None = None,
-        transport: str = IPDescriptor.Transport.TCP.value,
+        transport: str = DEFAULT_PROTOCOL.value,
         timeout: Timeout | NumberLike | None | EllipsisType = ...,
-        stop_conditions: StopCondition | None | EllipsisType | list = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
         alias: str = "",
         encoding: str = "utf-8",
         event_callback: Callable[[AdapterSignal], None] | None = None,
@@ -63,11 +63,7 @@ class IP(Adapter):
             descriptor=IPDescriptor(
                 address=address,
                 port=port,
-                transport=(
-                    IPDescriptor.Transport(transport.upper())
-                    if transport is not None
-                    else self.DEFAULT_PROTOCOL
-                ),
+                transport=IPDescriptor.Transport(transport.upper())
             ),
             alias=alias,
             timeout=timeout,
@@ -80,8 +76,8 @@ class IP(Adapter):
         )
         self.descriptor: IPDescriptor
 
-        if self.descriptor.transport is None:
-            self._logger.info(f"Setting up {self.descriptor.transport.value} IP adapter")
+        #if self.descriptor.transport is not None:
+        self._logger.info(f"Setting up {self.descriptor.transport.value} IP adapter")
 
         self.set_default_timeout(self._default_timeout())
 
@@ -102,7 +98,7 @@ class IP(Adapter):
         if self.descriptor.port is None:
             self.descriptor.port = port
 
-    def set_default_transport(self, transport : str | IPDescriptor.Transport):
+    def set_default_transport(self, transport : str | IPDescriptor.Transport) -> None:
         """
         Sets the default IP transport protocol
 

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/adapters/timeout.py

@@ -13,7 +13,7 @@ from ..tools.types import NumberLike, is_number
 
 class TimeoutAction(Enum):
     ERROR = "error"
-    RETURN = "return"
+    RETURN_EMPTY = "return_empty"
 
 
 class IsInitialized(Protocol):

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/adapters/visa.py

@@ -20,7 +20,7 @@ class Visa(Adapter):
         self,
         descriptor: str,
         alias: str = "",
-        stop_condition: StopCondition | None | EllipsisType = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
         timeout: None | float | Timeout | EllipsisType = ...,
         encoding: str = "utf-8",
         event_callback: Callable[[AdapterSignal], None] | None = None,
@@ -30,7 +30,7 @@ class Visa(Adapter):
         super().__init__(
             VisaDescriptor.from_string(descriptor),
             alias=alias,
-            stop_conditions=stop_condition,
+            stop_conditions=stop_conditions,
             timeout=timeout,
             encoding=encoding,
             event_callback=event_callback,

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/protocols/delimited.py

@@ -110,10 +110,8 @@ class Delimited(Protocol):
     def query(
         self,
         data: str,
-        timeout: Timeout | None | EllipsisType = ...,
-        decode: bool = True,
-        full_output: bool = False,
-    ) -> str | tuple[str, AdapterSignal]:
+        timeout: Timeout | None | EllipsisType = ...
+    ) -> str:
         """
         Writes then reads from the device and return the result
 
@@ -130,13 +128,13 @@ class Delimited(Protocol):
         """
         self._adapter.flushRead()
         self.write(data)
-        return self.read(timeout=timeout, decode=decode, full_output=full_output)
+        return self.read(timeout=timeout)
 
     def read_raw(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[bytes, AdapterReadPayload | None]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> bytes:
         """
         Reads command and formats it as a str
 
@@ -151,30 +149,27 @@ class Delimited(Protocol):
         """
 
         # Send up to the termination
-        raw_data, signal = self._adapter.read_detailed(
-            timeout=timeout, stop_condition=stop_condition
+        signal = self._adapter.read_detailed(
+            timeout=timeout, stop_conditions=stop_conditions
         )
-
-        return raw_data, signal
+        return signal.data()
 
     def read_detailed(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[str, AdapterReadPayload | None]:
-        raw_data, signal = self.read_raw(timeout=timeout, stop_condition=stop_condition)
-
-        data_out = self._decode(raw_data)
-        return data_out, signal
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...
+    ) -> AdapterReadPayload:
+        signal = self._adapter.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        return signal
 
     def read(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-        decode: bool = True,
-        full_output: bool = False,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...
     ) -> str:
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)[0]
+        signal = self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        return self._decode(signal.data())
+
 
     def _decode(self, data: bytes) -> str:
         try:

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/protocols/modbus.py

@@ -14,7 +14,7 @@ from unittest.mock import DEFAULT
 from ..adapters.adapter import Adapter
 from ..adapters.ip import IP
 from ..adapters.serialport import SerialPort
-from ..adapters.stop_condition import Length
+from ..adapters.stop_condition import Continuation, Length
 from ..adapters.timeout import Timeout
 from .protocol import Protocol
 
@@ -328,10 +328,12 @@ class Modbus(Protocol):
     def _error_code(self, response: bytes) -> int:
         return response[1]
 
-    def _parse_pdu(self, _pdu: bytes) -> bytes:
+    def _parse_pdu(self, _pdu: bytes | None) -> bytes:
         """
         Return data from PDU
         """
+        if _pdu is None:
+            raise RuntimeError("Failed to read modbus data") 
         if self._modbus_type == ModbusType.TCP:
             # Return raw data
             # data = _pdu
@@ -391,12 +393,13 @@ class Modbus(Protocol):
         )
 
         n_coil_bytes = ceil(number_of_coils / 8)
-        pdu: bytes = self._adapter.query(
+        pdu: bytes | None = self._adapter.query(
             self._make_pdu(query),
             # timeout=Timeout(continuation=1),
-            stop_condition=Length(
-                self._length(n_coil_bytes + 2)
-            ),  # TODO : convert to multiple stop conditions here
+            stop_conditions=[
+                Length(self._length(n_coil_bytes + 2)),
+                Continuation(time=1)
+              ]  # TODO : convert to multiple stop conditions here
         )
         response = self._parse_pdu(pdu)
         self._raise_if_error(response, exception_codes=EXCEPTIONS)
@@ -465,7 +468,7 @@ class Modbus(Protocol):
         response = self._parse_pdu(
             self._adapter.query(
                 self._make_pdu(query),
-                stop_condition=Length(self._length(byte_count + 2)),
+                stop_conditions=Length(self._length(byte_count + 2)),
             )
         )
         self._raise_if_error(response, exception_codes=EXCEPTIONS)
@@ -515,7 +518,7 @@ class Modbus(Protocol):
         response = self._parse_pdu(
             self._adapter.query(
                 self._make_pdu(query),
-                stop_condition=Length(self._length(2 + number_of_registers * 2)),
+                stop_conditions=Length(self._length(2 + number_of_registers * 2)),
             )
         )
         self._raise_if_error(response, exception_codes=EXCEPTIONS)
@@ -769,7 +772,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(len(query)))
+                self._make_pdu(query), stop_conditions=Length(self._length(len(query)))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -805,7 +808,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(len(query)))
+                self._make_pdu(query), stop_conditions=Length(self._length(len(query)))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -1198,7 +1201,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(5))
+                self._make_pdu(query), stop_conditions=Length(self._length(5))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -1250,7 +1253,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(5))
+                self._make_pdu(query), stop_conditions=Length(self._length(5))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -1451,7 +1454,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(len(query)))
+                self._make_pdu(query), stop_conditions=Length(self._length(len(query)))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -1521,7 +1524,7 @@ class Modbus(Protocol):
         response = self._parse_pdu(
             self._adapter.query(
                 self._make_pdu(query),
-                stop_condition=Length(self._length(2 + number_of_read_registers * 2)),
+                stop_conditions=Length(self._length(2 + number_of_read_registers * 2)),
             )
         )
         self._raise_if_error(response, EXCEPTIONS)

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/protocols/raw.py

@@ -49,33 +49,37 @@ class Raw(Protocol):
         self,
         data: bytes,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-        full_output: bool = False,
-    ) -> bytes | tuple[bytes, AdapterSignal]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> bytes:
         self._adapter.flushRead()
         self.write(data)
-        return self.read(
-            timeout=timeout,
-            stop_condition=stop_condition,
-            full_output=full_output,
-        )
+        return self.read(timeout=timeout, stop_conditions=stop_conditions)
+    
+    def query_detailed(
+        self,
+        data: bytes,
+        timeout: Timeout | None | EllipsisType = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> AdapterReadPayload:
+        self._adapter.flushRead()
+        self.write(data)
+        return self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
 
     def read(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-        full_output: bool = False,
-    ) -> bytes | tuple[bytes, AdapterSignal]:
-
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)[0]
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> bytes:
+        signal = self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        return signal.data() 
 
     def read_detailed(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[bytes, AdapterSignal | None]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> AdapterReadPayload:
         return self._adapter.read_detailed(
-            timeout=timeout, stop_condition=stop_condition
+            timeout=timeout, stop_conditions=stop_conditions
         )
 
     def _on_data_ready_event(self, data: AdapterReadPayload) -> None:

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/protocols/scpi.py

@@ -5,7 +5,7 @@
 
 from types import EllipsisType
 
-from syndesi.adapters.backend.adapter_backend import AdapterSignal
+from syndesi.adapters.backend.adapter_backend import AdapterReadPayload, AdapterSignal
 
 from ..adapters.adapter import Adapter
 from ..adapters.ip import IP
@@ -105,37 +105,39 @@ class SCPI(Protocol):
         self,
         command: str,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
     ) -> str:
         self._adapter.flushRead()
         self.write(command)
 
-        return self.read(timeout=timeout, stop_condition=stop_condition)
+        return self.read(timeout=timeout, stop_conditions=stop_conditions)
 
     def read_raw(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[bytes, AdapterSignal | None]:
-        return self._adapter.read_detailed(
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> bytes:
+        signal = self.read_detailed(
             timeout=timeout,
-            stop_condition=stop_condition,
+            stop_conditions=stop_conditions,
         )
+        return signal.data() 
 
     def read_detailed(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[str, AdapterSignal | None]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> AdapterReadPayload:
 
-        raw_data, signal = self.read_raw(timeout=timeout, stop_condition=stop_condition)
-        data_out = self._unformatCommand(self._from_bytes(raw_data))
-
-        return data_out, signal
+        signal = self._adapter.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        return signal
 
     def read(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
     ) -> str:
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)[0]
+        signal = self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        raw_data = signal.data()
+        return self._unformatCommand(self._from_bytes(raw_data))
+        

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/tools/backend_api.py

@@ -34,7 +34,7 @@ class Action(Enum):
     #FORCE_CLOSE = "force_close"  # (descriptor,) -> ()
     WRITE = "write"  # (descriptor,data) -> ()
     READ = "read"  # (descriptor,full_output,temporary_timeout,temporary_stop_condition) -> (data,metrics)
-    SET_STOP_CONDITION = "set_stop_condition"  # (descriptor,stop_condition)
+    SET_STOP_CONDITIONs = "set_stop_condition"  # (descriptor,stop_condition)
     FLUSHREAD = "flushread"
     START_READ = "start_read"  # Start a read (descriptor,response_time)
     RESPONSE_TIMEOUT = "response_timeout"

{syndesi-0.4.0 → syndesi-0.4.1}/syndesi/version.py

@@ -1,3 +1,3 @@
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 NAME = "Syndesi"
 AUTHOR = "Sébastien Deriaz"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syndesi
-Version: 0.4.0
+Version: 0.4.1
 Summary: Syndesi
 Author-email: Sébastien Deriaz <sebastien.deriaz1@gmail.com>
 License: GPL