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

syndesi/protocols/protocol.py

@@ -1,24 +1,80 @@
-from ..adapters import Adapter
-from ..adapters import Timeout
-from ..adapters.auto import auto_adapter
+# File : protocol.py
+# Author : Sébastien Deriaz
+# License : GPL
+
 import logging
-from ..tools.log import LoggerAlias
+from abc import abstractmethod
+from collections.abc import Callable
+from types import EllipsisType
+from typing import Any
+
+from ..adapters.adapter import Adapter
+from ..adapters.auto import auto_adapter
+from ..adapters.backend.adapter_backend import AdapterReadPayload, AdapterSignal
+
+# from syndesi.adapters.stop_condition import StopCondition
+from ..adapters.timeout import Timeout
+from ..tools.log_settings import LoggerAlias
+
 
 class Protocol:
-    def __init__(self, adapter : Adapter, timeout : Timeout = ...) -> None:
+    def __init__(
+        self,
+        adapter: Adapter,
+        timeout: Timeout | None | EllipsisType = ...,
+        event_callback: Callable[[AdapterSignal], None] | None = None,
+    ) -> None:
+        # TODO : Convert the callable from AdapterSignal to ProtocolSignal or something similar
         self._adapter = auto_adapter(adapter)
-        if timeout != ...:
+
+        self._event_callback = event_callback
+        self._adapter.set_event_callback(self.event_callback)
+
+        if timeout is not ...:
             self._adapter.set_default_timeout(timeout)
         self._logger = logging.getLogger(LoggerAlias.PROTOCOL.value)
 
-    def flushRead(self):
+        if timeout is ...:
+            self._adapter.set_timeout(self._default_timeout())
+        else:
+            self._adapter.set_timeout(timeout)
+
+    @abstractmethod
+    def _default_timeout(self) -> Timeout | None:
+        pass
+
+    def flushRead(self) -> None:
         self._adapter.flushRead()
 
-    def write(self, data):
+    def event_callback(self, event: AdapterSignal) -> None:
+        if self._event_callback is not None:
+            self._event_callback(event)
+
+    @abstractmethod
+    def _on_data_ready_event(self, data: AdapterReadPayload) -> None:
+        pass
+
+    @abstractmethod
+    def write(self, *args: Any, **kwargs: Any) -> None:
         pass
 
-    def query(self, data, timeout : Timeout = ...):
+    def open(self) -> None:
+        self._adapter.open()
+
+    def close(self) -> None:
+        self._adapter.close()
+
+    @abstractmethod
+    def query(
+        self,
+        *args: Any,
+        **kwargs: Any,
+        #   timeout: Union[Timeout, EllipsisType, None],
+        #   stop_condition: Union[StopCondition, None, EllipsisType],
+        #   full_output : bool,
+    ) -> Any:
         pass
 
-    def read(self):
-        pass
+    @abstractmethod
+    def read(self, *args: Any, **kwargs: Any) -> Any:
+        pass

syndesi/protocols/raw.py

@@ -1,12 +1,28 @@
-from ..adapters import Adapter, Timeout
-from .protocol import Protocol
+# File : raw.py
+# Author : Sébastien Deriaz
+# License : GPL
+
+from collections.abc import Callable
+from types import EllipsisType
+
+from syndesi.adapters.backend.adapter_backend import AdapterReadPayload, AdapterSignal
+from syndesi.adapters.stop_condition import StopCondition
 
+from ..adapters.adapter import Adapter
+from ..adapters.timeout import Timeout
+from .protocol import Protocol
 
 # Raw protocols provide the user with the binary data directly,
 # without converting it to string first
 
+
 class Raw(Protocol):
-    def __init__(self, adapter: Adapter, timeout : Timeout = ...) -> None:
+    def __init__(
+        self,
+        adapter: Adapter,
+        timeout: Timeout | None | EllipsisType = ...,
+        event_callback: Callable[[AdapterSignal], None] | None = None,
+    ) -> None:
         """
         Raw device, no presentation and application layers
 
@@ -14,15 +30,57 @@ class Raw(Protocol):
         ----------
         adapter : IAdapter
         """
-        super().__init__(adapter, timeout)
+        super().__init__(
+            adapter,
+            timeout,
+            event_callback,
+        )
+
+        # Connect the adapter if it wasn't done already
+        self._adapter.connect()
 
-    def write(self, data : bytes):
+    def _default_timeout(self) -> Timeout | None:
+        return Timeout(response=2, action="error")
+
+    def write(self, data: bytes) -> None:
         self._adapter.write(data)
 
-    def query(self, data : bytes, timeout=None, stop_condition=None, return_metrics : bool = False) -> bytes:
+    def query(
+        self,
+        data: bytes,
+        timeout: Timeout | None | EllipsisType = ...,
+        stop_condition: StopCondition | None | EllipsisType = ...,
+        full_output: bool = False,
+    ) -> bytes | tuple[bytes, AdapterSignal]:
         self._adapter.flushRead()
         self.write(data)
-        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+        return self.read(
+            timeout=timeout,
+            stop_condition=stop_condition,
+            full_output=full_output,
+        )
+
+    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]
+
+    def read_detailed(
+        self,
+        timeout: Timeout | None | EllipsisType = ...,
+        stop_condition: StopCondition | None | EllipsisType = ...,
+    ) -> tuple[bytes, AdapterSignal | None]:
+        return self._adapter.read_detailed(
+            timeout=timeout, stop_condition=stop_condition
+        )
+
+    def _on_data_ready_event(self, data: AdapterReadPayload) -> None:
+        # TODO : Call the callback here ?
+        pass
 
-    def read(self, timeout=None, stop_condition=None, return_metrics : bool = False) -> bytes:
-        return self._adapter.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+    def __str__(self) -> str:
+        return f"Raw({self._adapter})"

syndesi/protocols/scpi.py

@@ -1,12 +1,30 @@
-from ..adapters import Adapter, IP, Timeout, Termination, StopCondition
+# File : scpi.py
+# Author : Sébastien Deriaz
+# License : GPL
+
+
+from types import EllipsisType
+
+from syndesi.adapters.backend.adapter_backend import AdapterSignal
+
+from ..adapters.adapter import Adapter
+from ..adapters.ip import IP
+from ..adapters.stop_condition import StopCondition, Termination
+from ..adapters.timeout import Timeout, TimeoutAction
 from .protocol import Protocol
-from ..tools.types import is_byte_instance
 
-DEFAULT_TIMEOUT = Timeout(response=10, continuation=0.5, total=None, on_response='error', on_continuation='error')
 
 class SCPI(Protocol):
     DEFAULT_PORT = 5025
-    def __init__(self, adapter: Adapter, send_termination = '\n', receive_termination = None, timeout : Timeout = ..., encoding : str = 'utf-8') -> None:
+
+    def __init__(
+        self,
+        adapter: Adapter,
+        send_termination: str = "\n",
+        receive_termination: str | None = None,
+        timeout: Timeout | None | EllipsisType = ...,
+        encoding: str = "utf-8",
+    ) -> None:
         """
         SDP (Syndesi Device Protocol) compatible device
 
@@ -22,9 +40,7 @@ class SCPI(Protocol):
         """
         self._encoding = encoding
         # Set the default timeout
-        if timeout is Ellipsis:
-            timeout = DEFAULT_TIMEOUT
-        
+
         if receive_termination is None:
             self._receive_termination = send_termination
         else:
@@ -32,56 +48,94 @@ class SCPI(Protocol):
         self._send_termination = send_termination
         # Configure the adapter for stop-condition mode (timeouts will raise errors)
         if not adapter._default_stop_condition:
-            raise ValueError('No stop-conditions can be set for an adapter used by SCPI protocol')
-        adapter.set_stop_condition(Termination(self._receive_termination.encode(self._encoding)))
-        adapter.set_timeout(timeout)
+            raise ValueError(
+                "No stop-conditions can be set for an adapter used by SCPI protocol"
+            )
+        adapter.set_stop_conditions(
+            Termination(self._receive_termination.encode(self._encoding))
+        )
+
+        # adapter.set_timeout(self.timeout)
         if isinstance(adapter, IP):
             adapter.set_default_port(self.DEFAULT_PORT)
         # Give the adapter to the Protocol base class
         super().__init__(adapter=adapter, timeout=timeout)
 
-    def _to_bytes(self, command):
+        # Connect the adapter if it wasn't done already
+        self._adapter.connect()
+
+    def _default_timeout(self) -> Timeout | None:
+        return Timeout(response=5, action=TimeoutAction.ERROR.value)
+
+    def _to_bytes(self, command: str) -> bytes:
         if isinstance(command, str):
-            return command.encode('ASCII')
+            return command.encode("ASCII")
         else:
-            raise ValueError(f'Invalid command type : {type(command)}')
-    
-    def _from_bytes(self, payload : bytes):
-        if is_byte_instance(payload):
-            return payload.decode('ASCII')
+            raise ValueError(f"Invalid command type : {type(command)}")
+
+    def _from_bytes(self, payload: bytes) -> str:
+        if isinstance(payload, bytes):
+            return payload.decode("ASCII")
         else:
             raise ValueError(f"Invalid payload type : {type(payload)}")
 
-    def _formatCommand(self, command):
+    def _formatCommand(self, command: str) -> str:
         return command + self._send_termination
 
-    def _unformatCommand(self, payload):
-        return payload.replace(self._receive_termination, '')
-    
-    def _checkCommand(self, command : str):
-        for c in ['\n', '\r']:
+    def _unformatCommand(self, payload: str) -> str:
+        return payload.replace(self._receive_termination, "")
+
+    def _checkCommand(self, command: str) -> None:
+        for c in ["\n", "\r"]:
             if c in command:
                 raise ValueError(f"Invalid char {repr(c)} in command")
 
-    def write(self, command : str) -> None:
+    def write(self, command: str) -> None:
         self._checkCommand(command)
         payload = self._to_bytes(self._formatCommand(command))
         self._adapter.write(payload)
 
-    def write_raw(self, data : bytes, termination : bool = False):
-        self._adapter.write(data + (self._send_termination if termination else b''))
+    def write_raw(self, data: bytes, termination: bool = False) -> None:
+        self._adapter.write(
+            data
+            + (self._send_termination.encode(self._encoding) if termination else b"")
+        )
 
-    def query(self, command : str, timeout : Timeout = ..., stop_condition : StopCondition = ..., return_metrics : bool = False) -> str:
+    def query(
+        self,
+        command: str,
+        timeout: Timeout | None | EllipsisType = ...,
+        stop_condition: StopCondition | None | EllipsisType = ...,
+    ) -> str:
         self._adapter.flushRead()
         self.write(command)
-        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
 
-    def read(self, timeout : Timeout = ..., stop_condition : StopCondition = None, return_metrics : bool = False) -> str:
-        output = self._from_bytes(self._adapter.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics))
-        return self._unformatCommand(output)
+        return self.read(timeout=timeout, stop_condition=stop_condition)
 
-    def read_raw(self, timeout=None, stop_condition=None, return_metrics : bool = False) -> str:
-        """
-        Return the raw bytes instead of str
-        """
-        return self._adapter.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+    def read_raw(
+        self,
+        timeout: Timeout | None | EllipsisType = ...,
+        stop_condition: StopCondition | None | EllipsisType = ...,
+    ) -> tuple[bytes, AdapterSignal | None]:
+        return self._adapter.read_detailed(
+            timeout=timeout,
+            stop_condition=stop_condition,
+        )
+
+    def read_detailed(
+        self,
+        timeout: Timeout | None | EllipsisType = ...,
+        stop_condition: StopCondition | None | EllipsisType = ...,
+    ) -> tuple[str, AdapterSignal | None]:
+
+        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
+
+    def read(
+        self,
+        timeout: Timeout | None | EllipsisType = ...,
+        stop_condition: StopCondition | None | EllipsisType = ...,
+    ) -> str:
+        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)[0]

syndesi/scripts/syndesi.py

@@ -0,0 +1,52 @@
+# File : syndesi.py
+# Author : Sébastien Deriaz
+# License : GPL
+
+import argparse
+from enum import Enum
+
+from ..cli.shell import AdapterShell, AdapterType
+from ..tools.log import log
+from ..version import __version__
+
+
+class SyndesiCommands(Enum):
+    SERIAL = "serial"
+    IP = "ip"
+    MODBUS = "modbus"
+    VISA = "visa"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="syndesi", description="Syndesi command line tool", epilog=""
+    )
+
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    parser.add_argument("-v", "--verbose", action="store_true")
+    parser.add_argument(
+        "command",
+        choices=[x.value for x in SyndesiCommands],
+        help="Command, use syndesi <command> -h for help",
+    )
+
+    args, remaining_args = parser.parse_known_args()
+    command = SyndesiCommands(args.command)
+
+    if args.verbose:
+        log("DEBUG", console=True)
+
+    if command == SyndesiCommands.SERIAL:
+        AdapterShell(AdapterType.SERIAL, remaining_args).run()
+    elif command == SyndesiCommands.IP:
+        AdapterShell(AdapterType.IP, remaining_args).run()
+    elif command == SyndesiCommands.VISA:
+        AdapterShell(AdapterType.VISA, remaining_args).run()
+    else:
+        raise RuntimeError(f"Command '{command.value}' is not supported yet")
+
+
+if __name__ == "__main__":
+    main()

syndesi/scripts/syndesi_backend.py

@@ -0,0 +1,37 @@
+# File : syndesi_backend.py
+# Author : Sébastien Deriaz
+# License : GPL
+
+import argparse
+
+from ..cli.backend_console import BackendConsole
+from ..cli.backend_status import BackendStatus
+from ..cli.backend_wrapper import BackendWrapper
+
+
+def main() -> None:
+    argument_parser = argparse.ArgumentParser(prog="syndesi-backend")
+
+    argument_parser.add_argument(
+        "--status", action="store_true", help="Show backend status"
+    )
+
+    argument_parser.add_argument(
+        "--console", action="store_true", help="Run backend console"
+    )
+
+    args, remaining_args = argument_parser.parse_known_args()
+
+    if args.status:
+        status = BackendStatus(remaining_args)
+        status.run()
+    elif args.console:
+        console = BackendConsole(remaining_args)
+        console.run()
+    else:
+        backend = BackendWrapper(remaining_args)
+        backend.run()
+
+
+if __name__ == "__main__":
+    main()

syndesi/tools/backend_api.py

@@ -0,0 +1,209 @@
+# File : backend_api.py
+# Author : Sébastien Deriaz
+# License : GPL
+
+from dataclasses import dataclass
+from enum import Enum
+from multiprocessing.connection import Connection, wait
+from typing import Any, Protocol
+
+from syndesi.tools.errors import BackendCommunicationError, BackendError
+
+BACKEND_PORT = 59677
+LOCALHOST = "127.0.0.1"
+
+default_host = LOCALHOST
+# AUTHKEY = b'syndesi'
+
+# Backend protocol format
+# (action, arguments)
+# If the command succeeds, it is returned as :
+# (action, other arguments)
+# If the command fails, it is returned as :
+# (error, error_description)
+
+# The backend links the client with an adapter when SELECT_ADAPTER is sent along with an adapter descriptor
+
+STANDARD_RESPONSE_TIMEOUT = 2
+
+
+class Action(Enum):
+    # All adapters
+    SELECT_ADAPTER = "select"
+    OPEN = "open"  # (descriptor,stop_condition) -> ()
+    CLOSE = (
+        "close"  # (descriptor,) -> () # Notify the backend that this client will close
+    )
+    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)
+    FLUSHREAD = "flushread"
+    #START_READ = "start_read"  # Start a read (descriptor,response_time)
+    GET_BACKEND_TIME = "get_time"
+
+    # Events
+    ADAPTER_EVENT_DATA_READY = "event_adapter_data_ready"
+    ADAPTER_EVENT_DISCONNECTED = "event_adapter_disconnected"
+    ADAPTER_EVENT_READ_INIT = "event_adapter_read_init"
+
+    # Other
+    SET_ROLE_ADAPTER = (
+        "set_role_adapter"  # Define the client as an adapter (exchange of data)
+    )
+    SET_ROLE_MONITORING = "set_role_monitoring"  # The client queries for backend info
+    SET_ROLE_LOGGER = "set_role_logger"  # The client receives logs
+    SET_LOG_LEVEL = "set_log_level"
+    PING = "ping"
+    STOP = "stop"
+
+    # Backend debugger
+    ENUMERATE_ADAPTER_CONNECTIONS = "enumerate_adapter_connections"
+    ENUMERATE_MONITORING_CONNECTIONS = "enumerate_monitoring_connections"
+    BACKEND_STATS = "backend_stats"
+
+    # Errors
+    ERROR_GENERIC = "error_generic"
+    ERROR_UNKNOWN_ACTION = "error_unknown_action"
+    ERROR_INVALID_REQUEST = "error_invalid_request"
+    ERROR_ADAPTER_NOT_OPENED = "error_adapter_not_opened"
+    ERROR_INVALID_ROLE = "error_invalid_role"
+    ERROR_ADAPTER_DISCONNECTED = "error_adapter_disconnected"
+    ERROR_BACKEND_DISCONNECTED = "error_backend_disconnected"
+    ERROR_FAILED_TO_OPEN = "error_failed_to_open"
+
+
+def is_event(action: Action) -> bool:
+    return action.value.startswith("event_")
+
+
+def is_action_error(action: Action) -> bool:
+    return action.value.startswith("error_")
+
+
+class BackendException(Exception):
+    pass
+
+
+class ValidFragment(Protocol):
+    data: bytes
+
+
+@dataclass
+class Fragment:
+    data: bytes
+    timestamp: float | None
+
+    def __str__(self) -> str:
+        return f"{self.data!r}"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def __getitem__(self, key: slice) -> "Fragment":
+        # if self.data is None:
+        #     raise IndexError('Cannot index invalid fragment')
+        return Fragment(self.data[key], self.timestamp)
+
+
+# def get_conn_addresses(conn: Connection) -> tuple[str, str]:
+#     try:
+#         fd = conn.fileno()
+#     except OSError:
+#         return ("closed", "closed")
+#     else:
+#         sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
+#         try:
+#             # address, port = sock.getpeername()  # (IP, port) tuple
+#             peer_address = sock.getpeername()
+#             sock_address = sock.getsockname()
+#             return sock_address, peer_address
+#         except Exception:
+#             return ("error", "closed")
+
+
+BackendResponse = tuple[object, ...]
+
+
+def frontend_send(conn: Connection, action: Action, *args: Any) -> bool:
+    try:
+        conn.send((action.value, *args))
+    except (BrokenPipeError, OSError):
+        return False
+    else:
+        return True
+
+
+def backend_request(
+    conn: Connection,
+    action: Action,
+    *args: Any,
+    timeout: float = STANDARD_RESPONSE_TIMEOUT,
+) -> BackendResponse:
+    try:
+        conn.send((action.value, *args))
+    except (BrokenPipeError, OSError) as err:
+        raise BackendCommunicationError("Failed to communicate with backend") from err
+    else:
+        ready = wait([conn], timeout=timeout)
+        if conn not in ready:
+            raise BackendCommunicationError(
+                "Failed to receive backend response in time"
+            )
+
+        try:
+            raw_response: object = conn.recv()
+        except (EOFError, ConnectionResetError) as err:
+            raise BackendCommunicationError(
+                f"Failed to receive backend response to {action.value}"
+            ) from err
+
+        # Check if the response is correctly formatted
+        if not (isinstance(raw_response, tuple) and isinstance(raw_response[0], str)):
+            raise BackendCommunicationError(
+                f"Invalid response received from backend : {raw_response}"
+            )
+
+        response_action: Action = Action(raw_response[0])
+        arguments: tuple[Any, ...] = raw_response[1:]
+
+        if is_action_error(response_action):
+            if len(arguments) > 0:
+                if isinstance(arguments[0], str):
+                    error_message: str = arguments[0]
+                else:
+                    error_message = "failed to read error message"
+            else:
+                error_message = "Missing error message"
+            raise BackendError(f"{response_action} : {error_message}")
+        return arguments
+
+
+backend_send = frontend_send
+
+
+def raise_if_error(response: BackendResponse) -> None:
+    action = Action(response[0])
+    if is_action_error(action):
+        if len(response) > 1:
+            description = response[1]
+        else:
+            description = f"{action}"
+        raise BackendException(f"{action.name}/{description}")
+    return
+
+
+class AdapterBackendStatus(Enum):
+    DISCONNECTED = 0
+    CONNECTED = 1
+
+
+class ClientStatus(Enum):
+    DISCONNECTED = 0
+    CONNECTED = 1
+
+
+# class StatusSnapshot(TypedDict):
+#     type : Literal['snapshot']
+#     adapters :
+#     #clients : List[str]