syndesi 0.1.6__tar.gz → 0.2.0__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '0.1.6'
+VERSION = '0.2.0'
 DESCRIPTION = 'Syndesi'
 
 with open("README.md", "r", encoding="utf-8") as fh:
@@ -15,7 +15,11 @@ setup(
     description=DESCRIPTION,
     long_description_content_type="text/markdown",
     long_description=long_description,
-    scripts=['bin/syndesi'],
+    entry_points = {
+        'console_scripts': [
+            'syndesi=syndesi.shell.syndesi:main',
+            'syndesi-proxy=syndesi.proxy.proxy:main'],
+    },
     packages=find_packages(),
     install_requires=[''],
     keywords=['python', 'syndesi', 'interface', 'ethernet'],

{syndesi-0.1.6 → syndesi-0.2.0}/syndesi/adapters/__init__.py

@@ -2,6 +2,7 @@ from .adapter import Adapter
 from .ip import IP
 from .serialport import SerialPort
 from .visa import VISA
+from .proxy import Proxy
 
 from .timeout import Timeout
-from .stop_conditions import Termination, Length, StopCondition
+from .stop_conditions import Termination, Length, StopCondition

{syndesi-0.1.6 → syndesi-0.2.0}/syndesi/adapters/adapter.py

@@ -29,10 +29,14 @@ from ..tools.log import LoggerAlias
 import logging
 from time import time
 from dataclasses import dataclass
-from ..tools.others import default_argument, is_default_argument
+from ..tools.others import DEFAULT
 
-DEFAULT_TIMEOUT = default_argument(Timeout(response=1, continuation=100e-3, total=None))
-DEFAULT_STOP_CONDITION = default_argument(StopCondition())
+DEFAULT_TIMEOUT = Timeout(response=1, continuation=100e-3, total=None)
+DEFAULT_STOP_CONDITION = None
+
+
+class AdapterDisconnected(Exception):
+    pass
 
 STOP_DESIGNATORS = {
     'timeout' : {
@@ -68,10 +72,7 @@ class Adapter(ABC):
         DISCONNECTED = 0
         CONNECTED = 1
 
-    def __init__(self,
-        alias : str = '',
-        timeout : Union[float, Timeout] = DEFAULT_TIMEOUT,
-        stop_condition : Union[StopCondition, None] = DEFAULT_STOP_CONDITION):
+    def __init__(self, alias : str = '', stop_condition : Union[StopCondition, None] = DEFAULT, timeout : Union[float, Timeout] = DEFAULT) -> None:
         """
         Adapter instance
 
@@ -84,24 +85,33 @@ class Adapter(ABC):
         stop_condition : StopCondition or None
             Default to None
         """
+        super().__init__()
+        self._alias = alias
 
-        if is_number(timeout):
-            self._timeout = Timeout(response=timeout, continuation=100e-3)
-        elif isinstance(timeout, Timeout):
-            self._timeout = timeout
+        self._default_stop_condition = stop_condition == DEFAULT
+        if self._default_stop_condition:
+            self._stop_condition = DEFAULT_STOP_CONDITION
         else:
-            raise ValueError(f"Invalid timeout type : {type(timeout)}")
-
-        self._stop_condition = stop_condition
+            self._stop_condition = stop_condition
         self._read_queue = TimedQueue()
         self._thread : Union[Thread, None] = None
         self._status = self.Status.DISCONNECTED
+        self._logger = logging.getLogger(LoggerAlias.ADAPTER.value)
+
         # Buffer for data that has been pulled from the queue but
         # not used because of termination or length stop condition
         self._previous_read_buffer = b''
 
-        self._alias = alias
-        self._logger = logging.getLogger(LoggerAlias.ADAPTER.value)
+        self._default_timeout = timeout == DEFAULT
+        if self._default_timeout:
+            self._timeout = DEFAULT_TIMEOUT
+        else:
+            if is_number(timeout):
+                self._timeout = Timeout(response=timeout, continuation=100e-3)
+            elif isinstance(timeout, Timeout):
+                self._timeout = timeout
+            else:
+                raise ValueError(f"Invalid timeout type : {type(timeout)}")
 
     def set_default_timeout(self, default_timeout : Union[Timeout, tuple, float]):
         """
@@ -111,7 +121,10 @@ class Adapter(ABC):
         ----------
         default_timeout : Timeout or tuple or float
         """
-        self._timeout = timeout_fuse(self._timeout, default_timeout)
+        if self._default_timeout:
+            self._timeout = default_timeout
+        else:
+            self._timeout = timeout_fuse(self._timeout, default_timeout)
 
     def set_default_stop_condition(self, stop_condition):
         """
@@ -121,9 +134,8 @@ class Adapter(ABC):
         ----------
         stop_condition : StopCondition
         """
-        if is_default_argument(self._stop_condition):
+        if self._default_stop_condition:
             self._stop_condition = stop_condition
-        
 
     def flushRead(self):
         """
@@ -145,7 +157,7 @@ class Adapter(ABC):
         Stop communication with the device
         """
         pass
-            
+
     @abstractmethod
     def write(self, data : Union[bytes, str]):
         """
@@ -156,14 +168,11 @@ class Adapter(ABC):
         data : bytes or str
         """
         pass
-
-    @abstractmethod
-    def _start_thread(self):
-        """
-        Initiate the read thread
-        """
-        pass
     
+    # TODO : Return None or b'' when read thread is killed while reading
+    # This is to detect if a server socket has been closed
+
+
     def read(self, timeout=None, stop_condition=None, return_metrics : bool = False) -> bytes:
         """
         Read data from the device
@@ -222,6 +231,9 @@ class Adapter(ABC):
                 (timestamp, fragment) = self._read_queue.get(timeout_ms)
                 n_fragments += 1
 
+                if fragment == b'':
+                    raise AdapterDisconnected()
+
                 # 1) Evaluate the timeout
                 stop, timeout_ms = timeout.evaluate(timestamp)
                 if stop:
@@ -290,6 +302,13 @@ class Adapter(ABC):
         else:
             return output
 
+    @abstractmethod
+    def _start_thread(self):
+        pass
+
+    def __del__(self):
+        self.close()
+
     @abstractmethod
     def query(self, data : Union[bytes, str], timeout=None, stop_condition=None, return_metrics : bool = False) -> bytes:
         """
@@ -299,6 +318,4 @@ class Adapter(ABC):
         - read
         """
         pass
-
-    def __del__(self):
-        self.close()
+    

{syndesi-0.1.6 → syndesi-0.2.0}/syndesi/adapters/ip.py

@@ -7,22 +7,24 @@ from threading import Thread
 from .timed_queue import TimedQueue
 from typing import Union
 from time import time
+import argparse
+from ..tools import shell
 
-DEFAULT_RESPONSE_TIMEOUT = 1
-DEFAULT_CONTINUATION_TIMEOUT = 1e-3
-DEFAULT_TOTAL_TIMEOUT = 5
-
-DEFAULT_BUFFER_SIZE = 1024
+class IP(Adapter):
+    DEFAULT_RESPONSE_TIMEOUT = 1
+    DEFAULT_CONTINUATION_TIMEOUT = 1e-3
+    DEFAULT_TOTAL_TIMEOUT = 5
 
-DEFAULT_TIMEOUT = Timeout(
-                    response=DEFAULT_RESPONSE_TIMEOUT,
-                    continuation=DEFAULT_CONTINUATION_TIMEOUT,
-                    total=DEFAULT_TOTAL_TIMEOUT)
 
-class IP(Adapter):
+    DEFAULT_TIMEOUT = Timeout(
+                        response=DEFAULT_RESPONSE_TIMEOUT,
+                        continuation=DEFAULT_CONTINUATION_TIMEOUT,
+                        total=DEFAULT_TOTAL_TIMEOUT)
+    DEFAULT_BUFFER_SIZE = 1024
     class Protocol(Enum):
         TCP = 'TCP'
         UDP = 'UDP'
+
     def __init__(self,
                 address : str,
                 port : int = None,
@@ -30,7 +32,8 @@ class IP(Adapter):
                 timeout : Union[Timeout, float] = DEFAULT_TIMEOUT,
                 stop_condition = None,
                 alias : str = '',
-                buffer_size : int = DEFAULT_BUFFER_SIZE):
+                buffer_size : int = DEFAULT_BUFFER_SIZE,
+                _socket : socket.socket = None):
         """
         IP stack adapter
 
@@ -50,17 +53,24 @@ class IP(Adapter):
             Specify an alias for this adapter, '' by default
         buffer_size : int
             Socket buffer size, may be removed in the future
+        socket : socket.socket
+            Specify a custom socket, this is reserved for server application
         """
         super().__init__(alias=alias, timeout=timeout, stop_condition=stop_condition)
         self._transport = self.Protocol(transport)
-        if self._transport == self.Protocol.TCP:
-            self._logger.info("Setting up TCP IP adapter")
+        self._is_server = _socket is not None
+
+        self._logger.info(f"Setting up {self._transport.value} IP adapter ({'server' if self._is_server else 'client'})")
+
+        if self._is_server:
+            # Server
+            self._socket = _socket
+            self._status = self.Status.CONNECTED
+        elif self._transport == self.Protocol.TCP:
             self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         elif self._transport == self.Protocol.UDP:
-            self._logger.info("Setting up UDP IP adapter")
             self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        else:
-            raise ValueError("Invalid protocol")
+        
         self._address = address
         self._port = port
         self._buffer_size = buffer_size
@@ -80,45 +90,61 @@ class IP(Adapter):
             self._port = port
 
     def open(self):
+        if self._is_server:
+            raise SystemError("Cannot open server socket. It must be passed already opened")
         if self._port is None:
             raise ValueError(f"Cannot open adapter without specifying a port")
+
+        self._logger.debug(f"Adapter {self._alias} connect to ({self._address}, {self._port})")
         self._socket.connect((self._address, self._port))
         self._status = self.Status.CONNECTED
-        self._logger.info("Adapter opened !")
+        self._logger.info(f"Adapter {self._alias} opened !")
 
     def close(self):
         if hasattr(self, '_socket'):
             self._socket.close()
         self._logger.info("Adapter closed !")
+        self._status = self.Status.DISCONNECTED
             
     def write(self, data : Union[bytes, str]):
         data = to_bytes(data)
         if self._status == self.Status.DISCONNECTED:
-            self._logger.info("Adapter is closed, opening...")
+            self._logger.info(f"Adapter {self._alias} is closed, opening...")
             self.open()
         write_start = time()
         self._socket.send(data)
         write_duration = time() - write_start
         self._logger.debug(f"Written [{write_duration*1e3:.3f}ms]: {repr(data)}")
 
+    def _start_thread(self):
+        self._logger.debug("Starting read thread...")
+        self._thread = Thread(target=self._read_thread, daemon=True, args=(self._socket, self._read_queue))
+        self._thread.start()
+
+    # EXPERIMENTAL
+    def read_thread_alive(self):
+        return self._thread.is_alive()
+
+
     def _read_thread(self, socket : socket.socket, read_queue : TimedQueue):
-        while True:
+        while True: # TODO : Add stop_pipe ? Maybe it was removed ?
             try:
                 payload = socket.recv(self._buffer_size)
                 if len(payload) == self._buffer_size and self._transport == self.Protocol.UDP:
                     self._logger.warning("Warning, inbound UDP data may have been lost (max buffer size attained)")
             except OSError:
                 break
-            if not payload:
+            # If payload is empty, it means the socket has been disconnected
+            if payload == b'':
+                read_queue.put(payload)
                 break
             read_queue.put(payload)
 
-    def _start_thread(self):
-        self._logger.debug("Starting read thread...")
-        self._thread = Thread(target=self._read_thread, daemon=True, args=(self._socket, self._read_queue))
-        self._thread.start()
-
     def query(self, data : Union[bytes, str], timeout=None, stop_condition=None, return_metrics : bool = False):
+        if self._is_server:
+            raise SystemError("Cannot query on server adapters")
         self.flushRead()
         self.write(data)
-        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+    
+    

syndesi-0.2.0/syndesi/adapters/ip_server.py

@@ -0,0 +1,108 @@
+# ip_server.py
+# Sébastien Deriaz
+# 31.05.2024
+
+import socket
+from enum import Enum
+from . import IP, StopCondition, Timeout
+from time import time
+from ..tools.types import to_bytes
+from .timeout import timeout_fuse
+import logging
+from ..tools.log import LoggerAlias
+
+# NOTE : The adapter is only meant to work with a single client, thus
+# a IPServer class is made to handle the socket and generate IP adapters
+
+class IPServer:
+    DEFAULT_BUFFER_SIZE = 1024
+    class Protocol(Enum):
+        TCP = 'TCP'
+        UDP = 'UDP'
+
+    def __init__(self,
+                port : int = None,
+                transport : str = 'TCP',
+                address : str = None,
+                max_clients : int = 5,
+                stop_condition = None,
+                alias : str = '',
+                buffer_size : int = DEFAULT_BUFFER_SIZE):
+
+        """
+        IP server adapter
+
+        Parameters
+        ----------
+        port : int
+            IP port. If None, the default port set with set_default_port will be used
+        transport : str
+            'TCP' or 'UDP'
+        address : str
+            Custom socket ip, None by default
+        max_clients : int
+            Maximum number of clients, 5 by default
+        stop_condition : StopCondition
+            Specify a read stop condition (None by default)
+        alias : str
+            Specify an alias for this adapter, '' by default
+        buffer_size : int
+            Socket buffer size, may be removed in the future
+        """
+        self._alias = alias
+        self._stop_condition = stop_condition
+        self._logger = logging.getLogger(LoggerAlias.ADAPTER.value)
+        self._transport = self.Protocol(transport)
+        if self._transport == self.Protocol.TCP:
+            self._logger.info("Setting up TCP IP server adapter")
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        elif self._transport == self.Protocol.UDP:
+            self._logger.info("Setting up UDP IP server adapter")
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        else:
+            raise ValueError("Invalid protocol")
+
+        self._address = socket.gethostname() if address is None else address
+        self._port = port
+        self._max_clients = max_clients
+        self._opened = False
+        
+
+    def set_default_port(self, port):
+        """
+        Sets IP port if no port has been set yet.
+
+        This way, the user can leave the port empty
+        and the driver/protocol can specify it later
+        
+        Parameters
+        ----------
+        port : int
+        """
+        if self._port is None:
+            self._port = port
+
+
+    def open(self):
+        if self._port is None:
+            raise ValueError(f"Cannot open adapter without specifying a port")
+        self._logger.info(f"Listening to incoming connections on {self._address}:{self._port}")
+        self._socket.bind((self._address, self._port))
+        self._socket.listen(self._max_clients)
+        self._opened = True
+
+    def close(self):
+        if hasattr(self, '_socket'):
+            self._socket.close()
+        self._logger.info("Adapter closed !")
+        self._opened = False
+
+    def get_client(self, stop_condition : StopCondition = None, timeout : Timeout = None) -> IP:
+        """
+        Wait for a client to connect to the server and return the corresponding adapter
+        """
+        if not self._opened:
+            raise RuntimeError("open() must be called before getting client")
+        client_socket, address = self._socket.accept()
+        default_timeout = Timeout(response=None, continuation=IP.DEFAULT_CONTINUATION_TIMEOUT, total=None)
+        return IP(_socket=client_socket, address=address, stop_condition=stop_condition, timeout=timeout_fuse(timeout, default_timeout))

syndesi-0.2.0/syndesi/adapters/proxy.py

@@ -0,0 +1,92 @@
+# proxy.py
+# Sébastien Deriaz
+# 09.04.2024
+#
+# The proxy adapter allows for commands to be issued on a different device
+# The goal is to istanciate a class as such :
+#
+# Only adapter :
+#   # The proxy computer is accessed with 192.168.1.1 
+#   # The device (connected to the remote computer) is accessed with 192.168.2.1
+#   my_adapter = Proxy('192.168.1.1', IP('192.168.2.1'))
+#
+# Protocol :
+#   my_protocol = SCPI(Proxy('192.168.1.1', Serial('/dev/ttyUSB0')))
+#
+#
+# Driver :
+#   my_device = Driver(Proxy('192.168.1.1', VISA('...')))
+
+from enum import Enum
+from typing import Union
+
+from .adapter import Adapter
+from .. import IP, SerialPort, VISA
+from ..proxy.proxy_api import *
+from ..api.api import parse
+
+DEFAULT_PORT = 2608
+
+class Proxy(Adapter):
+    def __init__(self, proxy_adapter : Adapter, remote_adapter : Adapter):
+        """
+        Proxy adapter
+
+        Parameters
+        ----------
+        proxy_adapter : Adapter
+            Adapter to connect to the proxy server
+        remote_adapter : Adapter
+            Adapter to instanciate onto the proxy server
+        """
+        super().__init__()
+
+        self._proxy = proxy_adapter
+        self._remote = remote_adapter
+
+        if isinstance(proxy_adapter, IP):
+            proxy_adapter.set_default_port(DEFAULT_PORT)
+
+        if isinstance(self._remote, IP):
+            self._proxy.query(IPInstanciate(
+                    address=self._remote._address,
+                    port=self._remote._port,
+                    transport=self._remote._transport,
+                    buffer_size=self._remote._buffer_size
+                ).encode())
+        elif isinstance(self._remote, SerialPort):
+            self._proxy.query()
+
+    def check(self, status : ReturnStatus):
+        if not status.success:
+            # There is an error
+            raise ProxyException(status.error_message)
+
+    def open(self):
+        if isinstance(self._remote, IP):
+            self._proxy.query(AdapterOpen().encode())
+
+    def close(self):
+        self._proxy.query(AdapterClose().encode())
+
+    def write(self, data : Union[bytes, str]):
+        self._proxy.query(AdapterWrite(data).encode())
+
+    def read(self, timeout=None, stop_condition=None, return_metrics : bool = False):
+        output : AdapterReadReturn
+        output = parse(self._proxy.query(AdapterRead().encode()))
+        if isinstance(output, AdapterReadReturn):
+            return output.data
+        elif isinstance(output, ReturnStatus):
+            raise ProxyException(output.error_message)
+        else:
+            raise RuntimeError(f"Invalid return : {type(output)}")
+
+
+    def query(self, data : Union[bytes, str], timeout=None, stop_condition=None, return_metrics : bool = False):
+        self.check(parse(self._proxy.query(AdapterFlushRead().encode())))
+        self.check(parse(self._proxy.query(AdapterWrite(data).encode())))
+        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+
+    def _start_thread(self):
+        pass

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

@@ -7,6 +7,9 @@ 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 pyserial - serialposix.py
 import fcntl
@@ -60,10 +63,11 @@ class SerialPort(Adapter):
         self._logger.info("Adapter opened !")
 
     def close(self):
-        if self._thread.is_alive():
+        if self._thread is not None and self._thread.is_alive():
             os.write(self._stop_event_pipe_write, b'1')
             self._thread.join()
-        self._port.close()
+        if hasattr(self, '_port'):
+            self._port.close()
         self._logger.info("Adapter closed !")
             
     def write(self, data : bytes):
@@ -78,6 +82,9 @@ class SerialPort(Adapter):
         self._logger.debug(f"Written [{write_duration*1e3:.3f}ms]: {repr(data)}")
 
     def _start_thread(self):
+        """
+        Start the read thread
+        """
         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))
@@ -125,4 +132,21 @@ class SerialPort(Adapter):
     def query(self, data : Union[bytes, str], timeout=None, stop_condition=None, return_metrics : bool = False):
         self.flushRead()
         self.write(data)
-        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+        return self.read(timeout=timeout, stop_condition=stop_condition, return_metrics=return_metrics)
+
+    def shell_parse(inp: str):
+        parser = argparse.ArgumentParser(
+        prog='',
+        description='Serial port shell parser',
+        epilog='')
+        # Parse subcommand    
+        parser.add_argument('--' + shell.Arguments.PORT.value, type=str)
+        parser.add_argument('--' + shell.Arguments.BAUDRATE.value, type=int)
+        parser.add_argument('--' + shell.Arguments.ENABLE_RTS_CTS.value, action='store_true')
+        args = parser.parse_args(inp.split())
+
+        return {
+            'port' : getattr(args, shell.Arguments.PORT.value),
+            'baudrate' : getattr(args, shell.Arguments.BAUDRATE.value),
+            'rts_cts' : bool(getattr(args, shell.Arguments.ENABLE_RTS_CTS.value))
+        }

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

@@ -60,7 +60,13 @@ class Termination(StopCondition):
         sequence : bytes
         """
         super().__init__()
-        self._termination = sequence
+        if isinstance(sequence, str):
+            self._termination = sequence.encode('utf-8')
+        elif isinstance(sequence, bytes):
+            self._termination = sequence
+        else:
+            raise ValueError(f"Invalid termination sequence type : {type(sequence)}")
+
         #self._fragment_store = b''
         #self._sequence_index = 0
 

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

@@ -5,7 +5,7 @@
 from enum import Enum
 from typing import Union, Tuple
 from time import time
-from ..tools.others import is_default_argument
+#from ..tools.others import is_default_argument
 
 
 class Timeout():
@@ -264,10 +264,11 @@ def timeout_fuse(high_priority, low_priority):
     low = low_priority if isinstance(low_priority, Timeout) else Timeout(low_priority)
 
     # 3) If one is the default, take the other
-    if is_default_argument(high):
-        return low
-    if is_default_argument(low):
-        return high
+    # if is_default_argument(high):
+    #     return low
+    # if is_default_argument(low):
+    #     return high
+    # 05.06.2024 : Removed because is_default_argument is obsolete, use DEFAULT is necessary
     
     new_attr = {}
     # 4) Select with parameter to keep based on where it has been set

{syndesi-0.1.6 → syndesi-0.2.0}/syndesi/protocols/scpi.py

@@ -1,7 +1,8 @@
 from ..adapters import Adapter, IP, Timeout, Termination, StopCondition
 from .protocol import Protocol
 from ..tools.types import is_byte_instance
-from ..tools.others import is_default_argument
+#from ..tools.others import is_default_argument
+from ..tools.others import DEFAULT
 
 class SCPI(Protocol):
     DEFAULT_PORT = 5025
@@ -32,7 +33,7 @@ class SCPI(Protocol):
             self._adapter.set_default_port(self.DEFAULT_PORT)
 
         self._adapter.set_default_timeout(timeout)
-        if is_default_argument(self._adapter._stop_condition):
+        if self._adapter._stop_condition != DEFAULT:
             raise ValueError('A conflicting stop-condition has been set for this adapter')
         self._adapter._stop_condition = Termination(self._receive_termination.encode(encoding=encoding))
 

{syndesi-0.1.6 → syndesi-0.2.0}/syndesi/tools/log.py

@@ -11,6 +11,7 @@ from typing import List, Union
 class LoggerAlias(Enum):
     ADAPTER = 'adapter'
     PROTOCOL = 'protocol'
+    PROXY_SERVER = 'proxy_server'
 
 default_formatter = logging.Formatter('%(asctime)s:%(name)s:%(levelname)s:%(message)s')
 

syndesi-0.2.0/syndesi/tools/others.py

@@ -0,0 +1 @@
+DEFAULT = 'default'

syndesi-0.2.0/syndesi/tools/shell.py

@@ -0,0 +1,111 @@
+# shell.py
+# Sébastien Deriaz
+# 30.04.2024
+from enum import Enum
+from cmd import Cmd
+from syndesi.adapters import *
+import argparse
+import shlex
+import sys
+import os
+from colorist import ColorRGB
+
+VERSION = 0.1
+
+class ShellPrompt(Cmd):
+    __hiden_methods = ('do_EOF','do_clear','do_cls')
+    PROMPT_COLOR = ColorRGB(28, 90, 145)
+
+    prompt = f'{PROMPT_COLOR}❯ {PROMPT_COLOR.OFF}'
+    intro = "Welcome to the Syndesi Shell! Type ? to list commands"
+
+    def get_names(self):
+        return [n for n in dir(self.__class__) if n not in self.__hiden_methods]
+
+    def do_exit(self, inp):
+        """Exit"""
+        return True
+    
+    def do_serial(self, inp):
+        """Open serial adapter"""
+        self._adapter = SerialPort(**SerialPort.shell_parse(inp))
+
+    def do_ip(self, inp):
+        """Open IP adapter
+    -p / --port : port number
+    --ip : ip address
+    -t / --transport : TCP or UDP
+        """
+        parser = argparse.ArgumentParser()
+        parser.add_argument('-p', '--port', type=int, required=True)
+        parser.add_argument('--ip', type=str, required=True)
+        parser.add_argument('-t', '--transport', type=str, choices=['UDP', 'TCP'], default='TCP', required=False)
+        try:
+            args = parser.parse_args(shlex.split(inp))
+        except SystemExit as e:
+            pass
+        else:
+            self._adapter = IP(address=args.ip, port=args.port, transport=args.transport)
+
+    def default(self, inp):
+        if hasattr(self, '_adapter'):
+            cmd = inp + '\n'
+            output = self._adapter.query(cmd)
+            print(output)
+        else:
+            print(f"Unknown command : {inp}, type ? to list commands")
+
+    def do_clear(self, _):
+        if sys.platform == "linux" or sys.platform == "linux2" or sys.platform == "darwin":
+            # linux
+            os.system('clear')
+        elif sys.platform == "win32":
+            # Windows
+            os.system('cls')
+
+    def do_cls(self, _):
+        self.do_clear()
+
+    def do_help(self, arg: str) -> bool | None:
+        if arg:
+            # Use Cmd's help
+            super().do_help(arg)
+        else:
+            # Otherwise, print a custom help
+            names = self.get_names()
+
+            cmds_doc = []
+            cmds_undoc = []
+            docs = []
+            topics = set()
+            for name in names:
+                if name[:5] == 'help_':
+                    topics.add(name[5:])
+            names.sort()
+            # There can be duplicates if routines overridden
+            prevname = ''
+            for name in names:
+                if name[:3] == 'do_':
+                    if name == prevname:
+                        continue
+                    prevname = name
+                    cmd=name[3:]
+                    if cmd in topics:
+                        #cmds_doc.append(cmd)
+                        topics.remove(cmd)
+                    elif getattr(self, name).__doc__:
+                        cmds_doc.append(cmd)
+                        docs.append(getattr(self, name).__doc__)
+                    else:
+                        cmds_undoc.append(cmd)
+
+            print(f"Syndesi shell V{VERSION}")
+            print("Available commands :")
+            max_width = max([len(cmd) for cmd in cmds_doc])
+            for cmd, doc in zip(cmds_doc, docs):
+                print(f"  {cmd:<{max_width+2}} : {doc}")
+
+            #self.print_topics(self.misc_header,  sorted(topics),15,80)
+            #self.print_topics(self.undoc_header, cmds_undoc, 15,80)
+
+    do_EOF = do_exit # Allow CTRL+d to exit 

{syndesi-0.1.6 → syndesi-0.2.0}/syndesi/tools/types.py

@@ -72,7 +72,7 @@ def to_bytes(data):
     elif isinstance(data, str):
         return data.encode('utf-8')
     else:
-        return ValueError(f"Invalid data type : {type(data)}")
+        raise ValueError(f"Invalid data type : {type(data)}")
 
 
 

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

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

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

@@ -1,17 +1,18 @@
 LICENSE
 README.md
 setup.py
-bin/syndesi
 syndesi/__init__.py
 syndesi.egg-info/PKG-INFO
 syndesi.egg-info/SOURCES.txt
 syndesi.egg-info/dependency_links.txt
+syndesi.egg-info/entry_points.txt
 syndesi.egg-info/top_level.txt
 syndesi/adapters/__init__.py
 syndesi/adapters/adapter.py
 syndesi/adapters/auto.py
 syndesi/adapters/ip.py
-syndesi/adapters/remote.py
+syndesi/adapters/ip_server.py
+syndesi/adapters/proxy.py
 syndesi/adapters/serialport.py
 syndesi/adapters/stop_conditions.py
 syndesi/adapters/timed_queue.py
@@ -27,4 +28,5 @@ syndesi/tools/__init__.py
 syndesi/tools/exceptions.py
 syndesi/tools/log.py
 syndesi/tools/others.py
+syndesi/tools/shell.py
 syndesi/tools/types.py

syndesi-0.2.0/syndesi.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+syndesi = syndesi.shell.syndesi:main
+syndesi-proxy = syndesi.proxy.proxy:main

syndesi-0.1.6/bin/syndesi

@@ -1,57 +0,0 @@
-#!/usr/bin/env python
-
-# Syndesi CLI
-import argparse
-from cmd import Cmd
-from enum import Enum
-
-class MyPrompt(Cmd):
-    prompt = '❯ '
-    intro = "Welcome! Type ? to list commands"
-
-    def do_exit(self, inp):
-        print("Bye !")
-        return True
-
-    def do_connect(self, inp):
-        print("Device")
-
-    def default(self, inp):
-        print(f"Entered : {inp}")
-
-
-    do_EOF = do_exit # Allow CTRL+d to exit
- 
-
-class SubCommands(Enum):
-    SHELL = 'shell'
-
-
-
-
-def connect():
-    print("Entering connect subcommand...")
-
-    p = MyPrompt()
-    p.cmdloop()
-
-
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        prog='syndesi',
-        description='Syndesi command line interface',
-        epilog='')
-    # Parse subcommand    
-    parser.add_argument('subcommand', choices=[SubCommands.SHELL.value])
-
-    args = parser.parse_args()
-
-    if args.subcommand == SubCommands.SHELL.value:
-        connect()
-        
-
-
-if __name__ == '__main__':
-    main()

syndesi-0.1.6/syndesi/adapters/remote.py

@@ -1,18 +0,0 @@
-# remote.py
-# Sébastien Deriaz
-# 09.04.2024
-#
-# The remote adapter allows for commands to be issued on a different device through TCP
-# The goal is to istanciate a class as such :
-#
-# Only adapter :
-#   # The remote computer is accessed with 192.168.1.1
-#   # The device (connected to the remote computer) is accessed with 192.168.2.1
-#   my_adapter = Remote('192.168.1.1', IP('192.168.2.1'))
-#
-# Protocol :
-#   my_protocol = SCPI(Remote('192.168.1.1', Serial('/dev/ttyUSB0')))
-#
-#
-# Driver :
-#   my_device = Driver(Remote('192.168.1.1', VISA('...')))

syndesi-0.1.6/syndesi/tools/others.py

@@ -1,10 +0,0 @@
-DEFAULT_ATTRIBUTE_FLAG_NAME = '_is_default'
-
-
-def default_argument(instance):
-    setattr(instance, DEFAULT_ATTRIBUTE_FLAG_NAME, True)
-    return instance
-
-def is_default_argument(instance):
-    return hasattr(instance, DEFAULT_ATTRIBUTE_FLAG_NAME)
-