syndesi 0.4.1__tar.gz → 0.4.2__tar.gz

syndesi-0.4.2/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: syndesi
+Version: 0.4.2
+Summary: Syndesi
+Author-email: Sébastien Deriaz <sebastien.deriaz1@gmail.com>
+License: GPL
+Keywords: python,syndesi,interface,ethernet,serial,visa
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: prompt_toolkit
+Requires-Dist: pyserial
+Requires-Dist: rich
+Requires-Dist: platformdirs
+Dynamic: license-file
+
+# Syndesi Python Implementation
+
+Syndesi description is available [here](https://github.com/syndesi-project/Syndesi/README.md)
+
+Syndesi is a modular Python framework designed to streamline communication and control of a wide range of electronic instruments and devices. By providing a unified abstraction layer for adapters, protocols, and device drivers, Syndesi enables seamless integration with test equipment such as multimeters, oscilloscopes, power supplies, UART/USB devices, and more. Its flexible architecture supports both high-level and low-level operations, making it ideal for automation, data acquisition, and custom device interfacing in laboratory, industrial, and research environments.
+
+## Installation
+
+The syndesi Python package can be installed through pip
+
+``pip install syndesi``
+
+The package can also be installed locally by cloning this repository
+
+```bash
+git clone https://github.com/syndesi-project/Syndesi
+cd Syndesi
+pip install .
+```
+
+## Usage
+
+The user can work with any of the three following layers :
+
+- Adapters : low-level communication (IP, UART, ...)
+- Protocols : Encapsulated protocols (Delimited, Modbus, ...)
+- Drivers : Device or application specific commands
+
+### Adapters
+
+The adapter allows the user to read and write raw data through IP, serial and VISA
+
+```python
+from syndesi import IP
+
+my_adapter = IP('192.168.1.12', port=5025)
+
+my_adapter.write(b'ping\n')
+
+my_adapter.read() # -> b'pong'
+```
+
+```python
+from syndesi import SerialPort
+
+arduino = SerialPort('/dev/ttyUSB0', baudrate=115200) # COMx on Windows
+arduino.query(b'get_temperature\n') # -> 20.5
+```
+
+### Protocols
+
+Protocols encapsulate and format data
+
+```python
+from syndesi import IP, Delimited
+
+my_server = Delimited(IP('test.server.local', port=1234))
+
+my_server.query('Hello world\n') # -> Hello world (\n is removed by Delimited)
+
+```
+
+### Drivers
+
+A driver only requires an adapter, the protocol (if used) is instanciated internally
+
+```python
+from syndesi_drivers.instruments.mutlimeters.siglent.SDM3055 import SDM3055
+from syndesi.adapters import IP
+
+mm = SDM3055(IP("192.168.1.123"))
+
+voltage = mm.measure_dc_voltage()
+```

syndesi-0.4.2/README.md

@@ -0,0 +1,74 @@
+# Syndesi Python Implementation
+
+Syndesi description is available [here](https://github.com/syndesi-project/Syndesi/README.md)
+
+Syndesi is a modular Python framework designed to streamline communication and control of a wide range of electronic instruments and devices. By providing a unified abstraction layer for adapters, protocols, and device drivers, Syndesi enables seamless integration with test equipment such as multimeters, oscilloscopes, power supplies, UART/USB devices, and more. Its flexible architecture supports both high-level and low-level operations, making it ideal for automation, data acquisition, and custom device interfacing in laboratory, industrial, and research environments.
+
+## Installation
+
+The syndesi Python package can be installed through pip
+
+``pip install syndesi``
+
+The package can also be installed locally by cloning this repository
+
+```bash
+git clone https://github.com/syndesi-project/Syndesi
+cd Syndesi
+pip install .
+```
+
+## Usage
+
+The user can work with any of the three following layers :
+
+- Adapters : low-level communication (IP, UART, ...)
+- Protocols : Encapsulated protocols (Delimited, Modbus, ...)
+- Drivers : Device or application specific commands
+
+### Adapters
+
+The adapter allows the user to read and write raw data through IP, serial and VISA
+
+```python
+from syndesi import IP
+
+my_adapter = IP('192.168.1.12', port=5025)
+
+my_adapter.write(b'ping\n')
+
+my_adapter.read() # -> b'pong'
+```
+
+```python
+from syndesi import SerialPort
+
+arduino = SerialPort('/dev/ttyUSB0', baudrate=115200) # COMx on Windows
+arduino.query(b'get_temperature\n') # -> 20.5
+```
+
+### Protocols
+
+Protocols encapsulate and format data
+
+```python
+from syndesi import IP, Delimited
+
+my_server = Delimited(IP('test.server.local', port=1234))
+
+my_server.query('Hello world\n') # -> Hello world (\n is removed by Delimited)
+
+```
+
+### Drivers
+
+A driver only requires an adapter, the protocol (if used) is instanciated internally
+
+```python
+from syndesi_drivers.instruments.mutlimeters.siglent.SDM3055 import SDM3055
+from syndesi.adapters import IP
+
+mm = SDM3055(IP("192.168.1.123"))
+
+voltage = mm.measure_dc_voltage()
+```

{syndesi-0.4.1 → syndesi-0.4.2}/pyproject.toml

@@ -11,7 +11,7 @@ dynamic = ["version"]
 description = "Syndesi"
 readme = "README.md"
 requires-python = ">=3.10"
-license = { text = "GPL" }  # update if different
+license = { text = "GPL" }
 authors = [{ name = "Sébastien Deriaz", email = "sebastien.deriaz1@gmail.com" }]
 keywords = ["python", "syndesi", "interface", "ethernet", "serial", "visa"]
 classifiers = [
@@ -42,8 +42,6 @@ include = ["syndesi*"]
 [tool.ruff]
 target-version = "py311"
 line-length = 100
-select = ["D","E","F","I","B"]   # include pydocstyle rules ("D")
-#ignore = ["D203","D213"]         # pick your preferences
 
 [tool.ruff.lint]
 select = ["E", "F", "W", "I", "UP", "B"]

{syndesi-0.4.1 → syndesi-0.4.2}/syndesi/adapters/adapter.py

@@ -15,8 +15,8 @@
 # An adapter is meant to work with bytes objects but it can accept strings.
 # Strings will automatically be converted to bytes using utf-8 encoding
 
-from enum import Enum
 import logging
+import os
 import queue
 import subprocess
 import sys
@@ -25,43 +25,44 @@ import time
 import weakref
 from abc import ABC, abstractmethod
 from collections.abc import Callable
+from enum import Enum
 from multiprocessing.connection import Client, Connection
 from types import EllipsisType
 from typing import Any
-import os
 
-from .backend.backend_tools import BACKEND_REQUEST_DEFAULT_TIMEOUT
 from syndesi.tools.types import NumberLike, is_number
 
 from ..tools.backend_api import (
     BACKEND_PORT,
+    EXTRA_BUFFER_RESPONSE_TIME,
     Action,
     BackendResponse,
     Fragment,
     default_host,
     raise_if_error,
-    EXTRA_BUFFER_RESPONSE_TIME
 )
 from ..tools.log_settings import LoggerAlias
 from .backend.adapter_backend import (
     AdapterDisconnected,
-    AdapterResponseTimeout,
     AdapterReadPayload,
+    AdapterResponseTimeout,
     AdapterSignal,
 )
+from .backend.backend_tools import BACKEND_REQUEST_DEFAULT_TIMEOUT
 from .backend.descriptors import Descriptor
-from .stop_condition import StopCondition, Continuation, StopConditionType, Total
+from .stop_condition import Continuation, StopCondition, StopConditionType
 from .timeout import Timeout, TimeoutAction, any_to_timeout
 
 DEFAULT_STOP_CONDITION = Continuation(time=0.1)
 
-DEFAULT_TIMEOUT = Timeout(response=5, action='error')
+DEFAULT_TIMEOUT = Timeout(response=5, action="error")
 
 # Maximum time to let the backend start
 START_TIMEOUT = 2
 # Time to shutdown the backend
 SHUTDOWN_DELAY = 2
 
+
 class SignalQueue(queue.Queue[AdapterSignal]):
     def __init__(self) -> None:
         self._read_payload_counter = 0
@@ -70,12 +71,12 @@ class SignalQueue(queue.Queue[AdapterSignal]):
     def has_read_payload(self) -> bool:
         return self._read_payload_counter > 0
 
-
-    def put(self, signal: AdapterSignal, block: bool = True, timeout: float | None = None) -> None:
+    def put(
+        self, signal: AdapterSignal, block: bool = True, timeout: float | None = None
+    ) -> None:
         if isinstance(signal, AdapterReadPayload):
             self._read_payload_counter += 1
         return super().put(signal, block, timeout)
-    
 
     def get(self, block: bool = True, timeout: float | None = None) -> AdapterSignal:
         signal = super().get(block, timeout)
@@ -94,19 +95,20 @@ def is_backend_running(address: str, port: int) -> bool:
         conn.close()
         return True
 
+
 def start_backend(port: int | None = None) -> None:
     arguments = [
-            sys.executable,
-            "-m",
-            "syndesi.adapters.backend.backend",
-            "-s",
-            str(SHUTDOWN_DELAY),
-            "-q",
-            "-p",
-            str(BACKEND_PORT if port is None else port),
-        ]
-    
-    stdin  = subprocess.DEVNULL
+        sys.executable,
+        "-m",
+        "syndesi.adapters.backend.backend",
+        "-s",
+        str(SHUTDOWN_DELAY),
+        "-q",
+        "-p",
+        str(BACKEND_PORT if port is None else port),
+    ]
+
+    stdin = subprocess.DEVNULL
     stdout = subprocess.DEVNULL
     stderr = subprocess.DEVNULL
 
@@ -122,8 +124,8 @@ def start_backend(port: int | None = None) -> None:
 
     else:
         # Windows: detach from the parent's console so keyboard Ctrl+C won't propagate.
-        CREATE_NEW_PROCESS_GROUP = subprocess.CREATE_NEW_PROCESS_GROUP # type: ignore
-        DETACHED_PROCESS = 0x00000008          # not exposed by subprocess on all Pythons
+        CREATE_NEW_PROCESS_GROUP = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore
+        DETACHED_PROCESS = 0x00000008  # not exposed by subprocess on all Pythons
         # Optional: CREATE_NO_WINDOW (no window even for console apps)
         CREATE_NO_WINDOW = 0x08000000
 
@@ -138,9 +140,11 @@ def start_backend(port: int | None = None) -> None:
             close_fds=True,
         )
 
+
 class ReadScope(Enum):
-    NEXT = 'next'
-    BUFFERED = 'buffered'
+    NEXT = "next"
+    BUFFERED = "buffered"
+
 
 class Adapter(ABC):
     def __init__(
@@ -215,7 +219,7 @@ class Adapter(ABC):
             elif isinstance(stop_conditions, list):
                 self._stop_conditions = stop_conditions
             else:
-                raise ValueError('Invalid stop_conditions')
+                raise ValueError("Invalid stop_conditions")
 
         # Set the timeout
         self.is_default_timeout = False
@@ -335,7 +339,7 @@ class Adapter(ABC):
                 action = Action(response[0])
 
                 if action == Action.ADAPTER_SIGNAL:
-                #if is_event(action):
+                    # if is_event(action):
                     if len(response) <= 1:
                         raise RuntimeError(f"Invalid event response : {response}")
                     signal: AdapterSignal = response[1]
@@ -371,7 +375,9 @@ class Adapter(ABC):
             self._logger.debug(f"Setting default timeout to {default_timeout}")
             self._timeout = default_timeout
 
-    def set_stop_conditions(self, stop_conditions: StopCondition | None | list[StopCondition]) -> None:
+    def set_stop_conditions(
+        self, stop_conditions: StopCondition | None | list[StopCondition]
+    ) -> None:
         """
         Overwrite the stop-condition
 
@@ -411,7 +417,6 @@ class Adapter(ABC):
                 self._signal_queue.get(block=False)
             except queue.Empty:
                 break
-            
 
     def previous_read_buffer_empty(self) -> bool:
         """
@@ -464,7 +469,7 @@ class Adapter(ABC):
         self,
         timeout: Timeout | EllipsisType | None = ...,
         stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
-        scope : str = ReadScope.BUFFERED.value,
+        scope: str = ReadScope.BUFFERED.value,
     ) -> AdapterReadPayload:
         """
         Read data from the device
@@ -490,13 +495,13 @@ class Adapter(ABC):
             read_timeout = self._timeout
         else:
             read_timeout = any_to_timeout(timeout)
-            
+
         if read_timeout is None:
             raise RuntimeError("Cannot read without setting a timeout")
 
         if stop_conditions is not ...:
             if isinstance(stop_conditions, StopCondition):
-                stop_conditions = [stop_conditions]    
+                stop_conditions = [stop_conditions]
             self._make_backend_request(Action.SET_STOP_CONDITIONs, stop_conditions)
 
         # First, we check if data is in the buffer and if the scope if set to BUFFERED
@@ -525,21 +530,21 @@ class Adapter(ABC):
                 # Wait for the response time + a bit more
                 read_stop_timestamp = read_init_time + _response
 
-            # else:
-            #     start_read_id = None
-            #     read_init_time = None
-
-            
             while True:
                 try:
                     if read_stop_timestamp is None:
                         queue_timeout = None
                     else:
-                        queue_timeout = max(0, read_stop_timestamp - time.time() + EXTRA_BUFFER_RESPONSE_TIME)
+                        queue_timeout = max(
+                            0,
+                            read_stop_timestamp
+                            - time.time()
+                            + EXTRA_BUFFER_RESPONSE_TIME,
+                        )
 
                     signal = self._signal_queue.get(timeout=queue_timeout)
-                except queue.Empty:
-                    raise RuntimeError('Failed to receive response from backend')
+                except queue.Empty as e:
+                    raise RuntimeError("Failed to receive response from backend") from e
                 if isinstance(signal, AdapterReadPayload):
                     output_signal = signal
                     break
@@ -552,17 +557,16 @@ class Adapter(ABC):
                     # Otherwise ignore it
 
         if output_signal is None:
-            # TODO : Make read_timeout always Timeout, never None ?
             match read_timeout.action:
                 case TimeoutAction.RETURN_EMPTY:
                     t = time.time()
                     return AdapterReadPayload(
-                        fragments=[Fragment(b'', t)],
+                        fragments=[Fragment(b"", t)],
                         stop_timestamp=t,
                         stop_condition_type=StopConditionType.TIMEOUT,
                         previous_read_buffer_used=False,
                         response_timestamp=None,
-                        response_delay=None
+                        response_delay=None,
                     )
                 case TimeoutAction.ERROR:
                     raise TimeoutError(
@@ -570,7 +574,7 @@ class Adapter(ABC):
                     )
                 case _:
                     raise NotImplementedError()
-        
+
         else:
             return output_signal
 

{syndesi-0.4.1 → syndesi-0.4.2}/syndesi/adapters/backend/adapter_backend.py

@@ -7,19 +7,18 @@
 
 import logging
 import socket
+import time
 from abc import ABC, abstractmethod
 from collections.abc import Generator
 from dataclasses import dataclass
 from enum import Enum
 from multiprocessing.connection import Connection
 from threading import Thread
-import time
-from typing import Protocol, cast
-
-from syndesi.tools.types import NumberLike
+from typing import Protocol
 
 from ...tools.backend_api import AdapterBackendStatus, Fragment
 from ...tools.log_settings import LoggerAlias
+from ..stop_condition import StopConditionType
 from .descriptors import Descriptor
 from .stop_condition_backend import (
     ContinuationBackend,
@@ -27,8 +26,6 @@ from .stop_condition_backend import (
     TotalBackend,
 )
 
-from ..stop_condition import Continuation, StopConditionType
-
 
 class HasFileno(Protocol):
     def fileno(self) -> int:
@@ -82,12 +79,13 @@ class AdapterDisconnected(AdapterSignal):
 #     def __repr__(self) -> str:
 #         return self.__str__()
 
+
 @dataclass
 class AdapterResponseTimeout(AdapterSignal):
-    identifier : int
+    identifier: int
 
     def __str__(self) -> str:
-        return f"Response timeout"
+        return "Response timeout"
 
     def __repr__(self) -> str:
         return self.__str__()
@@ -99,9 +97,9 @@ class AdapterReadPayload(AdapterSignal):
     stop_timestamp: float
     stop_condition_type: StopConditionType
     previous_read_buffer_used: bool
-    response_timestamp : float | None
+    response_timestamp: float | None
     # Only used by client and set by frontend
-    response_delay : float | None = None
+    response_delay: float | None = None
 
     def data(self) -> bytes:
         return b"".join([f.data for f in self.fragments])
@@ -118,9 +116,10 @@ class AdapterReadPayload(AdapterSignal):
 @dataclass
 class ResponseRequest:
     timestamp: float
-    identifier : int
+    identifier: int
+
 
-def nmin(a : float | None, b : float | None) -> float | None:
+def nmin(a: float | None, b: float | None) -> float | None:
     if a is None and b is None:
         return None
     elif a is None:
@@ -130,6 +129,7 @@ def nmin(a : float | None, b : float | None) -> float | None:
     else:
         return min(a, b)
 
+
 class AdapterBackend(ABC):
     class ThreadCommands(Enum):
         STOP = b"0"
@@ -168,7 +168,7 @@ class AdapterBackend(ABC):
         # None : No ask
         # float : Ask for a response to happen at the specified value at max
         self._response_request: ResponseRequest | None = None
-        self._response_request_start : float | None = None
+        self._response_request_start: float | None = None
 
         self._first_fragment = True
 
@@ -246,10 +246,10 @@ class AdapterBackend(ABC):
     @abstractmethod
     def _socket_read(self) -> Fragment:
         raise NotImplementedError
-    
-    def _fragments_to_string(self, fragments : list[Fragment]) -> str:
+
+    def _fragments_to_string(self, fragments: list[Fragment]) -> str:
         if len(fragments) > 0:
-            return '+'.join(repr(f.data) for f in fragments)
+            return "+".join(repr(f.data) for f in fragments)
         else:
             return str([])
 
@@ -263,7 +263,10 @@ class AdapterBackend(ABC):
             self.close()
             yield AdapterDisconnected()
         else:
-            self._logger.debug(f"New fragment {fragment_delta_t:+.3f} {fragment}" + (" (first)" if self._first_fragment else ""))
+            self._logger.debug(
+                f"New fragment {fragment_delta_t:+.3f} {fragment}"
+                + (" (first)" if self._first_fragment else "")
+            )
             if self._status == AdapterBackendStatus.CONNECTED:
                 t = time.time()
 
@@ -272,7 +275,9 @@ class AdapterBackend(ABC):
 
                 if self._response_request is not None:
                     for stop_condition in self._stop_conditions:
-                        if isinstance(stop_condition, (ContinuationBackend, TotalBackend)):
+                        if isinstance(
+                            stop_condition, (ContinuationBackend, TotalBackend)
+                        ):
                             self._response_request = None
                             break
 
@@ -287,15 +292,18 @@ class AdapterBackend(ABC):
                     kept = fragment
 
                     # Run each stop condition one after the other, if a stop is reached, stop evaluating
-                    stop_condition_type : StopConditionType
+                    stop_condition_type: StopConditionType
                     for stop_condition in self._stop_conditions:
-                        stop, kept, self._previous_buffer, self._next_timeout_timestamp = \
-                            stop_condition.evaluate(kept)
+                        (
+                            stop,
+                            kept,
+                            self._previous_buffer,
+                            self._next_timeout_timestamp,
+                        ) = stop_condition.evaluate(kept)
                         if stop:
                             stop_condition_type = stop_condition.type()
                             break
 
-                    
                     # if kept.data != b'':
                     #     self.fragments.append(kept)
 
@@ -303,14 +311,22 @@ class AdapterBackend(ABC):
 
                     if stop:
                         self._first_fragment = True
-                        self._logger.debug(f"Payload {self._fragments_to_string(self.fragments)} ({stop_condition_type.value})")
-                        if self._response_request_start is None or len(self.fragments) == 0:
+                        self._logger.debug(
+                            f"Payload {self._fragments_to_string(self.fragments)} ({stop_condition_type.value})"
+                        )
+                        if (
+                            self._response_request_start is None
+                            or len(self.fragments) == 0
+                        ):
                             response_delay = None
                         else:
                             if self.fragments[0].timestamp is None:
                                 response_delay = None
                             else:
-                                response_delay = self.fragments[0].timestamp - self._response_request_start
+                                response_delay = (
+                                    self.fragments[0].timestamp
+                                    - self._response_request_start
+                                )
                             self._response_request_start = None
                         yield AdapterReadPayload(
                             fragments=self.fragments,
@@ -318,9 +334,9 @@ class AdapterBackend(ABC):
                             stop_condition_type=stop_condition_type,
                             previous_read_buffer_used=False,
                             response_timestamp=self.fragments[0].timestamp,
-                            response_delay=response_delay
+                            response_delay=response_delay,
                         )
-                        self._next_timeout_timestamp = None # Experiment !
+                        self._next_timeout_timestamp = None  # Experiment !
                         self.fragments.clear()
 
                     if len(self._previous_buffer.data) > 0 and stop:
@@ -341,8 +357,9 @@ class AdapterBackend(ABC):
         """
         self._response_request_start = time.time()
         self._logger.debug(f"Setup read [{identifier}] in {response_time:.3f} s")
-        self._response_request = ResponseRequest(self._response_request_start + response_time, identifier)
-        
+        self._response_request = ResponseRequest(
+            self._response_request_start + response_time, identifier
+        )
 
     @abstractmethod
     def is_opened(self) -> bool:
@@ -366,7 +383,9 @@ class AdapterBackend(ABC):
                 response_delay = None
             else:
                 if self.fragments[0].timestamp is not None:
-                    response_delay = self.fragments[0].timestamp - self._response_request_start
+                    response_delay = (
+                        self.fragments[0].timestamp - self._response_request_start
+                    )
                 else:
                     response_delay = None
                 self._response_request_start = None
@@ -376,8 +395,10 @@ class AdapterBackend(ABC):
                 stop_condition_type=StopConditionType.TIMEOUT,
                 previous_read_buffer_used=False,
                 fragments=self.fragments,
-                response_timestamp=self.fragments[0].timestamp if len(self.fragments) > 0 else None,
-                response_delay=response_delay
+                response_timestamp=(
+                    self.fragments[0].timestamp if len(self.fragments) > 0 else None
+                ),
+                response_delay=response_delay,
             )
             # Reset response request
             if self._response_request is not None:
@@ -388,8 +409,7 @@ class AdapterBackend(ABC):
             return output
 
         elif (
-            self._next_timeout_origin
-            == self.AdapterTimeoutEventOrigin.RESPONSE_REQUEST
+            self._next_timeout_origin == self.AdapterTimeoutEventOrigin.RESPONSE_REQUEST
         ):
             if self._response_request is not None:
                 signal = AdapterResponseTimeout(self._response_request.identifier)
@@ -402,8 +422,6 @@ class AdapterBackend(ABC):
         min_timestamp = None
         self._next_timeout_origin = None
 
-        t = time.time()
-
         if self._next_timeout_timestamp is not None:
             min_timestamp = self._next_timeout_timestamp
             self._next_timeout_origin = self.AdapterTimeoutEventOrigin.TIMEOUT