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

syndesi/adapters/backend/timeout.py

@@ -1,252 +0,0 @@
-# File : timeout.py
-# Author : Sébastien Deriaz
-# License : GPL
-#
-# The timeout backend manages timing when reading from a device, it both
-# records how much time each action took and stops communication if it
-# exceeds set criteria
-
-# from enum import Enum
-# from typing import Union, Tuple
-# from time import time
-# import json
-
-# class TimeoutAction(Enum):
-#     DISCARD = "discard"  # If a timeout is reached, data is discarded
-#     RETURN = "return"  #  If a timeout is reached, data is returned (timeout acts as a stop condition)
-#     STORE = "store"  # If a timeout is reached, data is stored and returned on the next read() call
-#     ERROR = "error"  # If a timeout is reached, raise an error
-
-
-# class TimeoutType(Enum):
-#     RESPONSE = "response"
-
-# class JsonKey(Enum):
-#     RESPONSE = "r"
-#     ACTION = "a"
-
-
-# class TimeoutBackend:
-#     class _State(Enum):
-#         WAIT_FOR_RESPONSE = 0
-#         CONTINUATION = 1
-
-#     def __init__(
-#         self, response, continuation, total, on_response, on_continuation, on_total
-#     ) -> None:
-#         """
-#         A class to manage timeouts
-
-#         Timeouts are split in three categories :
-#         - response timeout : the "standard" timeout, (i.e the time it takes for
-#             a device to start transmitting data)
-#         - continuation timeout : the time between reception of
-#             data units (bytes or blocks of data)
-#         - total timeout : maximum time from start to end of transmission.
-#             This timeout can stop a communication mid-way. It is used to
-#             prevent a host from getting stuck reading a constantly streaming device
-
-#         Each timeout is specified in seconds
-
-#         Actions
-#         - discard : Discard all of data obtained during the read() call if the specified timeout if reached and return empty data
-#         - return : Return all of the data read up to this point when the specified timeout is reached
-#         - store : Store all of the data read up to this point in a buffer. Data will be available at the next read() call
-#         - error : Produce an error
-
-#         Parameters
-#         ----------
-#         response : float
-#         continuation : float
-#         total : float
-#         on_response : str
-#             Action on response timeout (see Actions)
-#         on_continuation : str
-#             Action on continuation timeout (see Actions)
-#         on_total : str
-#             Action on total timeout (see Actions)
-#         """
-#         super().__init__()
-#         # It is possible to pass a tuple to set response/continuation/total, parse this first if it is the case
-#         if isinstance(response, (tuple, list)):
-#             if len(response) >= 3:
-#                 total = response[2]
-#             if len(response) >= 2:
-#                 continuation = response[1]
-#             response = response[0]
-
-#         # Timeout values (response, continuation and total)
-#         self._response = response
-#         self._continuation = continuation
-#         self._total = total
-#         self._on_response = (
-#             TimeoutAction(on_response) if on_response is not None else None
-#         )
-#         self._on_continuation = (
-#             TimeoutAction(on_continuation) if on_continuation is not None else None
-#         )
-#         self._on_total = TimeoutAction(on_total) if on_total is not None else None
-
-#         # State machine flags
-#         self._state = self._State.WAIT_FOR_RESPONSE
-#         self._queue_timeout_type = TimeoutType.RESPONSE
-#         self._last_data_action_origin = TimeoutType.RESPONSE
-
-#     def initiate_read(self, deferred_buffer: bool = False) -> Union[float, None]:
-#         """
-#         Initiate a read sequence.
-
-#         The maximum time that should be spent in the next byte read
-#         is returned
-
-#         Returns
-#         -------
-#         stop : bool
-#             Timeout is reached
-#         keep : bool
-#             True if data read up to this point should be kept
-#             False if data should be discarded
-#         timeout : float or None
-#             None is there's no timeout
-#         """
-#         self._start_time = time()
-#         if deferred_buffer:
-#             self._state = self._State.CONTINUATION
-#             self._data_action = self._on_continuation
-#             self._queue_timeout_type = TimeoutType.CONTINUATION
-#         else:
-#             self._state = self._State.WAIT_FOR_RESPONSE
-#             self._data_action = self._on_response
-#             self._queue_timeout_type = TimeoutType.RESPONSE
-#         self._last_timestamp = None
-
-#         self.response_time = None
-#         self.continuation_times = []
-#         self.total_time = None
-
-#         self._output_timeout = None
-
-#         return self._response
-
-#     def evaluate(self, timestamp: float) -> Tuple[bool, Union[float, None]]:
-#         stop = False
-
-#         # self._check_uninitialization()
-
-#         self._data_action = None
-#         self._stop_source_value = (
-#             "###"  # When a timeout occurs, store the value that exceeded its value here
-#         )
-#         self._stop_source_limit = "###"  # And store the limit value here
-
-#         # First check if the timestamp is None, that would mean the timeout was reached in the queue
-#         if timestamp is None:
-#             # Set the data action according to the timeout that was given for the queue before
-#             match self._queue_timeout_type:
-#                 case TimeoutType.RESPONSE:
-#                     self._data_action = self._on_response
-#                     self._stop_source_limit = self._response
-#                 case TimeoutType.CONTINUATION:
-#                     self._data_action = self._on_continuation
-#                     self._stop_source_limit = self._continuation
-#                 case TimeoutType.TOTAL:
-#                     self._data_action = self._on_total
-#                     self._stop_source_limit = self._total
-#             self._stop_source_value = None  # We do not have the exceed time, but None will be printed as '---'
-#             self._last_data_action_origin = self._queue_timeout_type
-#             stop = True
-
-#         else:
-#             # Check total
-#             if self._total is not None:
-#                 self.total_time = timestamp - self._start_time
-#                 if self.total_time >= self._total:
-#                     stop = True
-#                     self._data_action = self._on_total
-#                     self._last_data_action_origin = TimeoutType.TOTAL
-#                     self._stop_source_value = self.total_time
-#                     self._stop_source_limit = self._total
-#             # Check continuation
-#             elif (
-#                 self._continuation is not None
-#                 and self._state == self._State.CONTINUATION
-#                 and self._last_timestamp is not None
-#             ):
-#                 continuation_time = timestamp - self._last_timestamp
-#                 self.continuation_times.append(continuation_time)
-#                 if continuation_time >= self._continuation:
-#                     stop = True
-#                     self._data_action = self._on_continuation
-#                     self._last_data_action_origin = TimeoutType.CONTINUATION
-#                     self._stop_source_value = continuation_time
-#                     self._stop_source_limit = self._continuation
-#             # Check response time
-#             elif (
-#                 self._response is not None
-#                 and self._state == self._State.WAIT_FOR_RESPONSE
-#             ):
-#                 self.response_time = timestamp - self._start_time
-#                 if self.response_time >= self._response:
-#                     stop = True
-#                     self._data_action = self._on_response
-#                     self._last_data_action_origin = TimeoutType.RESPONSE
-#                     self._stop_source_value = self.response_time
-#                     self._stop_source_limit = self._response
-
-#         self._output_timeout = None
-#         # If we continue
-#         if not stop:
-#             # Update the state
-#             if self._state == self._State.WAIT_FOR_RESPONSE:
-#                 self._state = self._State.CONTINUATION
-#             self._last_timestamp = timestamp
-#             # No timeouts were reached, return the next one
-#             # Return the timeout (state is always CONTINUATION at this stage)
-#             # Take the smallest between continuation and total
-#             if self._total is not None and self._continuation is not None:
-#                 c = self._continuation
-#                 t = self._start_time + self._total
-#                 if c < t:
-#                     self._output_timeout = c
-#                     self._queue_timeout_type = TimeoutType.CONTINUATION
-#                 else:
-#                     self._output_timeout = t
-#                     self._queue_timeout_type = TimeoutType.TOTAL
-#             elif self._total is not None:
-#                 self._output_timeout = time() - (self._start_time + self._total)
-#                 self._queue_timeout_type = TimeoutType.TOTAL
-#             elif self._continuation is not None:
-#                 self._output_timeout = self._continuation
-#                 self._queue_timeout_type = TimeoutType.CONTINUATION
-
-#         return stop, self._output_timeout
-
-#     def dataAction(self):
-#         """
-#         Return the data action (discard, return, store or error)
-#         and the timeout origin (response, continuation or total)
-
-#         Returns
-#         -------
-#         data_action : Timeout.DataAction
-#         origin : Timeout.TimeoutType
-
-#         """
-#         return self._data_action, self._last_data_action_origin
-
-#     def __str__(self) -> str:
-#         def _format(value, action):
-#             if value is None:
-#                 return "None"
-#             elif value is Ellipsis:
-#                 return "not set"
-#             else:
-#                 return f'{value*1e3:.3f}ms/{action.value if isinstance(action, Enum) else "not set"}'
-
-#         response = "r:" + _format(self._response, self._on_response)
-#         continuation = "c:" + _format(self._continuation, self._on_continuation)
-#         total = "t:" + _format(self._total, self._on_total)
-#         return f"Timeout({response},{continuation},{total})"
-
-#     def __repr__(self) -> str:
-#         return self.__str__()

syndesi/adapters/backend/visa_backend.py

@@ -1,197 +0,0 @@
-# File : visa.py
-# Author : Sébastien Deriaz
-# License : GPL
-#
-# The VISA backend communicates using pyvisa
-
-from __future__ import annotations
-
-import queue
-import socket
-import threading
-import time
-from types import ModuleType
-from typing import TYPE_CHECKING
-
-from ...tools.backend_api import AdapterBackendStatus, Fragment
-from .adapter_backend import (
-    AdapterBackend,
-    AdapterDisconnected,
-    AdapterSignal,
-    HasFileno,
-)
-from .descriptors import VisaDescriptor
-
-# --- Typing-only imports so mypy knows pyvisa symbols without requiring it at runtime
-if TYPE_CHECKING:
-    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
-
-pyvisa: ModuleType | None = _pyvisa_runtime  # type: ignore
-
-
-class VisaBackend(AdapterBackend):
-    def __init__(self, descriptor: VisaDescriptor):
-        """
-        USB VISA stack adapter
-        """
-        super().__init__(descriptor=descriptor)
-        self.descriptor: VisaDescriptor
-
-        if pyvisa is None:
-            raise ImportError(
-                "Missing optional dependency 'pyvisa'. Install with:\n"
-                "  python -m pip install pyvisa"
-            )
-
-        # Safe: guarded above, so mypy knows pyvisa is a module here
-        self._rm = pyvisa.ResourceManager()
-        self._inst: Resource | None = None  # annotation only; no runtime import needed
-
-        # We need a socket pair because VISA doesn't expose a selectable fileno/socket
-        # So we create a thread to read data and push that to the socket
-        self._notify_recv, self._notify_send = socket.socketpair()
-        self._notify_recv.setblocking(False)
-        self._notify_send.setblocking(False)
-
-        self._stop_lock = threading.Lock()
-        self.stop = False
-
-        self._fragment_lock = threading.Lock()
-        self._fragment = Fragment(b"", None)
-        self._event_queue: queue.Queue[AdapterSignal] = queue.Queue()
-
-    @classmethod
-    def list_devices(cls: type[VisaBackend]) -> list[str]:
-        """
-        Returns a list of available VISA devices
-        """
-        if pyvisa is None:
-            raise ImportError(
-                "Missing optional dependency 'pyvisa'. Install with:\n"
-                "  python -m pip install pyvisa"
-            )
-
-        rm = pyvisa.ResourceManager()
-        available_resources: list[str] = []
-        for device in rm.list_resources():
-            try:
-                d = rm.open_resource(device)
-                d.close()
-                available_resources.append(device)
-            except pyvisa.VisaIOError:
-                # Device cannot be opened; skip it
-                pass
-
-        return available_resources
-
-    def flush_read(self) -> bool:
-        super().flush_read()
-        while not self._event_queue.empty():
-            self._event_queue.get()
-        return True
-
-    def open(self) -> bool:
-        output = False
-        if self._inst is None:
-            # NOTE: self._rm is always defined in __init__ when pyvisa is present
-            self._inst = self._rm.open_resource(self.descriptor.descriptor)
-
-        if self._status == AdapterBackendStatus.DISCONNECTED:
-            # These attributes exist on pyvisa resources
-            self._inst.write_termination = ""
-            self._inst.read_termination = None
-
-            self._inst_lock = threading.Lock()
-            self._status = AdapterBackendStatus.CONNECTED
-
-        if self._thread is None:
-            self._thread = threading.Thread(
-                target=self._internal_thread,
-                args=(self._inst, self._event_queue),
-                daemon=True,
-            )
-            self._thread.start()
-            output = True
-
-        return output
-
-    def close(self) -> bool:
-        super().close()
-        with self._inst_lock:
-            if self._inst is not None:
-                self._inst.close()
-        self._status = AdapterBackendStatus.DISCONNECTED
-        with self._stop_lock:
-            self.stop = True
-        return True
-
-    def write(self, data: bytes) -> bool:
-        super().write(data)
-        with self._inst_lock:
-            if self._inst is not None:
-                self._inst.write_raw(data)
-        return True
-
-    def _socket_read(self) -> Fragment:
-        self._notify_recv.recv(1)
-        if not self._event_queue.empty():
-            event = self._event_queue.get()
-            if isinstance(event, AdapterDisconnected):
-                return Fragment(b"", None)
-
-        with self._fragment_lock:
-            output = self._fragment
-            self._fragment = Fragment(b"", None)
-            return output
-
-    def _internal_thread(
-        self,
-        inst: Resource,
-        event_queue: queue.Queue[AdapterSignal],
-    ) -> None:
-        assert pyvisa is not None  # for type-narrowing inside this method
-        timeout = 2000
-        while True:
-            payload = b""
-            with self._fragment_lock:
-                self._fragment = Fragment(b"", None)
-            try:
-                inst.timeout = timeout
-            except pyvisa.InvalidSession:
-                pass
-            try:
-                while True:
-                    # Read up to an error
-                    payload += inst.read_bytes(1)
-                    inst.timeout = 0
-            except pyvisa.VisaIOError:
-                # Timeout
-                if payload:
-                    with self._fragment_lock:
-                        if self._fragment.timestamp is None:
-                            self._fragment.timestamp = time.time()
-                            self._fragment.data += payload
-                    # Tell the session that there's data (write to a virtual socket)
-                    self._notify_send.send(b"1")
-            except (TypeError, pyvisa.InvalidSession, BrokenPipeError):
-                event_queue.put(AdapterDisconnected())
-                self._notify_send.send(b"1")
-            with self._stop_lock:
-                if self.stop:
-                    break
-
-    def selectable(self) -> HasFileno | None:
-        return self._notify_recv
-
-    def is_opened(self) -> bool:
-        if self._inst is None:
-            return False
-        else:
-            return self._status == AdapterBackendStatus.CONNECTED

syndesi/adapters/ip_server.py

@@ -1,102 +0,0 @@
-# File : ip_server.py
-# Author : Sébastien Deriaz
-# License : GPL
-#
-# IP server, WIP
-
-
-# NOTE : The adapter is only meant to work with a single client, thus
-# a IPServer class is made to handle the socket and generate IP adapters
-
-# class IPServer:
-#     DEFAULT_BUFFER_SIZE = 1024
-#     class Protocol(Enum):
-#         TCP = 'TCP'
-#         UDP = 'UDP'
-
-#     def __init__(self,
-#                 port : int = None,
-#                 transport : str = 'TCP',
-#                 address : str = None,
-#                 max_clients : int = 5,
-#                 stop_condition = None,
-#                 alias : str = '',
-#                 buffer_size : int = DEFAULT_BUFFER_SIZE):
-
-#         """
-#         IP server adapter
-
-#         Parameters
-#         ----------
-#         port : int
-#             IP port. If None, the default port set with set_default_port will be used
-#         transport : str
-#             'TCP' or 'UDP'
-#         address : str
-#             Custom socket ip, None by default
-#         max_clients : int
-#             Maximum number of clients, 5 by default
-#         stop_condition : StopCondition
-#             Specify a read stop condition (None by default)
-#         alias : str
-#             Specify an alias for this adapter, '' by default
-#         buffer_size : int
-#             Socket buffer size, may be removed in the future
-#         """
-#         self._alias = alias
-#         self._stop_condition = stop_condition
-#         self._logger = logging.getLogger(LoggerAlias.ADAPTER.value)
-#         self._transport = self.Protocol(transport)
-#         if self._transport == self.Protocol.TCP:
-#             self._logger.info("Setting up TCP IP server adapter")
-#             self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-#         elif self._transport == self.Protocol.UDP:
-#             self._logger.info("Setting up UDP IP server adapter")
-#             self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-#         else:
-#             raise ValueError("Invalid protocol")
-
-#         self._address = socket.gethostname() if address is None else address
-#         self._port = port
-#         self._max_clients = max_clients
-#         self._opened = False
-
-
-#     def set_default_port(self, port):
-#         """
-#         Sets IP port if no port has been set yet.
-
-#         This way, the user can leave the port empty
-#         and the driver/protocol can specify it later
-
-#         Parameters
-#         ----------
-#         port : int
-#         """
-#         if self._port is None:
-#             self._port = port
-
-
-#     def open(self):
-#         if self._port is None:
-#             raise ValueError(f"Cannot open adapter without specifying a port")
-#         self._logger.info(f"Listening to incoming connections on {self._address}:{self._port}")
-#         self._socket.bind((self._address, self._port))
-#         self._socket.listen(self._max_clients)
-#         self._opened = True
-
-#     def close(self):
-#         if hasattr(self, '_socket'):
-#             self._socket.close()
-#         self._logger.info("Adapter closed !")
-#         self._opened = False
-
-#     def get_client(self, stop_condition : StopConditionBackend = None, timeout : Timeout = None) -> IP:
-#         """
-#         Wait for a client to connect to the server and return the corresponding adapter
-#         """
-#         if not self._opened:
-#             raise RuntimeError("open() must be called before getting client")
-#         client_socket, address = self._socket.accept()
-#         default_timeout = Timeout(response=None, continuation=IP.DEFAULT_CONTINUATION_TIMEOUT, total=None)
-#         return IP(_socket=client_socket, address=address, stop_condition=stop_condition, timeout=timeout_fuse(timeout, default_timeout))

syndesi/adapters/stop_condition.py

@@ -1,90 +0,0 @@
-# File : stop_condition.py
-# Author : Sébastien Deriaz
-# License : GPL
-
-from abc import abstractmethod
-from enum import Enum
-
-class StopConditionType(Enum):
-    TERMINATION = "termination"
-    LENGTH = "length"
-    TIMEOUT = "timeout"
-
-class StopCondition:
-    @abstractmethod
-    def type(self) -> StopConditionType:
-        pass
-
-    def __init__(self) -> None:
-        """
-        A condition to stop reading from a device
-
-        Cannot be used on its own
-        """
-
-
-class Termination(StopCondition):
-    def __init__(self, sequence: bytes | str) -> None:
-        """
-        Stop reading once the desired sequence is detected
-
-        Parameters
-        ----------
-        sequence : bytes
-        """
-        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)}")
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
-    def __str__(self) -> str:
-        return f"Termination({repr(self.sequence)})"
-
-    def type(self) -> StopConditionType:
-        return StopConditionType.TERMINATION
-
-
-class Length(StopCondition):
-    def __init__(self, N: int) -> None:
-        """
-        Stop condition when the desired number of bytes is reached or passed
-
-        Parameters
-        ----------
-        N : int
-            Number of bytes
-        """
-        self.N = N
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
-    def __str__(self) -> str:
-        return f"Length({self.N})"
-
-    def type(self) -> StopConditionType:
-        return StopConditionType.LENGTH
-
-
-class Continuation(StopCondition):
-    def __init__(self, time: float) -> None:
-        super().__init__()
-        self.continuation = time
-
-    def type(self) -> StopConditionType:
-        return StopConditionType.TIMEOUT
-
-
-class Total(StopCondition):
-    def __init__(self, time: float) -> None:
-        super().__init__()
-        self.total = time
-
-    def type(self) -> StopConditionType:
-        return StopConditionType.TIMEOUT