syndesi 0.3.2__py3-none-any.whl → 0.4.1__py3-none-any.whl

syndesi/adapters/stop_condition.py

@@ -10,6 +10,9 @@ class StopConditionType(Enum):
     TERMINATION = 'termination'
     LENGTH = 'length'
     TIMEOUT = 'timeout'
+    #CONTINUATION = 'continuation'
+    #TOTAL = 'total'
+
 
 
 
@@ -109,34 +112,52 @@ class Length(StopCondition):
         return StopConditionType.LENGTH
 
 
-class TimeoutStopCondition(StopCondition):
-    def __init__(
-        self, continuation: float | None = None, total: float | None = None
-    ) -> None:
+class Continuation(StopCondition):
+    def __init__(self, time : float) -> None:
         super().__init__()
-        self.continuation = continuation
-        self.total = total
-
-    # def compose_json(self) -> str:
-    #     data = {
-    #         JsonKey.TYPE.value: StopConditionType.TIMEOUT.value,
-    #         JsonKey.TIMEOUT_CONTINUATION.value: self.continuation,
-    #         JsonKey.TIMEOUT_TOTAL.value: self.total,
-    #     }
-    #     return json.dumps(data)
-
-    # def compose(self) -> dict:
-    #     return {
-    #         StopConditionDescriptorKey.TYPE.value: StopConditionType.TIMEOUT.value,
-    #         StopConditionDescriptorKey.TIMEOUT_CONTINUATION.value: self.continuation,
-    #         StopConditionDescriptorKey.TIMEOUT_TOTAL.value: self.total,
-    #     }
-
-    def __repr__(self) -> str:
-        return super().__repr__()
+        self.continuation = time
+    
+    def type(self) -> StopConditionType:
+        return StopConditionType.TIMEOUT
 
-    def __str__(self) -> str:
-        return super().__str__()
+class Total(StopCondition):
+    def __init__(self, time : float) -> None:
+        super().__init__()
+        self.total = time
     
     def type(self) -> StopConditionType:
         return StopConditionType.TIMEOUT
+    
+
+
+# class TimeoutStopCondition(StopCondition):
+#     def __init__(
+#         self, continuation: float | None = None, total: float | None = None
+#     ) -> None:
+#         super().__init__()
+#         self.continuation = continuation
+#         self.total = total
+
+#     # def compose_json(self) -> str:
+#     #     data = {
+#     #         JsonKey.TYPE.value: StopConditionType.TIMEOUT.value,
+#     #         JsonKey.TIMEOUT_CONTINUATION.value: self.continuation,
+#     #         JsonKey.TIMEOUT_TOTAL.value: self.total,
+#     #     }
+#     #     return json.dumps(data)
+
+#     # def compose(self) -> dict:
+#     #     return {
+#     #         StopConditionDescriptorKey.TYPE.value: StopConditionType.TIMEOUT.value,
+#     #         StopConditionDescriptorKey.TIMEOUT_CONTINUATION.value: self.continuation,
+#     #         StopConditionDescriptorKey.TIMEOUT_TOTAL.value: self.total,
+#     #     }
+
+#     def __repr__(self) -> str:
+#         return super().__repr__()
+
+#     def __str__(self) -> str:
+#         return super().__str__()
+    
+#     def type(self) -> StopConditionType:
+#         return StopConditionType.TIMEOUT

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):
@@ -67,7 +67,7 @@ class Timeout:
 
     def set_default(self, default_timeout: "Timeout") -> None:
         if self._is_default_response:
-            self.response = default_timeout.response
+            self._response = default_timeout.response()
         if self._is_default_action:
             self.action = default_timeout.action
 

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/cli/shell_tools.py

@@ -8,100 +8,98 @@ from dataclasses import dataclass
 from typing import Any
 
 
-@dataclass
-class CommandSpec:
-    name: str
-    func: Callable[..., Any]  # the underlying function object
-    help: str = ""
-    aliases: tuple[str, ...] = ()
-    hidden: bool = False
-    dangerous: bool = False
-    owner_cls: type | None = None  # populated when collected
-    method_kind: str = "function"  # "instance" | "class" | "static" | "function"
-
-
-# ---- Module-level registry (optional)
-# If you like auto-discovery, classes decorated with @collect_cli_exports
-# get added here at import time.
-CLI_CLASS_REGISTRY: set[type] = set()
-
-
-def iter_all_cli_specs(classes: Iterable[type]) -> Iterable[CommandSpec]:
-    """Yield CommandSpec for the given classes (or CLI_CLASS_REGISTRY if you pass that)."""
-    for cls in classes:
-        for spec in getattr(cls, "__cli_exports__", ()):
-            yield from spec
-
-
-# ---- Decorators
-
-
-def cli_command(
-    name: str | None = None,
-    *,
-    help: str = "",
-    aliases: tuple[str, ...] = (),
-    hidden: bool = False,
-    dangerous: bool = False,
-) -> None:
-    """
-    Decorate any callable (method or function) to mark it as CLI-visible.
-    Attach a CommandSpec to the function object. Class binding is assigned later.
-    """
-
-    def deco(fn: Callable[..., Any]) -> None:
-        # Note: we attach spec on the underlying function (works for instance funcs).
-        spec = CommandSpec(
-            name=(name or fn.__name__).replace("_", "-"),
-            func=fn,
-            help=help or (fn.__doc__ or "").strip(),
-            aliases=aliases,
-            hidden=hidden,
-            dangerous=dangerous,
-        )
-        fn.__cli_export__ = spec
-        return fn
-
-    return deco
-
-
-def collect_cli_exports(cls: type) -> None:
-    """
-    Class decorator: scan the class for decorated methods (instance, classmethod, staticmethod),
-    create a stable list of CommandSpec, and attach it as __cli_exports__.
-    Also registers the class in CLI_CLASS_REGISTRY for optional auto-discovery.
-    """
-    exports: list[CommandSpec] = []
-
-    for _, obj in cls.__dict__.items():
-        # instance method (function descriptor)
-        if inspect.isfunction(obj):
-            spec: CommandSpec | None = getattr(obj, "__cli_export__", None)
-            if spec:
-                spec.owner_cls = cls
-                spec.method_kind = "instance"
-                exports.append(spec)
-            continue
-
-        # classmethod / staticmethod wrap the underlying function in .__func__
-        if isinstance(obj, classmethod):
-            fn = obj.__func__
-            spec = getattr(fn, "__cli_export__", None)
-            if spec:
-                spec.owner_cls = cls
-                spec.method_kind = "class"
-                exports.append(spec)
-            continue
-
-        if isinstance(obj, staticmethod):
-            fn = obj.__func__
-            spec = getattr(fn, "__cli_export__", None)
-            if spec:
-                spec.owner_cls = cls
-                spec.method_kind = "static"
-                exports.append(spec)
-            continue
-
-    cls.__cli_exports__ = tuple(exports)
-    CLI_CLASS_REGISTRY.add(cls)
-    return cls
+# @dataclass
+# class CommandSpec:
+#     name: str
+#     func: Callable[..., Any]  # the underlying function object
+#     help: str = ""
+#     aliases: tuple[str, ...] = ()
+#     hidden: bool = False
+#     dangerous: bool = False
+#     owner_cls: type | None = None  # populated when collected
+#     method_kind: str = "function"  # "instance" | "class" | "static" | "function"
+
+
+# # ---- Module-level registry (optional)
+# # If you like auto-discovery, classes decorated with @collect_cli_exports
+# # get added here at import time.
+# CLI_CLASS_REGISTRY: set[type] = set()
+
+
+# def iter_all_cli_specs(classes: Iterable[type]) -> Iterable[CommandSpec]:
+#     """Yield CommandSpec for the given classes (or CLI_CLASS_REGISTRY if you pass that)."""
+#     for cls in classes:
+#         for spec in getattr(cls, "__cli_exports__", ()):
+#             yield from spec
+
+
+# # ---- Decorators
+# def cli_command(
+#     name: str | None = None,
+#     *,
+#     help: str = "",
+#     aliases: tuple[str, ...] = (),
+#     hidden: bool = False,
+#     dangerous: bool = False,
+# ) -> None:
+#     """
+#     Decorate any callable (method or function) to mark it as CLI-visible.
+#     Attach a CommandSpec to the function object. Class binding is assigned later.
+#     """
+
+#     def deco(fn: Callable[..., Any]) -> None:
+#         # Note: we attach spec on the underlying function (works for instance funcs).
+#         spec = CommandSpec(
+#             name=(name or fn.__name__).replace("_", "-"),
+#             func=fn,
+#             help=help or (fn.__doc__ or "").strip(),
+#             aliases=aliases,
+#             hidden=hidden,
+#             dangerous=dangerous,
+#         )
+#         fn.__cli_export__ = spec
+#         return fn
+
+#     return deco
+
+
+# def collect_cli_exports(cls: type) -> None:
+#     """
+#     Class decorator: scan the class for decorated methods (instance, classmethod, staticmethod),
+#     create a stable list of CommandSpec, and attach it as __cli_exports__.
+#     Also registers the class in CLI_CLASS_REGISTRY for optional auto-discovery.
+#     """
+#     exports: list[CommandSpec] = []
+
+#     for _, obj in cls.__dict__.items():
+#         # instance method (function descriptor)
+#         if inspect.isfunction(obj):
+#             spec: CommandSpec | None = getattr(obj, "__cli_export__", None)
+#             if spec:
+#                 spec.owner_cls = cls
+#                 spec.method_kind = "instance"
+#                 exports.append(spec)
+#             continue
+
+#         # classmethod / staticmethod wrap the underlying function in .__func__
+#         if isinstance(obj, classmethod):
+#             fn = obj.__func__
+#             spec = getattr(fn, "__cli_export__", None)
+#             if spec:
+#                 spec.owner_cls = cls
+#                 spec.method_kind = "class"
+#                 exports.append(spec)
+#             continue
+
+#         if isinstance(obj, staticmethod):
+#             fn = obj.__func__
+#             spec = getattr(fn, "__cli_export__", None)
+#             if spec:
+#                 spec.owner_cls = cls
+#                 spec.method_kind = "static"
+#                 exports.append(spec)
+#             continue
+
+#     cls.__cli_exports__ = tuple(exports)
+#     CLI_CLASS_REGISTRY.add(cls)
+#     return cls

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/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/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/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))
+