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

syndesi/adapters/backend/ip_backend.py

@@ -1,149 +0,0 @@
-# File : ip.py
-# Author : Sébastien Deriaz
-# License : GPL
-#
-# The IP backend communicates with TCP or UDP capable hosts using the IP layer
-
-import socket
-import time
-from typing import cast
-
-import _socket
-
-from ...tools.backend_api import AdapterBackendStatus, Fragment
-from .adapter_backend import AdapterBackend, HasFileno
-from .descriptors import IPDescriptor
-
-
-class IPBackend(AdapterBackend):
-    BUFFER_SIZE = 65507
-    # _DEFAULT_BUFFER_SIZE = 1024
-    # DEFAULT_TIMEOUT = TimeoutBackend(
-    #     response=5,
-    #     action="error"
-    # )
-    DEFAULT_STOP_CONDITION = None
-
-    def __init__(self, descriptor: IPDescriptor):
-        """
-        IP stack adapter
-
-        Parameters
-        ----------
-        address : str
-            IP description
-        port : int
-            IP port
-        transport : str
-            'TCP' or 'UDP'
-        timeout : Timeout | float
-            Specify communication timeout
-        stop_condition : StopCondition
-            Specify a read stop condition (None by default)
-        buffer_size : int
-            Socket buffer size, may be removed in the future
-        socket : socket.socket
-            Specify a custom socket, this is reserved for server application
-        """
-        super().__init__(descriptor=descriptor)
-        self.descriptor: IPDescriptor
-
-        self._logger.info(f"Setting up {self.descriptor} adapter ")
-
-        self._socket: _socket.socket | None = None
-
-    def selectable(self) -> HasFileno | None:
-        return self._socket
-
-    def open(self) -> bool:
-        output = False
-        if self._status == AdapterBackendStatus.DISCONNECTED:
-            if self.descriptor.port is None:  # TODO : Check if this is even possible
-                raise ValueError("Cannot open adapter without specifying a port")
-
-            if self._socket is None:
-                if self.descriptor.transport == IPDescriptor.Transport.TCP:
-                    self._socket = cast(
-                        _socket.socket,
-                        socket.socket(socket.AF_INET, socket.SOCK_STREAM),
-                    )
-                elif self.descriptor.transport == IPDescriptor.Transport.UDP:
-                    self._socket = cast(
-                        _socket.socket, socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-                    )
-                else:
-                    raise ValueError(
-                        f"Invalid transport protocol : {self.descriptor.transport}"
-                    )
-            try:
-                self._socket.settimeout(
-                    0.5
-                )  # TODO : Configure this cleanly, it has to be less than the receive timeout of the frontend
-                self._socket.connect((self.descriptor.address, self.descriptor.port))
-            except OSError as e:  # TODO : Maybe change the exception ?
-                self._logger.error(f"Failed to open adapter {self.descriptor} : {e}")
-            else:
-                self._status = AdapterBackendStatus.CONNECTED
-                self._logger.info(f"IP Adapter {self.descriptor} opened")
-                output = True
-        else:
-            self._logger.info(f"Adapter {self.descriptor} already openend")
-            output = True
-
-        return output
-
-    def close(self) -> bool:
-        super().close()
-
-        self._status = AdapterBackendStatus.DISCONNECTED
-        if self._socket is not None:
-            self._socket.close()
-            self._socket = None
-            self._logger.info(f"Adapter {self.descriptor} closed")
-            return True
-        else:
-            self._logger.error(f"Failed to close adapter {self.descriptor}")
-            return False
-
-    def write(self, data: bytes) -> bool:
-        super().write(data)
-
-        # TODO : Manage adapter reopen
-        # if self._status == AdapterBackendStatus.DISCONNECTED:
-        #     self._logger.info("Adapter is closed, opening...")
-        #     self.open()
-
-        # Socket send
-        if self._socket is None:
-            self._logger.error(f"Cannot write to closed adapter {self.descriptor}")
-            return False
-        try:
-            self._socket.send(data)
-        except (BrokenPipeError, OSError) as e:
-            # Socket has been disconnected by the remote peer
-            self._logger.error(f"Failed to write to adapter {self.descriptor} ({e})")
-            self.close()
-            return False
-        else:
-            return True
-
-    def _socket_read(self) -> Fragment:
-        # This function is called only if the socket was ready
-        t = time.time()
-        if self._socket is None:
-            return Fragment(b"", t)
-        else:
-            try:
-                fragment = Fragment(self._socket.recv(self.BUFFER_SIZE), t)
-            except (ConnectionRefusedError, OSError):
-                fragment = Fragment(b"", t)
-
-            if fragment.data == b"":
-                # Socket disconnected
-                self._logger.debug("## Socket disconnected")
-                self.close()
-
-        return fragment
-
-    def is_opened(self) -> bool:
-        return self._status == AdapterBackendStatus.CONNECTED

syndesi/adapters/backend/serialport_backend.py

@@ -1,241 +0,0 @@
-# File : serialport.py
-# Author : Sébastien Deriaz
-# License : GPL
-#
-# The SerialPort backend communicates with serial devices using the serial package
-
-import time
-
-import serial
-from serial.serialutil import PortNotOpenError
-
-from syndesi.tools.backend_api import AdapterBackendStatus, Fragment
-
-from .adapter_backend import AdapterBackend, HasFileno
-from .descriptors import SerialPortDescriptor
-
-
-class SerialPortBackend(AdapterBackend):
-    def __init__(self, descriptor: SerialPortDescriptor):
-        """
-        Serial communication adapter
-
-        Parameters
-        ----------
-        port : str
-            Serial port (COMx or ttyACMx)
-        """
-        super().__init__(descriptor=descriptor)
-        self.descriptor: SerialPortDescriptor
-        self._logger.info(f"Setting up SerialPort adapter {self.descriptor}")
-        self._port: serial.Serial | None = None
-        self._rts_cts = False
-
-        self.open()
-
-    def set_baudrate(self, baudrate: int) -> None:
-        """
-        Set baudrate
-
-        Parameters
-        ----------
-        baudrate : int
-        """
-        self.descriptor.baudrate = baudrate
-
-        if self.is_opened():
-            self.close()
-            self.open()
-
-    # TODO : Check if this is still necessary, it's probably more of a frontend thing
-    def set_default_baudrate(self, baudrate: int) -> None:
-        """
-        Sets the default baudrate
-
-        Parameters
-        ----------
-        baudrate : int
-        """
-        self.descriptor.set_default_baudrate(baudrate)
-
-    def flush_read(self) -> bool:
-        super().flush_read()
-        if self._port is None:
-            return False
-        else:
-            self._port.flush()
-            return True
-
-    def set_rtscts(self, enabled: bool) -> None:
-        self._rts_cts = enabled
-        if self.is_opened():
-            self.close()
-            self.open()
-
-    def open(self) -> bool:
-        if self.descriptor.baudrate is None:
-            raise ValueError("Baudrate must be set, please use set_baudrate")
-
-        if self._port is None:
-            self._port = serial.Serial(
-                port=self.descriptor.port,
-                baudrate=self.descriptor.baudrate,
-                rtscts=self._rts_cts,
-            )
-        elif not self._port.isOpen():  # type: ignore
-            self._port.open()
-
-        if self._port.isOpen():  # type: ignore
-            self._logger.info(f"Adapter {self.descriptor} opened")
-            self._status = AdapterBackendStatus.CONNECTED
-            return True
-        else:
-            self._logger.error(f"Failed to open adapter {self.descriptor}")
-            self._status = AdapterBackendStatus.DISCONNECTED
-            return False
-
-    def close(self) -> bool:
-        super().close()
-        if hasattr(self, "_port") and self._port is not None:
-            # Close and the read thread will die by itself
-            self._port.close()
-            self._logger.info("Adapter closed")
-            return True
-        else:
-            return False
-
-    def write(self, data: bytes) -> bool:
-        super().write(data)
-        if self._port is None:
-            self._logger.error(f"Cannot write to closed adapter {self.descriptor}")
-            return False
-        else:
-            if self._rts_cts:  # Experimental
-                self._port.setRTS(True)  # type: ignore
-            # TODO : Implement auto open
-            # if self._status == AdapterBackendStatus.DISCONNECTED:
-            #     self.open()
-            # write_start = time.time()
-            try:
-                self._port.write(data)
-            except (OSError, PortNotOpenError):
-                return False
-            #            write_duration = time.time() - write_start
-            # self._logger.debug(f"Write [{write_duration * 1e3:.3f}ms]: {repr(data)}")
-
-            return True
-
-    def _socket_read(self) -> Fragment:
-        t = time.time()
-
-        if self._port is None:
-            self._logger.debug('Port is None -> b""')
-            return Fragment(b"", t)
-        else:
-            try:
-                data = self._port.read_all()
-            except (OSError, PortNotOpenError):
-                self._logger.debug('Port error -> b""')
-                return Fragment(b"", t)
-            else:
-                # This is a test, it seems b"" happens sometimes and disconnects the adapter
-                if data is not None and data != b"":
-                    return Fragment(data, t)
-                else:
-                    return Fragment(b"", t)
-                    # self._logger.debug('Data is none -> b""')
-                # else:
-                #     self._logger.debug(f'{data=}')
-
-    # def _start_thread(self):
-    #     """
-    #     Start the read thread
-    #     """
-    #     #super()._start_thread()
-    #     if self._thread is None or not self._thread.is_alive():
-    #         self._thread = Thread(
-    #             target=self._read_thread,
-    #             daemon=True,
-    #             args=(self._port, self._read_queue, self._thread_commands_read),
-    #         )
-    #         self._thread.start()
-
-    # def _read_thread(
-    #     self,
-    #     port: serial.Serial,
-    #     read_queue: TimedQueue,
-    #     thread_commands: socket.socket,
-    # ):
-    #     # On linux, it is possivle to use the select.select for both serial port and stop socketpair.
-    #     # On Windows, this is not possible. so the port timeout is used instead.
-    #     if sys.platform == "win32":
-    #         port.timeout = 0.1
-    #     while True:
-    #         # Check how many bytes are available
-    #         if sys.platform == "win32":
-    #             ready, _, _ = select.select([thread_commands], [], [], 0)
-    #             if thread_commands in ready:
-    #                 # Stop the read thread
-    #                 break
-    #             else:
-    #                 # Read data from the serialport with a timeout, if the timeout occurs, read again.
-    #                 # This is to avoid having a crazy fast loop
-    #                 fragment = port.read()
-    #                 if len(fragment) > 0:
-    #                     read_queue.put(fragment)
-    #         else:
-    #             ready, _, _ = select.select([self._port.fd, thread_commands], [], [])
-    #             if thread_commands in ready:
-    #                 command = self.ThreadCommands(thread_commands.recv(1))
-    #                 if command == self.ThreadCommands.STOP:
-    #                     # Stop the read thread
-    #                     break
-    #             elif self._port.fd in ready:
-    #                 try:
-    #                     in_waiting = self._port.in_waiting
-    #                 except OSError:
-    #                     # Input/output error, the port was disconnected
-    #                     read_queue.put(AdapterDisconnected)
-    #                 else:
-    #                     fragment = port.read(in_waiting)
-    #                     if fragment:
-    #                         read_queue.put(fragment)
-
-    # def read(
-    #     self, timeout=..., stop_condition=..., full_output: bool = False
-    # ) -> bytes:
-    #     """
-    #     Read data from the device
-
-    #     Parameters
-    #     ----------
-    #     timeout : Timeout or None
-    #         Set a custom timeout, if None (default), the adapter timeout is used
-    #     stop_condition : StopCondition or None
-    #         Set a custom stop condition, if None (Default), the adapater stop condition is used
-    #     full_output : bool
-    #         Return a dictionary containing information about the read operation like
-    #             'read_duration' : float
-    #             'origin' : 'timeout' or 'stop_condition'
-    #             'timeout' : Timeout.TimeoutType
-    #             'stop_condition' : Length or Termination (StopCondition class)
-    #             'previous_read_buffer_used' : bool
-    #             'n_fragments' : int
-    #     """
-    #     output = super().read(timeout, stop_condition, full_output)
-    #     if self._rts_cts:  # Experimental
-    #         self._port.setRTS(False)
-    #     return output
-
-    def is_opened(self) -> bool:
-        if self._port is not None:
-            if self._port.isOpen():  # type: ignore
-                return True
-
-        return False
-
-    def selectable(self) -> HasFileno | None:
-        if self._port is not None and self.is_opened():
-            return self._port
-        else:
-            return None

syndesi/adapters/backend/stop_condition_backend.py

@@ -1,219 +0,0 @@
-# File : stop_condition.py
-# Author : Sébastien Deriaz
-# License : GPL
-#
-# A stop-condition describes when a communication with a device should
-# be stopped based on the data received (length, contents, termination, etc...)
-# A stop-condition can also format the data if necessary (remove termination for example)
-
-import time
-
-from syndesi.adapters.stop_condition import (
-    Continuation,
-    Length,
-    StopCondition,
-    StopConditionType,
-    Termination,
-    Total,
-)
-
-from ...tools.backend_api import Fragment
-
-
-def termination_in_data(termination: bytes, data: bytes) -> tuple[int | None, int]:
-    """
-    Return the position (if it exists) and length of the termination (or part of it) inside data
-    """
-    p = None
-    L = len(termination)
-    # First check if the full termination is somewhere. If that's the case, data will be split
-    try:
-        p = data.index(termination)
-        # If found, return that
-    except ValueError:
-        # If not, we'll try to find if part of the sequence is at the end, in that case
-        # we'll return the length of the sequence that was found
-        L -= 1
-        while L > 0:
-            if data[-L:] == termination[:L]:
-                p = len(data) - L  # - 1
-                break
-            L -= 1
-
-    return p, L
-
-
-class StopConditionBackend:
-    def __init__(self) -> None:
-        pass
-
-    def initiate_read(self) -> None:
-        raise NotImplementedError()
-
-    def evaluate(
-        self, raw_fragment: Fragment
-    ) -> tuple[bool, Fragment, Fragment, float | None]:
-        raise NotImplementedError()
-
-    def type(self) -> StopConditionType:
-        raise NotImplementedError()
-
-    def flush_read(self) -> None:
-        raise NotImplementedError()
-
-
-class TerminationBackend(StopConditionBackend):
-    def __init__(self, sequence: bytes) -> None:
-        super().__init__()
-        self._sequence = sequence
-        self._sequence_found_length = 0
-
-    def initiate_read(self) -> None:
-        # Termination
-        self._sequence_found_length = 0
-
-    def flush_read(self) -> None:
-        self._sequence_found_length = 0
-
-    def evaluate(
-        self, raw_fragment: Fragment
-    ) -> tuple[bool, Fragment, Fragment, float | None]:
-        if raw_fragment.data is None:
-            raise RuntimeError("Trying to evaluate an invalid fragment")
-
-        position, length = termination_in_data(
-            self._sequence[self._sequence_found_length :], raw_fragment.data
-        )
-        stop = False
-        deferred = Fragment(b"", None)
-
-        if position is None:
-            # Nothing was found, keep everything
-            kept = raw_fragment
-        else:
-            self._sequence_found_length += length
-
-            if self._sequence_found_length == len(self._sequence):
-                # The sequence was found entirely
-                deferred = raw_fragment[position + length :]
-                self._sequence_found_length = 0
-                stop = True
-            elif position + length == len(raw_fragment.data):
-                # Part of the sequence was found at the end
-                # Return what's before the sequence
-                deferred = Fragment(b"", None)
-
-            kept = raw_fragment[:position]
-
-        return stop, kept, deferred, None
-
-    def type(self) -> StopConditionType:
-        return StopConditionType.TERMINATION
-
-
-class LengthBackend(StopConditionBackend):
-    def __init__(self, N: int) -> None:
-        super().__init__()
-        self._N = N
-        self._counter = 0
-
-    def initiate_read(self) -> None:
-        # Length
-        self._counter = 0
-
-    def flush_read(self) -> None:
-        self._counter = 0
-
-    def evaluate(
-        self, raw_fragment: Fragment
-    ) -> tuple[bool, Fragment, Fragment, float | None]:
-        remaining_bytes = self._N - self._counter
-        kept_fragment = raw_fragment[:remaining_bytes]
-        deferred_fragment = raw_fragment[remaining_bytes:]
-        self._counter += len(kept_fragment.data)
-        remaining_bytes = self._N - self._counter
-        # TODO : remaining_bytes <= 0 ? Alongside above TODO maybe
-        return remaining_bytes == 0, kept_fragment, deferred_fragment, None
-
-    def type(self) -> StopConditionType:
-        return StopConditionType.LENGTH
-
-
-class ContinuationBackend(StopConditionBackend):
-    def __init__(self, time: float) -> None:
-        super().__init__()
-        self._continuation = time
-        self._last_fragment: float | None = None
-
-    def initiate_read(self) -> None:
-        self._last_fragment = time.time()
-
-    def flush_read(self) -> None:
-        self._last_fragment = None
-
-    def evaluate(
-        self, raw_fragment: Fragment
-    ) -> tuple[bool, Fragment, Fragment, float | None]:
-        deferred = Fragment(b"", None)
-        kept = raw_fragment
-
-        if raw_fragment.timestamp is None:
-            raise RuntimeError("Cannot evaluate fragment with no timestamp")
-        # last_fragment can be none if no data was ever received
-        if self._last_fragment is not None:
-            continuation_timestamp = self._last_fragment + self._continuation
-            stop = continuation_timestamp <= raw_fragment.timestamp
-            next_event_timeout = continuation_timestamp
-        else:
-            stop = False
-            next_event_timeout = None
-
-        return stop, kept, deferred, next_event_timeout
-
-    def type(self) -> StopConditionType:
-        return StopConditionType.TIMEOUT
-
-
-class TotalBackend(StopConditionBackend):
-    def __init__(self, time: float) -> None:
-        super().__init__()
-        self._total = time
-        self._start_time: float | None = None
-
-    def initiate_read(self) -> None:
-        self._start_time = time.time()
-
-    def flush_read(self) -> None:
-        self._start_time = None
-
-    def evaluate(
-        self, raw_fragment: Fragment
-    ) -> tuple[bool, Fragment, Fragment, float | None]:
-        kept = raw_fragment
-        deferred = Fragment(b"", None)
-
-        if raw_fragment.timestamp is None:
-            raise RuntimeError("Cannot evaluate fragment with no timestamp")
-
-        if self._start_time is None:
-            raise RuntimeError("Invalid start time")
-        total_timestamp = self._start_time + self._total
-        stop = total_timestamp <= raw_fragment.timestamp
-
-        return stop, kept, deferred, total_timestamp
-
-    def type(self) -> StopConditionType:
-        return StopConditionType.TIMEOUT
-
-
-def stop_condition_to_backend(stop_condition: StopCondition) -> StopConditionBackend:
-    if isinstance(stop_condition, Termination):
-        return TerminationBackend(stop_condition.sequence)
-    elif isinstance(stop_condition, Length):
-        return LengthBackend(stop_condition.N)
-    elif isinstance(stop_condition, Continuation):
-        return ContinuationBackend(stop_condition.continuation)
-    elif isinstance(stop_condition, Total):
-        return TotalBackend(stop_condition.total)
-    else:
-        raise RuntimeError(f"Invalid stop condition : {stop_condition}")

syndesi/adapters/backend/timed_queue.py

@@ -1,39 +0,0 @@
-# File : timed_queue.py
-# Author : Sébastien Deriaz
-# License : GPL
-#
-# The timed queue is a special queue that stores time information when elements are stored inside
-# This is used to manage timing when reading data from devices
-
-# import queue
-# from time import time
-
-
-# class TimedQueue:
-#     def __init__(self) -> None:
-#         self._queue = queue.Queue()
-
-#     def put(self, fragment: bytes) -> None:
-#         self._queue.put((time(), fragment))
-
-#     def get(self, timeout: float | None) -> tuple[float, bytes]:
-#         """
-#         Return an element of the timed queue. Waits at most the amount of time specified by timeout
-
-#         Parameters
-#         ----------
-#         timeout : float, None
-#         """
-#         try:
-#             return self._queue.get(block=True, timeout=timeout)
-#         except queue.Empty:  # No item after timeout
-#             return None, None
-
-#     def is_empty(self):
-#         return self._queue.empty()
-
-#     def clear(self):
-#         with self._queue.mutex:
-#             self._queue.queue.clear()
-#             self._queue.all_tasks_done.notify_all()
-#             self._queue.unfinished_tasks = 0