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

syndesi/adapters/backend/adapter_session.py

@@ -11,9 +11,11 @@ import threading
 import time
 from enum import Enum
 from multiprocessing.connection import Pipe, wait
-from typing import Any, Tuple
+from typing import Any
 
-from syndesi.adapters.backend.stop_condition_backend import StopConditionBackend, stop_condition_to_backend
+from syndesi.adapters.backend.stop_condition_backend import (
+    stop_condition_to_backend,
+)
 from syndesi.tools.errors import make_error_description
 from syndesi.tools.types import NumberLike
 
@@ -21,9 +23,6 @@ from ...tools.backend_api import Action, frontend_send
 from ...tools.log_settings import LoggerAlias
 from .adapter_backend import (
     AdapterBackend,
-    AdapterDisconnected,
-    #AdapterReadInit,
-    AdapterReadPayload,
     Selectable,
     nmin,
 )
@@ -37,15 +36,16 @@ from .descriptors import (
 )
 from .ip_backend import IPBackend
 from .serialport_backend import SerialPortBackend
-#from .stop_condition_backend import stop_condition_from_list
+
+# from .stop_condition_backend import stop_condition_from_list
 from .visa_backend import VisaBackend
-from pathlib import Path
 
 
 class TimeoutEvent(Enum):
     MONITORING = 0
     ADAPTER = 1
-    #CONNECTIONS = 2
+    # CONNECTIONS = 2
+
 
 def get_adapter(descriptor: Descriptor) -> AdapterBackend:
     # The adapter doesn't exist, create it
@@ -99,12 +99,10 @@ class AdapterSession(threading.Thread):
             self._shutdown_counter_top = None
             self._shutdown_counter = None
 
-        #self._timeout_events: list[tuple[TimeoutEvent, float]] = []
+        # self._timeout_events: list[tuple[TimeoutEvent, float]] = []
 
         self._read_init_id = 0
 
-
-
     def add_connection(self, conn: NamedConnection) -> None:
         with self._connections_lock:
             self.connections.append(conn)
@@ -142,13 +140,12 @@ class AdapterSession(threading.Thread):
             except Exception as e:
                 error_message = make_error_description(e)
 
-
                 self._logger.critical(
                     f"Error in {self._adapter.descriptor} session loop : {error_message}"
                 )
                 try:
                     error_message = make_error_description(e)
-                        
+
                     for conn in self.connections:
                         frontend_send(conn.conn, Action.ERROR_GENERIC, error_message)
                 except Exception:
@@ -167,15 +164,13 @@ class AdapterSession(threading.Thread):
         # The wait has a timeout set by the adapter, it corresponds to the current continuation/total timeout
 
         # Create a list of what is awaited
-        wait_list: list[Selectable] = [
-            conn.conn for conn in self.connections
-        ]
+        wait_list: list[Selectable] = [conn.conn for conn in self.connections]
         adapter_fd = self._adapter.selectable()
         if adapter_fd is not None and adapter_fd.fileno() >= 0:
             wait_list.append(adapter_fd)
 
         wait_list.append(self._new_connection_r)
-    
+
         timeout_timestamp = None
         event = None
 
@@ -183,8 +178,11 @@ class AdapterSession(threading.Thread):
         if adapter_timestamp is not None:
             timeout_timestamp = nmin(timeout_timestamp, adapter_timestamp)
             event = TimeoutEvent.ADAPTER
-        
-        if timeout_timestamp is None or self._next_monitoring_timestamp < timeout_timestamp:
+
+        if (
+            timeout_timestamp is None
+            or self._next_monitoring_timestamp < timeout_timestamp
+        ):
             timeout_timestamp = self._next_monitoring_timestamp
             event = TimeoutEvent.MONITORING
 
@@ -253,7 +251,6 @@ class AdapterSession(threading.Thread):
             return
         try:
             request = conn.conn.recv()
-            request_timestamp = time.time()
         except (EOFError, ConnectionResetError) as e:
             # Probably a ping or an error
             self._logger.warning(
@@ -280,7 +277,7 @@ class AdapterSession(threading.Thread):
                                 response_action = Action.OPEN
                             else:
                                 response_action = Action.ERROR_FAILED_TO_OPEN
-                            extra_arguments = ("",)                            
+                            extra_arguments = ("",)
                         case Action.WRITE:
                             data = request[1]
                             if self._adapter.is_opened():
@@ -301,12 +298,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:
-                            self._adapter.set_stop_conditions([
-                                stop_condition_to_backend(sc) for sc in request[1]
-                                ])
+                        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:
@@ -315,7 +312,9 @@ class AdapterSession(threading.Thread):
                         case Action.START_READ:
                             response_time = float(request[1])
                             self._adapter.start_read(response_time, self._read_init_id)
-                            response_action, extra_arguments = Action.START_READ, (self._read_init_id,)
+                            response_action, extra_arguments = Action.START_READ, (
+                                self._read_init_id,
+                            )
                             self._read_init_id += 1
 
                         # case Action.GET_BACKEND_TIME:

syndesi/adapters/backend/backend_tools.py

@@ -1,9 +1,9 @@
 import socket
 from multiprocessing.connection import Connection
 
-
 BACKEND_REQUEST_DEFAULT_TIMEOUT = 0.5
 
+
 def get_conn_addresses(conn: Connection) -> tuple[tuple[str, int], tuple[str, int]]:
     try:
         fd = conn.fileno()

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/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/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
@@ -33,7 +33,6 @@ class SerialPortBackend(AdapterBackend):
 
         self.open()
 
-
     def set_baudrate(self, baudrate: int) -> None:
         """
         Set baudrate
@@ -83,10 +82,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,17 +111,17 @@ 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()
-            #write_start = time.time()
+            # 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)}")
+            #            write_duration = time.time() - write_start
+            # self._logger.debug(f"Write [{write_duration * 1e3:.3f}ms]: {repr(data)}")
 
             return True
 
@@ -144,7 +143,7 @@ class SerialPortBackend(AdapterBackend):
                     return Fragment(data, t)
                 else:
                     return Fragment(b"", t)
-                    #self._logger.debug('Data is none -> b""')
+                    # self._logger.debug('Data is none -> b""')
                 # else:
                 #     self._logger.debug(f'{data=}')
 
@@ -230,7 +229,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/adapters/backend/stop_condition_backend.py

@@ -7,12 +7,19 @@
 # A stop-condition can also format the data if necessary (remove termination for example)
 
 import time
-from abc import abstractmethod
-from enum import Enum
 
-from syndesi.adapters.stop_condition import StopCondition, Termination, Length, Continuation, Total, StopConditionType
+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
@@ -29,7 +36,7 @@ def termination_in_data(termination: bytes, data: bytes) -> tuple[int | None, in
         L -= 1
         while L > 0:
             if data[-L:] == termination[:L]:
-                p = len(data) - L# - 1
+                p = len(data) - L  # - 1
                 break
             L -= 1
 
@@ -44,17 +51,19 @@ class StopConditionBackend:
         raise NotImplementedError()
 
     def evaluate(
-        self, raw_fragment: Fragment) -> tuple[bool, Fragment, Fragment, float | None]:
+        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:
+    def __init__(self, sequence: bytes) -> None:
         super().__init__()
         self._sequence = sequence
         self._sequence_found_length = 0
@@ -66,10 +75,12 @@ class TerminationBackend(StopConditionBackend):
     def flush_read(self) -> None:
         self._sequence_found_length = 0
 
-    def evaluate(self, raw_fragment: Fragment) -> tuple[bool, Fragment, Fragment, float | None]:
+    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
         )
@@ -93,26 +104,29 @@ class TerminationBackend(StopConditionBackend):
                 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:
+    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]:
+    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:]
@@ -120,23 +134,26 @@ class LengthBackend(StopConditionBackend):
         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:
+    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]:
+    def evaluate(
+        self, raw_fragment: Fragment
+    ) -> tuple[bool, Fragment, Fragment, float | None]:
         deferred = Fragment(b"", None)
         kept = raw_fragment
 
@@ -152,15 +169,16 @@ class ContinuationBackend(StopConditionBackend):
             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:
+    def __init__(self, time: float) -> None:
         super().__init__()
         self._total = time
-        self._start_time : float | None = None
+        self._start_time: float | None = None
 
     def initiate_read(self) -> None:
         self._start_time = time.time()
@@ -168,7 +186,9 @@ class TotalBackend(StopConditionBackend):
     def flush_read(self) -> None:
         self._start_time = None
 
-    def evaluate(self, raw_fragment: Fragment) -> tuple[bool, Fragment, Fragment, float | None]:
+    def evaluate(
+        self, raw_fragment: Fragment
+    ) -> tuple[bool, Fragment, Fragment, float | None]:
         kept = raw_fragment
         deferred = Fragment(b"", None)
 
@@ -181,11 +201,12 @@ class TotalBackend(StopConditionBackend):
         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:
+
+def stop_condition_to_backend(stop_condition: StopCondition) -> StopConditionBackend:
     if isinstance(stop_condition, Termination):
         return TerminationBackend(stop_condition.sequence)
     elif isinstance(stop_condition, Length):
@@ -195,4 +216,4 @@ def stop_condition_to_backend(stop_condition : StopCondition) -> StopConditionBa
     elif isinstance(stop_condition, Total):
         return TotalBackend(stop_condition.total)
     else:
-        raise RuntimeError(f'Invalid stop condition : {stop_condition}')
+        raise RuntimeError(f"Invalid stop condition : {stop_condition}")

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/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/adapters/stop_condition.py

@@ -2,26 +2,19 @@
 # Author : Sébastien Deriaz
 # License : GPL
 
-import json
 from abc import abstractmethod
 from enum import Enum
 
 class StopConditionType(Enum):
-    TERMINATION = 'termination'
-    LENGTH = 'length'
-    TIMEOUT = 'timeout'
-    #CONTINUATION = 'continuation'
-    #TOTAL = 'total'
-
-
-
+    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
@@ -29,13 +22,6 @@ class StopCondition:
         Cannot be used on its own
         """
 
-    # @abstractmethod
-    # def compose_json(self) -> str:
-    #     raise NotImplementedError
-
-    # def compose(self) -> dict:
-    #     raise NotImplementedError
-
 
 class Termination(StopCondition):
     def __init__(self, sequence: bytes | str) -> None:
@@ -54,25 +40,12 @@ class Termination(StopCondition):
         else:
             raise ValueError(f"Invalid termination sequence type : {type(sequence)}")
 
-    # def compose_json(self) -> str:
-    #     data = {
-    #         JsonKey.TYPE.value: StopConditionType.TERMINATION.value,
-    #         JsonKey.TERMINATION_SEQUENCE.value: self._sequence.decode("utf-8"),
-    #     }
-    #     return json.dumps(data)
-    
-    # def compose(self) -> dict:
-    #     return {
-    #         StopConditionDescriptorKey.TYPE.value: StopConditionType.TERMINATION.value,
-    #         StopConditionDescriptorKey.TERMINATION_SEQUENCE.value: self.sequence.decode("utf-8"),
-    #     }
-
     def __repr__(self) -> str:
         return self.__str__()
 
     def __str__(self) -> str:
         return f"Termination({repr(self.sequence)})"
-    
+
     def type(self) -> StopConditionType:
         return StopConditionType.TERMINATION
 
@@ -89,75 +62,29 @@ class Length(StopCondition):
         """
         self.N = N
 
-    # def compose_json(self) -> str:
-    #     data = {
-    #         JsonKey.TYPE.value: StopConditionType.LENGTH.value,
-    #         JsonKey.LENGTH_N.value: self._N,
-    #     }
-    #     return json.dumps(data)
-
-    # def compose(self) -> dict:
-    #     return {
-    #         StopConditionDescriptorKey.TYPE.value: StopConditionType.LENGTH.value,
-    #         StopConditionDescriptorKey.LENGTH_N.value: self.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:
+    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:
+    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