holado 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

holado_python/standard_library/socket/non_blocking_socket.py

@@ -17,8 +17,10 @@ from holado_python.standard_library.socket.socket import SocketClient
 import abc
 from holado_multitask.multithreading.loopfunctionthreaded import LoopFunctionThreaded
 import selectors
-import types
-import threading
+import ssl
+import select
+from holado.common.handlers.undefined import undefined_argument
+import time
 
 logger = logging.getLogger(__name__)
 
@@ -34,92 +36,85 @@ class NonBlockingSocketClient(SocketClient):
     """
     __metaclass__ = abc.ABCMeta
     
-    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None):
+    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument, do_run_with_recv=True, do_run_with_send=True):
         self.__selector = selectors.DefaultSelector()
         
-        self.__data_lock = threading.Lock()
-        self.__data = types.SimpleNamespace(
-            in_bytes=b"",
-            out_bytes=b"",
-        )
-        
-        # Note: __selector and __data must be defined before, since Socket.__init__ can execute create_ipv4_socket
-        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs)
-        
-        self.__start_thread = None
+        # Note: __selector must be defined before, since Socket.__init__ can execute create_ipv4_socket
+        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay, do_run_with_recv=do_run_with_recv, do_run_with_send=do_run_with_send)
 
     def _delete_object(self):
-        self.stop()
         if self.internal_socket:
+            # Note: stop must be done before unregistering selector
+            self.stop()
             self.__selector.unregister(self.internal_socket)
         
         super()._delete_object()
     
     def _register_socket(self, sock):
         events = selectors.EVENT_READ | selectors.EVENT_WRITE
-        self.__selector.register(sock, events, data=self.__data)
-    
-    @property
-    def _data_lock(self):
-        return self.__data_lock
-    
-    @property
-    def _data(self):
-        return self.__data
+        self.__selector.register(sock, events, data=self._data)
     
     def start(self, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
         """Start client event loop.
         """
         kwargs = {'read_bufsize':read_bufsize, 'read_kwargs':read_kwargs, 'write_kwargs':write_kwargs}
-        self.__start_thread = LoopFunctionThreaded(self._wait_and_process_events, kwargs=kwargs, register_thread=True, delay_before_run_sec=None)
-        self.__start_thread.start()
-    
-    def stop(self):
-        if self.__start_thread is not None:
-            self.__start_thread.interrupt()
-            self.__start_thread.join()
-            self.__start_thread = None
+        thread = LoopFunctionThreaded(self._wait_and_process_events, kwargs=kwargs, register_thread=True, delay_before_run_sec=None)
+        self._start_thread(thread)
     
     def _wait_and_process_events(self, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        has_activity = False
         events = self.__selector.select(timeout=None)
         for key, mask in events:
-            self._service_connection(key, mask, read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+            has_activity |= self._service_connection(key, mask, read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+        
+        # Wait before next loop if no data was exchanged
+        if not has_activity and self._idle_sleep_delay is not None:
+            time.sleep(self._idle_sleep_delay)
 
     def _service_connection(self, key, mask, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        has_activity = False
         read_kwargs = read_kwargs if read_kwargs is not None else {}
         write_kwargs = write_kwargs if write_kwargs is not None else {}
         
         sock = key.fileobj
         data = key.data
-        if mask & selectors.EVENT_READ:
-            recv_data = sock.recv(read_bufsize, **read_kwargs)
+        if self.is_run_with_recv and mask & selectors.EVENT_READ:
+            if self.is_with_ssl:
+                # ssl doesn't suppôrt flags != 0
+                flags = 0
+            else:
+                flags = read_kwargs.get('flags', 0)
+            
+            recv_data = sock.recv(read_bufsize, flags)
             if recv_data:
-                with self.__data_lock:      # data is self.__data
+                has_activity = True
+                with self._data_lock:      # data is self._data
                     data.in_bytes += recv_data
-        if mask & selectors.EVENT_WRITE:
-            with self.__data_lock:      # data is self.__data
+                    if logger.isEnabledFor(logging.DEBUG):
+                        logger.debug(f"[{self.name}] Received [{recv_data}] (type: {type(recv_data)} ; total: {len(data.in_bytes)})")
+        
+        if self.is_run_with_send and mask & selectors.EVENT_WRITE:
+            with self._data_lock:      # data is self._data
                 if data.out_bytes:
+                    has_activity = True
                     sent = sock.send(data.out_bytes)
-                    data.out_bytes = data.out_bytes[sent:]
-    
-    @property
-    def received_data_size(self):
-        with self.__data_lock:
-            res = len(self.__data.in_bytes)
-        return res
-    
-    def read(self, bufsize=1024):
-        with self.__data_lock:
-            if self.__data.in_bytes:
-                res = self.__data.in_bytes[:bufsize]
-                self.__data.in_bytes = self.__data.in_bytes[bufsize:]
-            else:
-                res = b''
-        return res
+                    if sent > 0:
+                        data.out_bytes = data.out_bytes[sent:]
+                        if logger.isEnabledFor(logging.DEBUG):
+                            logger.debug(f"[{self.name}] Sent {sent} data (remaining to send: {len(data.out_bytes)})")
+        
+        return has_activity
     
-    def write(self, data_bytes):
-        with self.__data_lock:
-            self.__data.out_bytes += data_bytes
+    def do_ssl_handshake(self):
+        if self.is_with_ssl:
+            while True:
+                try:
+                    self.internal_socket.do_handshake()
+                    break
+                except ssl.SSLWantReadError:
+                    select.select([self.internal_socket], [], [])
+                except ssl.SSLWantWriteError:
+                    select.select([], [self.internal_socket], [])
 
 
 class TCPNonBlockingSocketClient(NonBlockingSocketClient):
@@ -127,8 +122,8 @@ class TCPNonBlockingSocketClient(NonBlockingSocketClient):
     TCP socket client.
     """
     
-    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None):
-        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs)
+    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument, do_run_with_recv=True, do_run_with_send=True):
+        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay, do_run_with_recv=do_run_with_recv, do_run_with_send=do_run_with_send)
     
     def create_ipv4_socket(self, host, port, **kwargs):
         ssl_context, kwargs = self._new_ssl_context_if_required(**kwargs)
@@ -137,8 +132,11 @@ class TCPNonBlockingSocketClient(NonBlockingSocketClient):
         sock.setblocking(False)
         
         if ssl_context:
-            sock = ssl_context.wrap_socket(sock, server_hostname=host, do_handshake_on_connect=False)
-        self._set_internal_socket(sock)
+            do_handshake_on_connect = False
+            sock = ssl_context.wrap_socket(sock, server_hostname=host, do_handshake_on_connect=do_handshake_on_connect)
+            self._set_internal_socket(sock, is_with_ssl=True, is_ssl_handshake_done_on_connect=do_handshake_on_connect)
+        else:
+            self._set_internal_socket(sock)
         
         # Register socket
         self._register_socket(sock)

holado_python/standard_library/socket/socket.py

@@ -19,6 +19,10 @@ import abc
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_core.common.tools.tools import Tools
 from holado_python.standard_library.ssl.ssl import SslManager
+import threading
+import types
+from abc import abstractmethod
+from holado.common.handlers.undefined import undefined_argument
 
 logger = logging.getLogger(__name__)
 
@@ -31,7 +35,12 @@ class Socket(DeleteableObject):
     """
     __metaclass__ = abc.ABCMeta
     
-    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None):
+    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument):
+        """Socket constructor
+        @param name: Socket name
+        @param create_ipv4_socket_kwargs: arguments to create an IPv4 socket
+        @param idle_sleep_delay: delay to sleep when socket is idle (used in some clients/servers to control CPU resource impact ; default: 0.01 s)
+        """
         if name is None and create_ipv4_socket_kwargs is not None:
             if not set(create_ipv4_socket_kwargs.keys()).issuperset({'host', 'port'}):
                 raise FunctionalException(f"Parameters 'host' and 'port' must be defined")
@@ -39,6 +48,13 @@ class Socket(DeleteableObject):
         
         super().__init__(name)
         self.__socket = None
+        self.__is_started = False
+        self.__start_thread = None
+        self.__idle_sleep_delay = idle_sleep_delay if idle_sleep_delay is not undefined_argument else 0.01
+        
+        # SSL management
+        self.__is_with_ssl = False
+        self.__is_ssl_handshake_done = False
         
         if create_ipv4_socket_kwargs is not None:
             self.create_ipv4_socket(**create_ipv4_socket_kwargs)
@@ -56,8 +72,22 @@ class Socket(DeleteableObject):
     def internal_socket(self) -> socket.socket:
         return self.__socket
     
-    def _set_internal_socket(self, socket):
+    @property
+    def is_started(self):
+        return self.__is_started
+    
+    @property
+    def is_with_ssl(self):
+        return self.__is_with_ssl
+    
+    @property
+    def _idle_sleep_delay(self):
+        return self.__idle_sleep_delay
+    
+    def _set_internal_socket(self, socket, is_with_ssl=False, is_ssl_handshake_done_on_connect=True):
         self.__socket = socket
+        self.__is_with_ssl = is_with_ssl
+        self.__is_ssl_handshake_done = is_ssl_handshake_done_on_connect
     
     @abc.abstractmethod
     def create_ipv4_socket(self, host, port, **kwargs):
@@ -69,14 +99,40 @@ class Socket(DeleteableObject):
                 self.__socket.shutdown(SHUT_RDWR)
             except OSError as exc:
                 if 'Errno 107' in str(exc):
-                    logger.info(f"Got following error on socket shutdown (known to appear sometimes at shutdown): {exc}")
+                    logger.info(f"Got following error on socket shutdown (known to appear sometimes during shutdown): {exc}")
                 else:
                     raise exc
-            self.__socket.close()
-            self.__socket = None
+            finally:
+                self.__socket.close()
+                self.__socket = None
+    
+    @abstractmethod
+    def start(self, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        raise NotImplementedError()
+    
+    def _start_thread(self, thread):
+        # Start thread
+        self.__start_thread = thread
+        self.__start_thread.start()
+        self.__is_started = True
+        
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"[{self.name}] Started")
+    
+    def stop(self):
+        if self.__start_thread is not None:
+            if self.__start_thread.is_interruptable:
+                self.__start_thread.interrupt()
+            self.__start_thread.join()
+            self.__start_thread = None
+            self.__is_started = False
+            
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"[{self.name}] Stopped")
     
     def read(self, bufsize=1024, **kwargs):
-        res = self.internal_socket.recv(bufsize, **kwargs)
+        flags = kwargs.get('flags', 0)
+        res = self.internal_socket.recv(bufsize, flags)
         if logger.isEnabledFor(logging.DEBUG):
             logger.debug(f"[{self.name}] Received [{res}] (type: {type(res)})")
         return res
@@ -101,6 +157,16 @@ class Socket(DeleteableObject):
             ssl_kwargs = Tools.pop_sub_kwargs(socket_kwargs, 'ssl.')
             res = SslManager.new_ssl_context(server_side=server_side, flat_kwargs=ssl_kwargs)
         return res, socket_kwargs
+    
+    def do_ssl_handshake(self):
+        # Handshake management is performed differently with blocking or non-blocking connection
+        # See BlockingSocketClient and NonBlockingSocketClient for implementation
+        raise NotImplementedError()
+    
+    def ensure_ssl_handshake_is_done(self):
+        if self.is_with_ssl and not self.__is_ssl_handshake_done:
+            self.do_ssl_handshake()
+            self.__is_ssl_handshake_done = True
 
 
 class SocketClient(Socket):
@@ -109,10 +175,81 @@ class SocketClient(Socket):
     """
     __metaclass__ = abc.ABCMeta
     
-    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None):
-        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs)
+    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument, do_run_with_recv=True, do_run_with_send=True):
+        """Socket client constructor
+        @param name: Socket client name
+        @param create_ipv4_socket_kwargs: Arguments to create an IPv4 socket
+        @param idle_sleep_delay: delay to sleep when socket is idle (used only in some clients to control CPU resource impact ; default: 0.01 s)
+        @param do_run_with_recv: Define if recv is done in run process when client is started
+        @param do_run_with_send: Define if send is done in run process when client is started
+        """
+        # Data used in start processing
+        self.__data_lock = threading.Lock()
+        self.__data = types.SimpleNamespace(
+            in_bytes=b"",
+            out_bytes=b"",
+        )
+        self.__with_recv = do_run_with_recv
+        self.__with_send = do_run_with_send
+        
+        # Note: super().__init__ must be done after self.__data & others initialization since it can execute create_ipv4_socket_kwargs method
+        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay)
+    
+    @property
+    def is_run_with_recv(self):
+        return self.__with_recv
     
-
+    @property
+    def is_run_with_send(self):
+        return self.__with_send
+    
+    @property
+    def _data_lock(self):
+        return self.__data_lock
+    
+    @property
+    def _data(self):
+        return self.__data
+    
+    def _delete_object(self):
+        self.stop()
+        super()._delete_object()
+    
+    def _start_thread(self, thread):
+        # Ensure SSL handshake is done before starting to receive and send data
+        self.ensure_ssl_handshake_is_done()
+        
+        # Start thread
+        super()._start_thread(thread)
+    
+    @property
+    def received_data_size(self):
+        with self.__data_lock:
+            res = len(self.__data.in_bytes)
+        return res
+    
+    def read(self, bufsize=1024, **kwargs):
+        if self.is_started and self.is_run_with_recv:
+            with self.__data_lock:
+                if self.__data.in_bytes:
+                    res = self.__data.in_bytes[:bufsize]
+                    self.__data.in_bytes = self.__data.in_bytes[bufsize:]
+                else:
+                    res = b''
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug(f"[{self.name}] Read data from received data: [{res}] (type: {type(res)} ; remaining data: {len(self.__data.in_bytes)})")
+            return res
+        else:
+            return super().read(bufsize=bufsize, **kwargs)
+    
+    def write(self, data_bytes, loop_until_all_is_sent=True, **kwargs):
+        if self.is_started and self.is_run_with_send:
+            with self.__data_lock:
+                self.__data.out_bytes += data_bytes
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug(f"[{self.name}] Added data in data to send (total: {len(self.__data.out_bytes)})")
+        else:
+            return super().write(data_bytes, loop_until_all_is_sent=loop_until_all_is_sent, **kwargs)
 
 
 class SocketServer(Socket):
@@ -121,8 +258,8 @@ class SocketServer(Socket):
     """
     __metaclass__ = abc.ABCMeta
     
-    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None):
-        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs)
+    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument):
+        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay)
     
     def accept(self):
         conn, addr = self.internal_socket.accept()
@@ -131,17 +268,7 @@ class SocketServer(Socket):
         return res, addr
     
     @abc.abstractmethod
-    def start(self, read_bufsize=1024, *, read_kwargs=None, write_kwargs=None):
-        """Start server.
-        """
-        raise NotImplementedError()
-    
-    @abc.abstractmethod
-    def stop(self):
-        raise NotImplementedError()
-    
-    @abc.abstractmethod
-    def _process_data(self, data):
+    def _process_received_data(self, data):
         raise NotImplementedError()
 
 

holado_python/tests/behave/steps/standard_library/socket_steps.py

@@ -21,7 +21,7 @@ from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
 from holado_python.standard_library.socket.blocking_socket import TCPBlockingSocketClient
 from holado_python.standard_library.socket.echo_server import EchoTCPBlockingSocketServer
-from holado_python.standard_library.socket.message_socket import MessageTCPSocketClient
+from holado_python.standard_library.socket.message_socket import MessageTCPNonBlockingSocketClient, MessageTCPBlockingSocketClient
 from holado_core.common.handlers.wait import WaitEndChange
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_python.standard_library.socket.non_blocking_socket import TCPNonBlockingSocketClient
@@ -74,7 +74,11 @@ def step_impl(context, var_name):
     kwargs = ValueTableConverter.convert_name_value_table_2_dict(table)
     
     separator = kwargs.pop('separator') if 'separator' in kwargs else '\n'
-    res = MessageTCPSocketClient(separator, create_ipv4_socket_kwargs=kwargs)
+    blocking = kwargs.pop('blocking') if 'blocking' in kwargs else True
+    if blocking:
+        res = MessageTCPBlockingSocketClient(separator, create_ipv4_socket_kwargs=kwargs)
+    else:
+        res = MessageTCPNonBlockingSocketClient(separator, create_ipv4_socket_kwargs=kwargs)
     
     __get_variable_manager().register_variable(var_name, res)
 
@@ -139,6 +143,14 @@ def step_impl(context, server_varname):
 ################################################################
 
 
+@Step(r"ensure SSL handshake is done \(socket: (?P<socket_varname>{Variable})\)")
+def step_impl(context, socket_varname):
+    """Ensure SSL handshake is done.
+    """
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    
+    sock.ensure_ssl_handshake_is_done()
+
 @Step(r"write (?P<data>{Bytes}) \(socket: (?P<socket_varname>{Variable})\)")
 def step_impl(context, data, socket_varname):
     """Send data
@@ -216,7 +228,7 @@ def step_impl(context, var_name, socket_varname):
     var_name = StepTools.evaluate_variable_name(var_name)
     sock = StepTools.evaluate_scenario_parameter(socket_varname)
     
-    res = len(sock.messages)
+    res = sock.nb_messages
     
     __get_variable_manager().register_variable(var_name, res)
 

holado_python/tests/behave/steps/standard_library/ssl_steps.py

@@ -21,7 +21,7 @@ from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
 from holado_python.standard_library.socket.blocking_socket import TCPBlockingSocketClient
 from holado_python.standard_library.socket.echo_server import EchoTCPBlockingSocketServer
-from holado_python.standard_library.socket.message_socket import MessageTCPSocketClient
+from holado_python.standard_library.socket.message_socket import MessageTCPNonBlockingSocketClient
 from holado_core.common.handlers.wait import WaitFuncResultVerifying, WaitEndChange
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_python.standard_library.ssl.ssl import SslManager

holado_scripting/text/interpreter/functions/function_apply_function.py

@@ -0,0 +1,60 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+from holado_scripting.text.base.base_function import BaseFunction
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.exceptions.functional_exception import FunctionalException
+import logging
+from holado_core.common.tools.tools import Tools
+from holado_python.standard_library.typing import Typing
+
+logger = logging.getLogger(__name__)
+
+
+class FunctionApplyFunction(BaseFunction):
+
+    def __init__(self, func, text_interpreter, var_manager):
+        self.__func = func
+        self.__text_interpreter = text_interpreter
+        self.__variable_manager = var_manager
+        
+        
+    def apply(self, args):
+        # Verify arguments
+        if not isinstance(args, list):
+            raise TechnicalException("Arguments must be a list")
+        if len(args) != 1:
+            raise FunctionalException(f"Function applying a function requires one argument.")
+
+        src = args[0]
+        res = src
+        
+        if isinstance(res, str):
+            # Interpret source
+            res = self.__text_interpreter.interpret(res)
+            
+            # Manage if source is a variable expression
+            if self.__variable_manager.exists_variable(expression=res):
+                res = self.__variable_manager.get_value(res)
+    
+        # Remove possible quotes
+        if isinstance(res, str):
+            if res.startswith("'") and res.endswith("'") or res.startswith('"') and res.endswith('"'):
+                res = res.strip("'\"")
+
+        res = self.__func(res)
+        
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"[FunctionApplyFunction({self.__func})] [{src}] (type: {Typing.get_object_class_fullname(src)}) -> [{res}] (type: {Typing.get_object_class_fullname(res)})")
+        return res
+    

holado_scripting/text/interpreter/functions/function_to_string.py

@@ -0,0 +1,50 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+from holado_scripting.text.base.base_function import BaseFunction
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_core.common.tools.string_tools import StrTools
+
+
+class FunctionToString(BaseFunction):
+
+    def __init__(self, text_interpreter, var_manager):
+        self.__text_interpreter = text_interpreter
+        self.__variable_manager = var_manager
+        
+    def apply(self, args):
+        from holado_test.scenario.step_tools import StepTools
+        
+        # Verify arguments
+        if not isinstance(args, list):
+            raise TechnicalException("Arguments must be a list")
+        if len(args) != 1:
+            raise FunctionalException("Function 'ToBytes' requires one argument.")
+
+        src = args[0]
+        
+        # Interpret source
+        if isinstance(src, str):
+            src = StepTools.extract_string_value(src)
+            src = self.__text_interpreter.interpret(src)
+        
+        # Manage if source is a variable expression
+        if isinstance(src, str) and self.__variable_manager.exists_variable(expression=src):
+            src = self.__variable_manager.get_value(src)
+        
+        # Convert source to bytes
+        res = StrTools.to_string(src)
+        
+        return res
+    

holado_scripting/text/interpreter/text_interpreter.py

@@ -30,6 +30,8 @@ from holado_scripting.text.interpreter.functions.function_exists_variable import
 from holado_scripting.text.interpreter.functions.function_convert import FunctionConvert
 from holado_python.common.tools.datetime import DateTime
 from holado_python.standard_library.typing import Typing
+from holado_scripting.text.interpreter.functions.function_to_string import FunctionToString
+from holado_scripting.text.interpreter.functions.function_apply_function import FunctionApplyFunction
 
 logger = logging.getLogger(__name__)
 
@@ -193,6 +195,7 @@ class TextInterpreter(TextInspecter):
         return res
     
     def __register_default_functions(self, dynamic_text_manager):
+        self.register_function("len", FunctionApplyFunction(len, self, self._variable_manager))
         self.register_function("DynamicValue", FunctionDynamicValue(dynamic_text_manager))
         self.register_function("ExistsVariable", FunctionExistsVariable(self._variable_manager))
         
@@ -206,6 +209,7 @@ class TextInterpreter(TextInspecter):
         self.register_function("ToBase64", FunctionToBase64(self, self._variable_manager))
         self.register_function("ToBytes", FunctionToBytes(self, self._variable_manager))
         self.register_function("ToHex", FunctionToHex(self, self._variable_manager))
+        self.register_function("ToString", FunctionToString(self, self._variable_manager))
         self.register_function("DatetimeUTCToTAI", FunctionConvert(lambda dt: DateTime.datetime_utc_to_tai(dt), self, self._variable_manager))
         self.register_function("DatetimeTAIToUTC", FunctionConvert(lambda dt: DateTime.datetime_tai_to_utc(dt), self, self._variable_manager))
         

holado_test/scenario/step_tools.py

@@ -34,6 +34,7 @@ from holado_scripting.common.tools.evaluate_parameters import EvaluateParameters
 from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado.holado_config import Config
 from holado_python.standard_library.typing import Typing
+from holado_value.common.tables.value_table_manager import ValueTableManager
 
 logger = logging.getLogger(__name__)
 
@@ -237,7 +238,7 @@ class StepTools(object):
                 cell_content = res.header.get_cell(0).content
                 if cls._get_variable_manager().exists_variable(variable_name=cell_content):
                     value = cls._get_variable_manager().get_variable_value(cell_content)
-                    if isinstance(value, ValueTableWithHeader):
+                    if ValueTableManager.is_value_table(value):
                         res = value
                     elif isinstance(value, TableWithHeader):
                         res = ValueTableConverter.convert_table_with_header_2_value_table_with_header(value, do_eval_once=do_eval_once)
@@ -246,7 +247,7 @@ class StepTools(object):
         elif isinstance(table, Table):        
             if res.nb_columns == 1 and res.nb_rows == 1:
                 value = res.get_row(0).get_cell(0).value
-                if isinstance(value, ValueTable):
+                if ValueTableManager.is_value_table(value):
                     res = value
                 elif isinstance(value, Table):
                     res = ValueTableConverter.convert_table_2_value_table(value, do_eval_once=do_eval_once)
@@ -498,7 +499,7 @@ class StepTools(object):
                           r"{Variable}|b'[^']*'".format(Variable=cls.get_registered_type_pattern('Variable')), 
                           StepTools.evaluate_scenario_parameter)
         cls.register_type('Str', 
-                          r"{Variable}|'[^']*'{suffix}".format(Variable=cls.get_registered_type_pattern('Variable'), suffix=regex_suffix), 
+                          r"{Variable}|r?'[^']*'{suffix}".format(Variable=cls.get_registered_type_pattern('Variable'), suffix=regex_suffix), 
                           StepTools.evaluate_scenario_parameter)
         cls.register_type('RawStr', 
                           r"{Variable}|'.*'{suffix}".format(Variable=cls.get_registered_type_pattern('Variable'), suffix=regex_suffix), 

holado_value/common/tables/comparators/table_2_value_table_cell_comparator.py

@@ -107,7 +107,8 @@ class Table2ValueTable_CellComparator(TableCellComparator):
         
         cause = None
         try:
-            value_type = cell_2.value_type
+            # value_type = cell_2.value_type
+            value_type = cell_2.content_type
             if value_type == ValueTypes.NotApplicable:
                 res = True
             elif value_type == ValueTypes.Null:

holado_value/common/tables/value_table_cell.py

@@ -63,6 +63,11 @@ class ValueTableCell(TableCell):
     def value(self):
         return self.__value.value
     
+    @value.setter
+    def value(self, value):
+        self.__value = Value(original_value=None, value=value, do_eval_once=self.__value.do_eval_once)
+        self.content = self.__value.original_value
+    
     def get_value(self, raise_if_undefined=False):
         return self.__value.get_value(raise_if_undefined=raise_if_undefined)