syndesi 0.2.0__tar.gz → 0.2.2__tar.gz

{syndesi-0.2.0/syndesi.egg-info → syndesi-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: syndesi
-Version: 0.2.0
+Version: 0.2.2
 Summary: Syndesi
 Author: Sebastien Deriaz
 Author-email: sebastien.deriaz1@gmail.com

{syndesi-0.2.0 → syndesi-0.2.2}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '0.2.0'
+VERSION = '0.2.2'
 DESCRIPTION = 'Syndesi'
 
 with open("README.md", "r", encoding="utf-8") as fh:

{syndesi-0.2.0 → syndesi-0.2.2}/syndesi/adapters/proxy.py

@@ -21,7 +21,7 @@ from enum import Enum
 from typing import Union
 
 from .adapter import Adapter
-from .. import IP, SerialPort, VISA
+from . import IP, SerialPort, VISA
 from ..proxy.proxy_api import *
 from ..api.api import parse
 

{syndesi-0.2.0 → syndesi-0.2.2}/syndesi/adapters/serialport.py

@@ -1,35 +1,27 @@
-from .adapter import Adapter
+import os
 import serial
-from ..tools.types import to_bytes
-from .stop_conditions import *
-from .timeout import Timeout
-from .timed_queue import TimedQueue
 from threading import Thread
 from typing import Union
 import select
 import argparse
-from ..tools import shell
-from collections.abc import Sequence
+#from collections.abc import Sequence
 
-# From pyserial - serialposix.py
-import fcntl
-import termios
-import struct
-if hasattr(termios, 'TIOCINQ'):
-    TIOCINQ = termios.TIOCINQ
-else:
-    TIOCINQ = getattr(termios, 'FIONREAD', 0x541B)
-TIOCM_zero_str = struct.pack('I', 0)
-import os
+from .adapter import Adapter
+from ..tools.types import to_bytes
+from .stop_conditions import *
+from .timeout import Timeout
+from .timed_queue import TimedQueue
+from ..tools import shell
+from ..tools.others import DEFAULT
 
-DEFAULT_TIMEOUT = Timeout(response=0.5, continuation=10e-3, total=None)
+DEFAULT_TIMEOUT = Timeout(response=1, continuation=200e-3, total=None)
 
 class SerialPort(Adapter):
     def __init__(self,  
                 port : str,
                 baudrate : int,
-                timeout : Union[Timeout, float] = DEFAULT_TIMEOUT,
-                stop_condition : StopCondition = None,
+                timeout : Union[Timeout, float] = DEFAULT,
+                stop_condition : StopCondition = DEFAULT,
                 rts_cts : bool = False): # rts_cts experimental
         """
         Serial communication adapter
@@ -39,8 +31,11 @@ class SerialPort(Adapter):
         port : str
             Serial port (COMx or ttyACMx)
         """
+        if timeout == DEFAULT:
+            timeout = DEFAULT_TIMEOUT
+            
         super().__init__(timeout=timeout, stop_condition=stop_condition)
-        self._logger.info("Setting up SerialPort adapter")
+        self._logger.info(f"Setting up SerialPort adapter timeout:{timeout}, stop_condition:{stop_condition}")
         self._port = serial.Serial(port=port, baudrate=baudrate)
         if self._port.isOpen():
             self._status = self.Status.CONNECTED
@@ -48,8 +43,6 @@ class SerialPort(Adapter):
             self._status = self.Status.DISCONNECTED
 
         self._rts_cts = rts_cts
-        
-        self._stop_event_pipe, self._stop_event_pipe_write = os.pipe()
 
     def flushRead(self):
         self._port.flush()
@@ -63,10 +56,8 @@ class SerialPort(Adapter):
         self._logger.info("Adapter opened !")
 
     def close(self):
-        if self._thread is not None and self._thread.is_alive():
-            os.write(self._stop_event_pipe_write, b'1')
-            self._thread.join()
         if hasattr(self, '_port'):
+            # Close and the read thread will die by itself
             self._port.close()
         self._logger.info("Adapter closed !")
             
@@ -87,23 +78,19 @@ class SerialPort(Adapter):
         """
         self._logger.debug("Starting read 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._stop_event_pipe))
+            self._thread = Thread(target=self._read_thread, daemon=True, args=(self._port, self._read_queue))
             self._thread.start()
 
-    def _read_thread(self, port : serial.Serial , read_queue : TimedQueue, stop_event_pipe):
+    def _read_thread(self, port : serial.Serial , read_queue : TimedQueue):
+        # NOTE : There should be some way to kill the thread, maybe check for an error on in_waiting but couldn't find it so far
         while True:
-            # It looks like using the raw implementation of port.in_waiting and port.read is better, there's no more warnings
-            # Equivalent of port.in_waiting :
-            in_waiting = struct.unpack('I', fcntl.ioctl(port.fd, TIOCINQ, TIOCM_zero_str))[0]
-            if in_waiting == 0:
-                ready, _, _ = select.select([port.fd, stop_event_pipe], [], [], None)
-                if stop_event_pipe in ready:
-                    # Stop
-                    break
-            # Else, read as many bytes as possible
-            fragment = os.read(port.fd, 1000) # simplified version of port.read()
-            if fragment:
-                read_queue.put(fragment)        
+            # Check how many bytes are available
+            in_waiting = self._port.in_waiting # This is a temporary fix to get windows compatiblity back, an error might pop up
+            if in_waiting > 0:
+                # Read those bytes
+                fragment = port.read(in_waiting)
+                if fragment:
+                    read_queue.put(fragment)        
 
     def read(self, timeout=None, stop_condition=None, return_metrics: bool = False) -> bytes:
         """

{syndesi-0.2.0 → syndesi-0.2.2}/syndesi/adapters/stop_conditions.py

@@ -134,6 +134,12 @@ class Termination(StopCondition):
         self._fragment_store = b''
         return output
 
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def __str__(self) -> str:
+        return f'Termination({repr(self._termination)})'
+
 class Length(StopCondition):
     def __init__(self, N : int) -> None:
         """
@@ -158,4 +164,10 @@ class Length(StopCondition):
         deferred_fragment = data[remaining_bytes:]
         self._counter += len(kept_fragment)
         remaining_bytes = self._N - self._counter
-        return remaining_bytes == 0, kept_fragment, deferred_fragment
+        return remaining_bytes == 0, kept_fragment, deferred_fragment
+
+    def __repr__(self) -> str:
+        return self.__str__()
+        
+    def __str__(self) -> str:
+        return f'Length({self._N})'

{syndesi-0.2.0 → syndesi-0.2.2}/syndesi/adapters/timeout.py

@@ -235,6 +235,15 @@ class Timeout():
         """
         return self._data_strategy, self._last_data_strategy_origin
 
+    def __str__(self) -> str:
+        response = f'r:{self._response:.3f}ms/{self._on_response},' if self._response is not None else ''
+        continuation = f'c:{self._continuation:.3f}ms/{self._on_continuation},' if self._continuation is not None else ''
+        total = f't:{self._total:.3f}ms/{self._on_total}' if self._total is not None else ''
+        return f'Timeout({response}{continuation}{total})'
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
 
 class TimeoutException(Exception):
     def __init__(self, type : Timeout.TimeoutType) -> None:

syndesi-0.2.2/syndesi/api/api.py

@@ -0,0 +1,77 @@
+import quopri
+from typing import Tuple, Union, Dict
+from enum import Enum
+from dataclasses import dataclass, fields, Field
+import json
+
+APIS = {}
+
+def register_api(apis : dict):
+    """
+    Register apis
+
+    Parameters
+    ----------
+    apis : dict
+        {'action' : APICall} class dictionary
+    """
+    APIS.update(apis)
+
+ACTION_ATTRIBUTE = 'action'
+
+class APIItem:
+    pass
+
+class APICall:
+    action = ''
+    _keyword = ''        
+
+    def encode(self) -> bytes:
+        cls_fields: Tuple[Field, ...] = fields(self)
+        data = {}
+        
+        # Add action field
+        data[ACTION_ATTRIBUTE] = self.action
+        # Add other fields
+        for field in cls_fields:
+            field_data = getattr(self, field.name)
+            if isinstance(field_data, Enum):
+                entry = field_data.value
+            elif isinstance(field_data, bytes):
+                entry = quopri.encodestring(field_data).decode('ASCII')
+            elif isinstance(field_data, str):
+                entry = quopri.encodestring(field_data.encode('utf-8')).decode('ASCII')
+            else:
+                entry = field_data
+
+            data[field.name] = entry
+        return json.dumps(data)
+
+def parse(data : Union[str, bytes]) -> APICall:
+    json_data = json.loads(data)
+    action = json_data[ACTION_ATTRIBUTE]
+    json_data.pop(ACTION_ATTRIBUTE)
+    arguments = json_data
+    # Find the right API call and return it
+    if action not in APIS:
+        raise RuntimeError(f"API action '{action}' not registered")
+
+    converted_arguments = {}
+    # Convert each argument according to the class field types
+    api_fields: Tuple[Field, ...] = fields(APIS[action])
+    
+    for field in api_fields:
+        if field.name not in arguments:
+            raise RuntimeError(f"Field '{field.name}' missing from arguments")
+
+        if field.type == bytes:
+            # Convert back
+            converted_arguments[field.name] = quopri.decodestring(arguments[field.name])
+        elif field.type == str:
+            converted_arguments[field.name] = quopri.decodestring(arguments[field.name]).decode('utf-8')
+        elif field.type == Enum:
+            converted_arguments[field.name] = field.type(arguments[field.name])
+        else:
+            converted_arguments[field.name] = arguments[field.name]
+
+    return APIS[action](**converted_arguments)

{syndesi-0.2.0 → syndesi-0.2.2}/syndesi/protocols/delimited.py

@@ -1,12 +1,12 @@
 from .protocol import Protocol
-from ..adapters import Adapter
+from ..adapters import Adapter, Timeout, Termination
 from ..tools.types import assert_byte_instance, assert_byte_instance
 from time import time
 import warnings
 
 
 class Delimited(Protocol):
-    def __init__(self, adapter : Adapter, termination='\n', format_response=True) -> None:
+    def __init__(self, adapter : Adapter, termination='\n', format_response=True, encoding : str = 'utf-8', timeout : Timeout = None) -> None:
         """
         Protocol with delimiter, like LF, CR, etc... '\\n' is used by default
 
@@ -15,18 +15,21 @@ class Delimited(Protocol):
         Parameters
         ----------
         adapter : IAdapter
-        end : bytes
+        termination : bytes
             Command termination, '\\n' by default
         format_response : bool
-            Apply formatting to the response (i.e removing the termination)
+            Apply formatting to the response (i.e removing the termination), True by default
+        encoding : str
+        timeout : Timeout
+            None by default (default timeout)
         """
-        super().__init__(adapter)
-
-        # Temporary solution before implementing stop conditions
-        self._buffer = ''
+        adapter.set_default_stop_condition(stop_condition=Termination(sequence=termination))
+        super().__init__(adapter, timeout=timeout)
 
         if not isinstance(termination, str):
             raise ValueError(f"end argument must be of type str, not {type(termination)}")
+
+        self._encoding = encoding
         self._termination = termination
         self._response_formatting = format_response
 
@@ -62,40 +65,24 @@ class Delimited(Protocol):
         self.write(command)
         return self.read()
 
-    # Note : for later revisions of the delimited module, the buffer should be removed as the
-    # adapter will take care of that using the stop conditions
-    #
-    # For now the delimited module will take care of it
-    #
-    # Stop conditions should also be added inside the delimited module (unclear yet how)
-
-    def read(self, timeout=2) -> str:
+    def read(self, timeout : Timeout = None, decode : str = True) -> str:
         """
         Reads command and formats it as a str
+
+        Parameters
+        ----------
+        timeout : Timeout
+        decode : bool
+            Decode incoming data, True by default
         """
-        if self._termination not in self._buffer:
-            # Read the adapter only if there isn't a fragment already in the buffer
-            start = time()
-            while True:
-                # Continuously read the adapter as long as no termination is caught
-                data = self._from_bytes(self._adapter.read())
-                self._buffer += data
-                if self._termination in data or time() > start + timeout:
-                    break
 
         # Send up to the termination
-        fragment, self._buffer = self._buffer.split(self._termination, maxsplit=1)
+        data = self._adapter.read(timeout=timeout)
+        if decode:
+            data = data.decode(self._encoding)
         if self._response_formatting:
             # Only send the fragment (no termination)
-            return fragment
+            return data
         else:
             # Add the termination back in
-            return fragment + self._termination
-
-    def read_raw(self) -> bytes:
-        """
-        Returns the raw bytes instead of str
-        """
-        if len(self._buffer) > 0:
-            warnings.warn("Warning : The buffer wasn't empty, standard (non raw) data is still in it")
-        return self._adapter.read()
+            return data + self._termination 

syndesi-0.2.2/syndesi/proxy/proxy.py

@@ -0,0 +1,136 @@
+# proxy.py
+# Sébastien Deriaz
+# 28.05.2024
+import argparse
+from enum import Enum
+from ..adapters import SerialPort
+from ..adapters.adapter import AdapterDisconnected
+from ..adapters.proxy import DEFAULT_PORT
+from ..adapters.ip_server import IPServer
+from typing import Union
+from .proxy_api import *
+from ..api.api import *
+import logging
+from ..tools.log import LoggerAlias, set_log_stream
+
+class AdapterType(Enum):
+    SERIAL = 'serial'
+    IP = 'ip'
+
+DEFAULT_BAUDRATE = 115200
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='syndesi-proxy',
+        description='Syndesi proxy server',
+        epilog='')
+    # Parse subcommand
+    parser.add_argument('-t', '--adapter_type', choices=[x.value for x in AdapterType], default=AdapterType.IP)
+    parser.add_argument('-p', '--port', type=int, default=DEFAULT_PORT, help='IP port')
+    parser.add_argument('-a', '--address', default=None, type=str, help='IP address or serial port')
+    parser.add_argument('-b', '--baudrate', type=int, default=DEFAULT_BAUDRATE, help='Serial baudrate')
+    parser.add_argument('-v', '--verbose', action='store_true')
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        set_log_stream(True, 'DEBUG')
+
+    proxy_server = ProxyServer(adapter_type=args.adapter_type, port=args.port, address=args.address, baudrate=args.baudrate)
+
+    proxy_server.start()
+
+class ProxyServer:
+    def __init__(self, adapter_type : AdapterType, port : Union[str, int], address : str, baudrate : int) -> None:
+        self._adapter_type = AdapterType(adapter_type)
+        self._adapter = None
+        self._port = port
+        self._address = address
+        self._baudrate = baudrate
+        self._logger = logging.getLogger(LoggerAlias.PROXY_SERVER.value)
+        self._logger.info('Initializing proxy server')
+
+    def start(self):
+        self._logger.info(f"Starting proxy server with {self._adapter_type.value} adapter")
+        
+        if self._adapter_type == AdapterType.SERIAL:
+            # If adapter type is serial, create the adapter directly
+            self._master_adapter = SerialPort(self._address, baudrate=self._baudrate)
+        elif self._adapter_type == AdapterType.IP:
+            # Otherwise, create a server to get IP clients
+            server = IPServer(port=self._port, transport='TCP', address=self._address, max_clients=1, stop_condition=None)
+            server.open()
+
+
+        # If the adapter type is IP, use the external while loop to get clients
+        while True:
+            self._master_adapter = server.get_client()
+            self._logger.info(f'Client connected : {self._master_adapter._address}:{self._master_adapter._port}')
+
+            while True:
+                try:
+                    call_raw = self._master_adapter.read()
+                except AdapterDisconnected:
+                    self._logger.info('Client disconnected')
+                    break
+
+                api_call = parse(call_raw)
+
+                self._logger.debug(f'Received {type(api_call)}')
+
+                output = self.manage_call(api_call)
+
+                self._master_adapter.write(output.encode())
+
+                if self._adapter_type == AdapterType.IP:
+                    if not self._master_adapter.read_thread_alive():
+                        break
+
+            # Loop only if we need to get a new client
+            if self._adapter_type != AdapterType.IP:
+                break
+
+    def manage_call(self, c : APICall) -> APICall:
+        output = None
+        # IP Specific
+        if isinstance(c, IPInstanciate):
+            self._adapter = IP(
+                address=c.address,
+                port=c.port)
+            output = ReturnStatus(True)
+        # Serial specific
+        if isinstance(c, SerialPortInstanciate):
+            self._adapter = SerialPort(
+                port=c.port,
+                baudrate=c.baudrate
+            )
+        # Adapter
+        elif isinstance(c, AdapterOpen):
+            if self._adapter is None:
+                output = ReturnStatus(False, 'Cannot open uninstanciated adapter')
+            self._adapter.open()
+            output = ReturnStatus(True)
+        elif isinstance(c, AdapterClose):
+            if self._adapter is None:
+                output = ReturnStatus(False, 'Cannot close uninstanciated adapter')
+            else:
+                self._adapter.close()
+                output = ReturnStatus(True)
+        elif isinstance(c, AdapterWrite):
+            if self._adapter is None:
+                output = ReturnStatus(False, 'Cannot write to uninstanciated adapter')
+            else:
+                self._adapter.write(c.data)
+                output = ReturnStatus(True)
+        elif isinstance(c, AdapterFlushRead):
+            self._adapter.flushRead()
+            output = ReturnStatus(True)
+        elif isinstance(c, AdapterRead):
+            # TODO : Implement return_metrics
+            data = self._adapter.read()
+            output = AdapterReadReturn(data=data)
+
+        return output
+
+if __name__ == '__main__':
+    main()

syndesi-0.2.2/syndesi/proxy/proxy_api.py

@@ -0,0 +1,93 @@
+# proxy_api.py
+# Sébastien Deriaz
+# 29.05.2024
+
+import sys
+from dataclasses import dataclass
+
+from ..api.api import APICall, ACTION_ATTRIBUTE, register_api, APIItem
+
+class ProxyException(Exception):
+    pass
+
+# IP specific
+@dataclass
+class IPInstanciate(APICall):
+    action = 'ip_adapter_inst'
+    address : str
+    port : int
+    transport : str
+    buffer_size : int
+
+@dataclass
+class TimeoutAPI(APIItem):
+    name = 'timeout'
+    response : float
+    continuation : float
+    total : float
+    on_response : str
+    on_continuation : str
+    on_total : str
+
+@dataclass
+class StopConditionAPI(APIItem):
+    pass
+
+@dataclass
+class TerminationAPI(StopConditionAPI):
+    name = 'termination'
+    sequence : bytes
+
+@dataclass
+class LengthAPI(StopConditionAPI):
+    name = 'length'
+    length : int
+
+# Serial specific
+@dataclass
+class SerialPortInstanciate(APICall):
+    action = 'serial_adapter_inst'
+    port : str
+    baudrate : int
+    timeout : TimeoutAPI
+    stop_condition : StopConditionAPI
+    rts_cts : bool
+
+# Adapters common
+@dataclass
+class AdapterOpen(APICall):
+    action = 'adapter_open'
+
+@dataclass
+class AdapterClose(APICall):
+    action = 'adapter_close'
+
+@dataclass
+class AdapterWrite(APICall):
+    action = 'adapter_write'
+    data : bytes
+
+@dataclass
+class AdapterFlushRead(APICall):
+    action = 'adapter_flush_read'
+
+@dataclass
+class AdapterRead(APICall):
+    action = 'adapter_read'
+
+@dataclass
+class AdapterReadReturn(APICall):
+    action = 'adapter_read_return'
+    data : bytes
+    return_metrics : dict = None
+
+@dataclass
+class ReturnStatus(APICall):
+    action = 'return_status'
+    success : bool
+    error_message : str = ''
+
+# Register apis
+current_module = sys.modules[__name__]
+API_CALLS_PER_ACTION = {getattr(obj, ACTION_ATTRIBUTE) : obj for obj in current_module.__dict__.values() if hasattr(obj, ACTION_ATTRIBUTE)}
+register_api(API_CALLS_PER_ACTION)

{syndesi-0.2.0 → syndesi-0.2.2/syndesi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: syndesi
-Version: 0.2.0
+Version: 0.2.2
 Summary: Syndesi
 Author: Sebastien Deriaz
 Author-email: sebastien.deriaz1@gmail.com

{syndesi-0.2.0 → syndesi-0.2.2}/syndesi.egg-info/SOURCES.txt

@@ -18,12 +18,17 @@ syndesi/adapters/stop_conditions.py
 syndesi/adapters/timed_queue.py
 syndesi/adapters/timeout.py
 syndesi/adapters/visa.py
+syndesi/api/__init__.py
+syndesi/api/api.py
 syndesi/protocols/__init__.py
 syndesi/protocols/delimited.py
 syndesi/protocols/protocol.py
 syndesi/protocols/raw.py
 syndesi/protocols/scpi.py
 syndesi/protocols/sdp.py
+syndesi/proxy/__init__.py
+syndesi/proxy/proxy.py
+syndesi/proxy/proxy_api.py
 syndesi/tools/__init__.py
 syndesi/tools/exceptions.py
 syndesi/tools/log.py