syndesi 0.1.6__py3-none-any.whl → 0.2.1__py3-none-any.whl

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

@@ -1,12 +1,18 @@
-from .adapter import Adapter
+import os
 import serial
+from threading import Thread
+from typing import Union
+import select
+import argparse
+#from collections.abc import Sequence
+
+from .adapter import Adapter
 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
+from ..tools import shell
+from ..tools.others import DEFAULT
 
 # From pyserial - serialposix.py
 import fcntl
@@ -17,16 +23,15 @@ if hasattr(termios, 'TIOCINQ'):
 else:
     TIOCINQ = getattr(termios, 'FIONREAD', 0x541B)
 TIOCM_zero_str = struct.pack('I', 0)
-import os
 
-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
@@ -36,8 +41,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
@@ -60,10 +68,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 +87,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))
@@ -87,7 +99,8 @@ class SerialPort(Adapter):
         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]
+            #in_waiting = struct.unpack('I', fcntl.ioctl(port.fd, TIOCINQ, TIOCM_zero_str))[0]
+            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:
                 ready, _, _ = select.select([port.fd, stop_event_pipe], [], [], None)
                 if stop_event_pipe in ready:
@@ -125,4 +138,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/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
 
@@ -128,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:
         """
@@ -152,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/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():
@@ -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:
@@ -264,10 +273,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/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/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/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/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/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/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/tools/others.py

@@ -1,10 +1 @@
-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)
-        
+DEFAULT = 'default'

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.dist-info → syndesi-0.2.1.dist-info}/METADATA

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

{syndesi-0.1.6.dist-info → syndesi-0.2.1.dist-info}/RECORD

@@ -2,19 +2,22 @@ experiments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 syndesi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 syndesi/adapters/IP.py,sha256=4QFxFZeZLDHCpPqtpGQuqmT9pjLiKUNT6zjqkoCZBfE,2093
 syndesi/adapters/VISA.py,sha256=GW4ZaW2cQ-0AmAOTeFcxZZz9E2V8URozR4a0Wpqpvgs,1119
-syndesi/adapters/__init__.py,sha256=Nwkpd3x4bmUMNZK5aO761IxFeKcTamZvdk7lbrU0HHs,199
-syndesi/adapters/adapter.py,sha256=X1U8lNWH1TkFcPXpJqZqV5PvJYGLiv3Y4mgm2SVjcsA,10286
+syndesi/adapters/__init__.py,sha256=Ya9cfzEubB35225S3HD-NI8UkfzS0P6uVZkgG_tTDTI,225
+syndesi/adapters/adapter.py,sha256=Y3P_uGHZEEsJQw7gME3oEhzYaPhClPxq67j5FKXsvbU,10824
 syndesi/adapters/auto.py,sha256=ONniaTqYuotdLg88PdyUY87gzLglWzejEURqDw3Q4dE,1688
 syndesi/adapters/iadapter.py,sha256=45scoY1khaSdZdIPETb0IuColPuEEE6LRw9OtHGl5v0,6884
-syndesi/adapters/ip.py,sha256=XZHKhXWwv1ud4ljsY557l-SBV0McPT4aJ2K76v40ApU,4399
+syndesi/adapters/ip.py,sha256=GWWxaRgmlcqdA2vb7OAYBAdjJdXimE0l3y3PE31AwjE,5422
 syndesi/adapters/ip_server.py,sha256=wFMF_uPvVnYHPqAkAOvIvRTrMh_WMtK53hUorzD9L5s,3802
+syndesi/adapters/proxy.py,sha256=Vdfh7UZLf3tJ68MItVkQijOnOT5iQaqDbvmKH9P7nhU,3011
 syndesi/adapters/remote.py,sha256=XaaMGVSq7ygEijbETlsy-2cHSmMhZmmjA6UCm7hBTmE,552
 syndesi/adapters/serial.py,sha256=cDp4lFt1f6Z6pRTWRXn0mjT_p0mZgAxqiJgtoXnEHDk,877
-syndesi/adapters/serialport.py,sha256=1lvQvYPrffcB2F6Y43mVEjx0g64XAurbNUfjFhJbMrg,4804
-syndesi/adapters/stop_conditions.py,sha256=X9PDQXHw3XJ16iFoPLJkhntYlfEhTWyye1gC8b75teI,5070
+syndesi/adapters/serialport.py,sha256=Uh64McFdvHqZJJfZXIZnqgU-cPvUhRnz91gLecEQJRg,6025
+syndesi/adapters/stop_conditions.py,sha256=-dWUpgXbFEtONBnvk04gjFUhcprf_KJb28aFMgsps4A,5599
 syndesi/adapters/timed_queue.py,sha256=F-Bwj91cR_iLN2TdCkFL4WfvlJXovhyRF7K3dm30g50,912
-syndesi/adapters/timeout.py,sha256=dCygGczGMvS0NV5QSSg-eJHOp8fhQWwmnb85Lus_Ksg,11081
+syndesi/adapters/timeout.py,sha256=fH5MIJIUEqgDXtF9EgxZgjgAQ0mdeoybcmFznutXINo,11656
 syndesi/adapters/visa.py,sha256=CHOGT6ZXhW3bROdFDYVEI9UXrXQbKgGnudxi14nFRaU,1304
+syndesi/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syndesi/api/api.py,sha256=OvoAkE__r9-VVdVgZs88707AC36d5R5J36DkQMdJgfs,2352
 syndesi/descriptors/IP.py,sha256=vr7UbD9B11QJLbpIMycqs2Aqq41IY_WWD_JjeZ5b1FY,124
 syndesi/descriptors/Serial.py,sha256=pO3MtQpWxV_gdSWsGLQ6nf-cANB1rLy8YSEDAK2Tb5I,127
 syndesi/descriptors/VISA.py,sha256=-OSp7ll2ZHme-Oj736h1wd96HHYGNy4EtGtajzNNvVE,706
@@ -32,26 +35,29 @@ syndesi/descriptors/syndesi/payload.py,sha256=SplKy_Fu4XXcgMY12ed162gS--otUKkPtA
 syndesi/descriptors/syndesi/sdid.py,sha256=0B_gHdRhjauW1aY-JF8B60gEY9Cz1TYPiKE3QnhePTM,346
 syndesi/protocols/__init__.py,sha256=0lLF9oH-K_nMp8OoztFfsidFmed2TBBffnN_zJT3f-4,145
 syndesi/protocols/commands.py,sha256=iZusNzht5zK31Uxdx3e2S4mXIdqcz5jBNuozajWuNQM,1898
-syndesi/protocols/delimited.py,sha256=LBX9FiLFzEyjoRMowwwDo135rww5iU9dWmaw7XliABA,3609
+syndesi/protocols/delimited.py,sha256=-F36ZvyIrAqO4bpxY-ZAXFM_zXi-CJluZj5M2tXGq_A,2997
 syndesi/protocols/iprotocol.py,sha256=TwAiu1Fxq9-vpxGu8f7WuADgeBvTORSIIwJ1vABqhuo,247
 syndesi/protocols/protocol.py,sha256=yRgy_5Sj4LFA-CAAdFX0ZkC7m8GE5NuLv2aSGI5rwKQ,402
 syndesi/protocols/raw.py,sha256=wqo2sIud1eWqQ-akGhwhOT8aI3SLiu4jlKJ5MgmhPbU,1019
-syndesi/protocols/scpi.py,sha256=GUXDWMoGyQwpT50DNaWrid0ENVzE_dfVkfxbVYt0l9M,3436
+syndesi/protocols/scpi.py,sha256=gU38dfaOhBJVmgDzLkXSqBqjP32uKLzRM5_jZCdCtOQ,3462
 syndesi/protocols/sdp.py,sha256=PQe8zwR2xRiKPVvZL8BqHKvxflyg5dJeV4BAaDMnNw8,313
+syndesi/proxy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syndesi/proxy/proxy.py,sha256=hsxRru-uJ_L9TIfTPqIFG_X1eOn3SR2forFrL70q0DE,5028
+syndesi/proxy/proxy_api.py,sha256=4dhprayG-iWIxEOdnpYwGhfi1cBA_mhuE1FilXpk8X0,1886
 syndesi/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 syndesi/tools/exceptions.py,sha256=KXMqrmwoTxfcGFUtjzQLlFS-QhKqwMTsnhDfQveDirc,303
-syndesi/tools/log.py,sha256=j6y4_Y2y1f4HX0CVsL70svV7HRRzRhuwXtXKruXN29U,3508
+syndesi/tools/log.py,sha256=zOPQA4ZSDU8qCwomS4w61vd9KJ3yTprAnOWYyV7tliM,3542
 syndesi/tools/logger.py,sha256=2Li7mRBtf06BXdGBa-I5aC4y4r2CxWEI8nmC6wh4-GE,3184
-syndesi/tools/others.py,sha256=r4Ad3TNOb5Lj1jnpIw4PPJTCOrCOVzT9ryAoqY-INGg,258
+syndesi/tools/others.py,sha256=y7sCWrnsgA3ih1eauucmOUbxHW6lVA120_g3co0MxDI,19
 syndesi/tools/remote_api.py,sha256=crokpha5PQQI5v5KtYe34X7N-rfKi4JGjN-Z6vyCSmo,3003
 syndesi/tools/remote_server.py,sha256=jSZZYzr6_kUo5Nb8_tA_whQceAcuKJrvSO3IdU94fBY,4830
 syndesi/tools/shell.py,sha256=A13htgZ0FsFfe8GMlv-4P_w0pv44ca5r4yshz990uqs,3556
 syndesi/tools/stop_conditions.py,sha256=_H-GPczrLTbPRHYpoPIItOqmPnemwn34QbKFn5GD6Uc,4824
-syndesi/tools/types.py,sha256=GAv3BCSZcCGsYH1milxKVIPmBkSxLfVcinqnuFqXflk,1631
-syndesi-0.1.6.data/scripts/syndesi,sha256=1y5vfiQPEissF1XsH7pfJYIKf1Lp3ScZWFtPdGELNws,956
+syndesi/tools/types.py,sha256=rEpz5wEYGcJgYkRffRP9sYAhKv8X6DNCXIeI8Zcsvfc,1630
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syndesi-0.1.6.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-syndesi-0.1.6.dist-info/METADATA,sha256=_M69G9-kc-gtdlCrB0XrgrG5JhP7SQkdKy9SslS9Tgo,3468
-syndesi-0.1.6.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-syndesi-0.1.6.dist-info/top_level.txt,sha256=HrY36JU6hFYp_6qv-GuVBBtHYYemn8qhCrqpvXBd1Lg,8
-syndesi-0.1.6.dist-info/RECORD,,
+syndesi-0.2.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+syndesi-0.2.1.dist-info/METADATA,sha256=alER12YD9J_KdOjJSycLYl3zkovbPhxX4bf8M2K6geA,3468
+syndesi-0.2.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+syndesi-0.2.1.dist-info/entry_points.txt,sha256=Q_38BGDXKEFxNPSXtkT8brn6f8lmOrkdkEv0IOV-YOM,96
+syndesi-0.2.1.dist-info/top_level.txt,sha256=HrY36JU6hFYp_6qv-GuVBBtHYYemn8qhCrqpvXBd1Lg,8
+syndesi-0.2.1.dist-info/RECORD,,

syndesi-0.2.1.dist-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.data/scripts/syndesi

@@ -1,57 +0,0 @@
-#!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()