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

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
@@ -83,10 +83,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
@@ -100,7 +100,7 @@ class SerialPortBackend(AdapterBackend):
         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 !")
+            self._logger.info("Adapter closed")
             return True
         else:
             return False
@@ -112,17 +112,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
 
@@ -130,17 +130,23 @@ class SerialPortBackend(AdapterBackend):
         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):
-                return Fragment(b'', t)
+                self._logger.debug('Port error -> b""')
+                return Fragment(b"", t)
             else:
-                if data is None:
-                    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):
     #     """
@@ -224,7 +230,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

@@ -10,25 +10,9 @@ import time
 from abc import abstractmethod
 from enum import Enum
 
-from syndesi.adapters.stop_condition import StopCondition, Termination, Length, TimeoutStopCondition
+from syndesi.adapters.stop_condition import StopCondition, Termination, Length, Continuation, Total, StopConditionType
 
 from ...tools.backend_api import Fragment
-
-
-# class StopConditionType(Enum):
-#     TERMINATION = "termination"
-#     LENGTH = "length"
-#     LAMBDA = "lambda"
-#     TIMEOUT = "timeout"
-
-
-# class StopConditionDescriptorKey(Enum):
-#     TYPE = "type"
-#     TERMINATION_SEQUENCE = "sequence"
-#     LENGTH_N = "N"
-#     TIMEOUT_CONTINUATION = "tc"
-#     TIMEOUT_TOTAL = "tt"
-
 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
@@ -51,61 +35,43 @@ def termination_in_data(termination: bytes, data: bytes) -> tuple[int | None, in
 
     return p, L
 
-class StopConditionBackend:
-    def __init__(self, stop_condition : StopCondition) -> None:
-        self.stop_condition = stop_condition
-
-        # Termination
-        self._sequence_found_length = 0
-
-        # Length
-        self._counter = 0
 
-        # Timeout
-        self._start_time: float | None = None
-        self._last_fragment: float | None = None
+class StopConditionBackend:
+    def __init__(self) -> None:
+        pass
 
     def initiate_read(self) -> None:
-        # Termination
-        self._sequence_found_length = 0
-        # Length
-        self._counter = 0
-        # Timeout
-        self._start_time = time.time()
-        self._last_fragment = self._start_time
-
+        raise NotImplementedError()
 
     def evaluate(
         self, raw_fragment: Fragment) -> tuple[bool, Fragment, Fragment, float | None]:
+        raise NotImplementedError()
 
-        if isinstance(self.stop_condition, Termination):
-            return self._evaluate_termination(raw_fragment)
-        elif isinstance(self.stop_condition, Length):
-            return self._evaluate_length(raw_fragment)
-        elif isinstance(self.stop_condition, TimeoutStopCondition):
-            return self._evaluate_timeout(raw_fragment)
-        else:
-            raise RuntimeError(f"Invalid stop condition : {self.stop_condition}")
+    def type(self) -> StopConditionType:
+        raise NotImplementedError()
+    
+    def flush_read(self) -> None:
+        raise NotImplementedError()
 
-    def flush_read(self):
+class TerminationBackend(StopConditionBackend):
+    def __init__(self, sequence : bytes) -> None:
+        super().__init__()
+        self._sequence = sequence
         self._sequence_found_length = 0
-        self._counter = 0
-        self._start_time = None
-        self._last_fragment = None
 
-    def __repr__(self) -> str:
-        return self.__str__()
+    def initiate_read(self) -> None:
+        # Termination
+        self._sequence_found_length = 0
 
-    def __str__(self) -> str:
-        return self.stop_condition.__str__()
+    def flush_read(self) -> None:
+        self._sequence_found_length = 0
 
-    def _evaluate_termination(self, raw_fragment: Fragment) -> tuple[bool, Fragment, Fragment, float | None]:
-        self.stop_condition : Termination
+    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.stop_condition.sequence[self._sequence_found_length :], raw_fragment.data
+            self._sequence[self._sequence_found_length :], raw_fragment.data
         )
         stop = False
         deferred = Fragment(b"", None)
@@ -116,7 +82,7 @@ class StopConditionBackend:
         else:
             self._sequence_found_length += length
 
-            if self._sequence_found_length == len(self.stop_condition.sequence):
+            if self._sequence_found_length == len(self._sequence):
                 # The sequence was found entirely
                 deferred = raw_fragment[position + length :]
                 self._sequence_found_length = 0
@@ -129,214 +95,104 @@ class StopConditionBackend:
             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_length(self, raw_fragment: Fragment) -> tuple[bool, Fragment, Fragment, float | None]:
-        self.stop_condition : Length
-        remaining_bytes = self.stop_condition.N - self._counter
+    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.stop_condition.N - self._counter
+        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
 
-    def _evaluate_timeout(self, raw_fragment: Fragment) -> tuple[bool, Fragment, Fragment, float | None]:
-        self.stop_condition : TimeoutStopCondition
+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()
 
-        stop = False
-        kept = raw_fragment
+    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)
-        next_event_timeout = 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.stop_condition.continuation is not None and self._last_fragment is not None:
-            continuation_timestamp = self._last_fragment + self.stop_condition.continuation
-            stop |= continuation_timestamp <= raw_fragment.timestamp
+        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
-
-        if self.stop_condition.total is not None:
-            if self._start_time is None:
-                raise RuntimeError("Invalid start time")
-            total_timestamp = self._start_time + self.stop_condition.total
-            stop |= total_timestamp <= raw_fragment.timestamp
-            if next_event_timeout is None:
-                next_event_timeout = total_timestamp
-            else:
-                next_event_timeout = min(next_event_timeout, total_timestamp)
+        else:
+            stop = False
+            next_event_timeout = None
 
         return stop, kept, deferred, next_event_timeout
-
-
-
-
-    # @property
-    # @abstractmethod
-    # def _TYPE(self) -> StopConditionType:
-    #     raise NotImplementedError
-
-    # def __init__(self) -> None:
-    #     """
-    #     A condition to stop reading from a device
-
-    #     Cannot be used on its own
-    #     """
-    #     self._and = None
-    #     self._or = None
-
-    #     self._eval_time = None
-
-    # @abstractmethod
-    # def initiate_read(self) -> float | None:
-    #     """
-    #     Initiate a read sequence.
-
-    #     The maximum time that should be spent in the next byte read
-    #     is returned
-
-    #     Returns
-    #     -------
-    #     timeout : float or None
-    #         None is there's no timeout
-    #     """
-    #     pass
-
-    # @abstractmethod
-    # def evaluate(
-    #     self, raw_fragment: Fragment, timestamp: float
-    # ) -> tuple[bool, Fragment, Fragment, float | None]:
-    #     """
-    #     Evaluate the next received byte
-
-    #     Returns
-    #     -------
-    #     stop : bool
-    #         False if read should continue
-    #         True if read should stop
-    #     kept_fragment : bytes
-    #         Part of the fragment kept for future use
-    #     deferred_fragment : bytes
-    #         Part of the fragment that was deferred because of a stop condition
-    #     """
-    #     pass
-
-    # @abstractmethod
-    # def flush_read(self) -> None:
-    #     """
-    #     Flush input buffer and reset stop-condition
-    #     """
-    #     pass
-
-
-
-
-# class TerminationBackend(StopConditionBackend):
-#     # _TYPE = StopConditionType.TERMINATION
-#     def flush_read(self) -> None:
-#         self._sequence_found_length = 0
-
-#     def __repr__(self) -> str:
-#         return self.__str__()
-
-#     def __str__(self) -> str:
-#         return f"TerminationBackend({repr(self._sequence)})"
-
-
-# # TODO : Add a "allow_longer" parameter ? If more than N data is received, keep it instead of raising an error ?
-# class LengthBackend(StopConditionBackend):
-#     # _TYPE = StopConditionType.LENGTH
-
     
+    def type(self) -> StopConditionType:
+        return StopConditionType.TIMEOUT
 
-#     def __repr__(self) -> str:
-#         return self.__str__()
-
-#     def __str__(self) -> str:
-#         return f"LengthBackend({self._N})"
-
-#     def flush_read(self) -> None:
-#         self._counter = 0
+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()
 
-# class TimeoutStopConditionBackend(StopConditionBackend):
-#     # _TYPE = StopConditionType.TIMEOUT
+    def flush_read(self) -> None:
+        self._start_time = None
 
-#     def __init__(self, continuation: float | None, total: float | None) -> None:
-#         """
-#         Timeout stop condition, can stop on continuation (device not responding after x seconds),
-#         or total (total communication time exceeds a given value)
+    def evaluate(self, raw_fragment: Fragment) -> tuple[bool, Fragment, Fragment, float | None]:
+        kept = raw_fragment
+        deferred = Fragment(b"", None)
 
-#         Parameters
-#         ----------
-#         continuation : float
-#         total : float
-#         """
-#         super().__init__()
-#         self._start_time: float | None = None
-#         self._last_fragment: float | None = None
-#         self._continuation = continuation
-#         self._total = total
+        if raw_fragment.timestamp is None:
+            raise RuntimeError("Cannot evaluate fragment with no timestamp")
 
-#     def initiate_read(self) -> None:
-#         self._start_time = time.time()
-#         self._last_fragment = self._start_time
+        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 flush_read(self) -> None:
-#         self._counter = 0
-#         self._start_time = None
-#         self._last_fragment = None
-
-
-# class Lambda(StopCondition): # TODO : maybe work on this a bit more
-#     class LambdaReturn:
-#         ERROR = 'error' # Discard everything and raise an error
-#         VALID = 'valid' # Return everything
-#         KEEP_N = 'keep_n' # Keep the first N bytes
-#         CONTINUE = 'continue' # Keep reading
-
-#     def __init__(self, _lambda : Callable) -> None:
-#         super().__init__()
-#         self._lambda = _lambda
-
-#     def initiate_read(self) -> Union[float, None]:
-#         return None
-
-#     def evaluate(self, fragment: bytes) -> Tuple[bool, Union[float, None]]:
-#         lambda_return, N = self._lambda(fragment)
-#         match lambda_return:
-#             case self.LambdaReturn.ERROR:
-#                 raise RuntimeError(f"Couldn't apply Lambda condition on fragment : {fragment}")
-#             case self.LambdaReturn.VALID:
-#                 return True, fragment, b''
-#             case self.LambdaReturn.KEEP_N:
-#                 return True, fragment[:N], fragment[N:]
-#             case self.LambdaReturn.CONTINUE:
-#                 return False, fragment, b'' # TODO : Check this
-
-#     def __repr__(self) -> str:
-#         return self.__str__()
-
-#     def __str__(self) -> str:
-#         return f'Lambda(...)'
-
-# def stop_conditions_to_backends(stop_conditions: list[StopCondition]) -> list["StopConditionBackend"]:
-#     output = []
-#     for stop_condition in stop_conditions:
-#         if isinstance(stop_condition, Termination):
-#             output.append(TerminationBackend(
-#                 sequence=stop_condition.sequence
-#             ))
-#         elif isinstance(stop_condition, Length):
-#             output.append(LengthBackend(
-#                 N=stop_condition.N
-#             ))
-#         elif isinstance(stop_condition, TimeoutStopCondition):
-#             output.append(TimeoutStopConditionBackend(
-#                 continuation=stop_condition.continuation,
-#                 total=stop_condition.total,
-#             ))
-
-#     return output
+    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/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/serialport.py

@@ -20,7 +20,7 @@ class SerialPort(Adapter):
         port: str,
         baudrate: int | None = None,
         timeout: Timeout | NumberLike | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
+        stop_conditions: StopCondition | list[StopCondition] | EllipsisType = ...,
         alias: str = "",
         rts_cts: bool = False,  # rts_cts experimental
         event_callback: Callable[[AdapterSignal], None] | None = None,
@@ -39,7 +39,7 @@ class SerialPort(Adapter):
         super().__init__(
             descriptor=descriptor,
             timeout=timeout,
-            stop_conditions=stop_condition,
+            stop_conditions=stop_conditions,
             alias=alias,
             event_callback=event_callback,
             backend_address=backend_address,
@@ -48,9 +48,8 @@ class SerialPort(Adapter):
         self.descriptor: SerialPortDescriptor
 
         self._logger.info(
-            f"Setting up SerialPort adapter {self.descriptor}, timeout={timeout} and stop_condition={stop_condition}"
+            f"Setting up SerialPort adapter {self.descriptor}, timeout={timeout} and stop_conditions={self._stop_conditions}"
         )
-        # self._port = None
 
         self.open()
 
@@ -78,4 +77,4 @@ class SerialPort(Adapter):
 
     def close(self, force: bool = False) -> None:
         super().close(force)
-        self._logger.info("Adapter closed !")
+        self._logger.info("Adapter closed")