holado 0.2.7__tar.gz → 0.2.8__tar.gz

{holado-0.2.7 → holado-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.2.7
+Version: 0.2.8
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues
@@ -53,6 +53,9 @@ Requires-Dist: moto; extra == 's3'
 Provides-Extra: sftp
 Requires-Dist: pysftp; extra == 'sftp'
 Requires-Dist: sftpserver; extra == 'sftp'
+Provides-Extra: ssl
+Requires-Dist: certifi; extra == 'ssl'
+Requires-Dist: pip-system-certs; extra == 'ssl'
 Provides-Extra: ws-suds
 Requires-Dist: suds; extra == 'ws-suds'
 Provides-Extra: ws-zeep

holado-0.2.8/packaging/VERSION

@@ -0,0 +1 @@
+0.2.8

{holado-0.2.7 → holado-0.2.8}/pyproject.toml

@@ -43,6 +43,7 @@ rabbitmq = ["pika"]
 redis = ["redis", "redis-om"]
 s3 = ["minio", "boto3", "moto", "flask", "flask_cors"]
 sftp = ["pysftp", "sftpserver"]
+ssl = ["pip-system-certs", "certifi"]
 ws-suds = ["suds"]
 ws-zeep = ["zeep"]
 yaml = ["pyyaml"]

{holado-0.2.7 → holado-0.2.8}/requirements_docker.txt

@@ -59,8 +59,9 @@ pyais
 # For .xslt files support
 openpyxl
 
-# For memory profiling
-pympler
+# For debug
+pympler     # memory profiling
+#py-spy      # deadlock
 
 # For yaml module
 pyyaml

{holado-0.2.7 → holado-0.2.8}/src/holado_core/common/tables/table.py

@@ -66,10 +66,10 @@ class Table(object):
         return result
     
     def __repr__(self)->str:
-        if self.nb_rows * self.nb_columns < 100:
+        if self.nb_rows < 10 or self.nb_rows * self.nb_columns < 100:
             return f"<{self.__class__.__name__}>({self.nb_rows}x{self.nb_columns})\n{self.represent()}"
         else:
-            return f"<{self.__class__.__name__}>({self.nb_rows}x{self.nb_columns})"
+            return f"<{self.__class__.__name__}>({self.nb_rows}x{self.nb_columns})\n{self.represent(limit_rows=10)}[...]"
     
     @property
     def content(self):

{holado-0.2.7 → holado-0.2.8}/src/holado_core/common/tools/string_tools.py

@@ -131,5 +131,14 @@ class StrTools(object):
             res = res.upper()
         
         return res
+    
+    @classmethod
+    def to_string(cls, src):
+        if isinstance(src, bytes):
+            return src.decode('utf-8')
+        elif isinstance(src, str):
+            return src
+        else:
+            return str(src)
 
 

{holado-0.2.7 → holado-0.2.8}/src/holado_core/tests/behave/steps/common/tables_steps.py

@@ -37,6 +37,7 @@ from holado_core.common.tools.converters.converter import Converter
 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.typing import Typing
+from holado_value.common.tables.value_table_manager import ValueTableManager
 
 logger = logging.getLogger(__name__)
 
@@ -317,6 +318,7 @@ def step_impl(context, var_name, table_varname, col_name):
     col_name = StepTools.evaluate_scenario_parameter(col_name)
 
     res_table = copy.copy(table)
+    is_value_table = ValueTableManager.is_value_table(res_table)
     col = res_table.get_column(name=col_name)
     
     tr_indexes = table_replace.get_column_indexes_by_string_content()
@@ -328,8 +330,10 @@ def step_impl(context, var_name, table_varname, col_name):
             cell_rep_value = row_replace[tr_indexes["Replace Value"]] if "Replace Value" in tr_indexes else None
             
             if cell_cond_value is not None:
+                # If condition value is 'DEFAULT' or cell value is equal to condition value
                 cond = (cell_cond_value.content_type == ValueTypes.Symbol and cell_cond_value.content == 'DEFAULT'
-                        or cell_cond_value.value_type != ValueTypes.NotApplicable and cell.content == cell_cond_value.value)
+                        or cell_cond_value.value_type != ValueTypes.NotApplicable 
+                            and (is_value_table and cell.value == cell_cond_value.value or not is_value_table and cell.content == cell_cond_value.value) )
             elif cell_cond_expr is not None:
                 cond = tcell_comparator.equals(cell, cell_cond_expr, raise_exception = False)
             else:
@@ -339,7 +343,10 @@ def step_impl(context, var_name, table_varname, col_name):
                 if cell_rep_value.value_type != ValueTypes.NotApplicable:
                     # Note: As 'col' is created with a copy of 'res_table' cells, 'cell' is also a 'res_table' cell.
                     #       Thus, modifying 'cell' is modifying the cell in 'res_table'
-                    cell.content = cell_rep_value.value
+                    if is_value_table:
+                        cell.value = cell_rep_value.value
+                    else:
+                        cell.content = cell_rep_value.value
                     break
                 else:
                     continue

{holado-0.2.7 → holado-0.2.8}/src/holado_helper/script/action.py

@@ -89,13 +89,22 @@ class BehaveActionRunner():
     
     def __add_variable_values(self, res, params):
         if params:
-            for key, value in params.items():
-                if key == 'STATUS':
-                    continue
-                if value is not_applicable:
-                    res[key] = 'N/A'
-                else:
-                    res[key] = value
+            if isinstance(params, dict):
+                for key, value in params.items():
+                    self.__add_variable_value(res, key, value)
+            elif isinstance(params, list):
+                for key, value in params:
+                    self.__add_variable_value(res, key, value)
+            else:
+                raise TechnicalException(f"Unexpected params type '{type(params)}'")
+    
+    def __add_variable_value(self, res, var_name, value):
+        if var_name == 'STATUS':
+            return
+        if value is not_applicable:
+            res[var_name] = 'N/A'
+        else:
+            res[var_name] = value
     
     def run(self):
         logger.info(f"Processing action '{self.__action_info.action}' of index {self.__action_info.index}: {self.__action_info.params}")

{holado-0.2.7 → holado-0.2.8}/src/holado_python/standard_library/socket/blocking_socket.py

@@ -16,6 +16,8 @@ import socket
 from holado_python.standard_library.socket.socket import SocketClient, SocketServer
 import abc
 from holado_multitask.multithreading.loopfunctionthreaded import LoopFunctionThreaded
+import time
+from holado.common.handlers.undefined import undefined_argument
 
 logger = logging.getLogger(__name__)
 
@@ -31,17 +33,79 @@ class BlockingSocketClient(SocketClient):
     """
     __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):
+        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 start(self, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        """Start client event loop.
+        """
+        if self.is_with_ssl:
+            # Set a small timeout, so that recv has a behaviour similar flag MSG_DONTWAIT
+            # See _process_recv_send implementation, recv flags are needed to be forced to 0
+            if self._idle_sleep_delay is not None:
+                self.internal_socket.settimeout(self._idle_sleep_delay)
+            else:
+                self.internal_socket.settimeout(0.01)
+        
+        kwargs = {'read_bufsize':read_bufsize, 'read_kwargs':read_kwargs, 'write_kwargs':write_kwargs}
+        thread = LoopFunctionThreaded(self._process_recv_send, kwargs=kwargs, register_thread=True, delay_before_run_sec=None)
+        self._start_thread(thread)
+    
+    def _process_recv_send(self, *, 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 {}
+        
+        recv_data = None
+        if self.is_run_with_recv:
+            if self.is_with_ssl:
+                # ssl doesn't suppôrt flags != 0
+                flags = 0
+            else:
+                # Add flag to not wait data
+                flags = read_kwargs.get('flags', 0)
+                flags |= socket.MSG_DONTWAIT
+            
+            try:
+                recv_data = self.internal_socket.recv(read_bufsize, flags)
+            except (BlockingIOError, TimeoutError):
+                # No data to read
+                pass
+            else:
+                if recv_data:
+                    has_activity = True
+                    with self._data_lock:
+                        self._data.in_bytes += recv_data
+                        if logger.isEnabledFor(logging.DEBUG):
+                            logger.debug(f"[{self.name}] Received [{recv_data}] (type: {type(recv_data)} ; total: {len(self._data.in_bytes)})")
+        
+        sent = None
+        if self.is_run_with_send:
+            with self._data_lock:
+                if self._data.out_bytes:
+                    has_activity = True
+                    sent = self.internal_socket.send(self._data.out_bytes)
+                    if sent > 0:
+                        self._data.out_bytes = self._data.out_bytes[sent:]
+                        if logger.isEnabledFor(logging.DEBUG):
+                            logger.debug(f"[{self.name}] Sent {sent} data (remaining to send: {len(self._data.out_bytes)})")
+        
+        # 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 do_ssl_handshake(self):
+        if self.is_with_ssl:
+            self.internal_socket.do_handshake()
+
 
 class TCPBlockingSocketClient(BlockingSocketClient):
     """
     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)
@@ -49,9 +113,12 @@ class TCPBlockingSocketClient(BlockingSocketClient):
         sock = socket.create_connection((host, port), **kwargs)
         
         if ssl_context:
-            sock = ssl_context.wrap_socket(sock, server_hostname=host, do_handshake_on_connect=False)
-            # sock = ssl_context.wrap_socket(sock, server_hostname=host)
-        self._set_internal_socket(sock)
+            # do_handshake_on_connect = True
+            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)
 
 
 
@@ -67,24 +134,16 @@ class BlockingSocketServer(SocketServer):
     """
     __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)
-        
-        self.__start_thread = None
+    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 start(self, read_bufsize=1024, *, read_kwargs=None, write_kwargs=None):
         """Start server to wait a connection, and then listen data, process data, and send result.
         Note: current implementation is simple and supports only one connection at a time.
         """
         kwargs = {'read_bufsize':read_bufsize, 'read_kwargs':read_kwargs, 'write_kwargs':write_kwargs}
-        self.__start_thread = LoopFunctionThreaded(self.wait_and_process_connection, 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_connection, kwargs=kwargs, register_thread=True, delay_before_run_sec=None)
+        self._start_thread(thread)
     
     def wait_and_process_connection(self, read_bufsize=1024, *, read_kwargs=None, write_kwargs=None):
         """Wait a connection, and then listen data, process data, and send result.
@@ -104,15 +163,11 @@ class BlockingSocketServer(SocketServer):
                     
                 if not data:
                     break
-                result = self._process_data(data)
+                result = self._process_received_data(data)
                 
                 if logger.isEnabledFor(logging.DEBUG):
                     logger.debug(f"[{self.name}] Sending: {result}")
                 conn.write(result, **write_kwargs)
-    
-    @abc.abstractmethod
-    def _process_data(self, data):
-        raise NotImplementedError()
 
 
 
@@ -121,8 +176,8 @@ class TCPBlockingSocketServer(BlockingSocketServer):
     TCP socket server
     """
     
-    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 create_ipv4_socket(self, host, port, **kwargs):
         ssl_context, kwargs = self._new_ssl_context_if_required(server_side=True, **kwargs)
@@ -130,7 +185,9 @@ class TCPBlockingSocketServer(BlockingSocketServer):
         sock = socket.create_server((host, port), **kwargs)
         
         if ssl_context:
-            # sock = ssl_context.wrap_socket(sock, do_handshake_on_connect=False, server_side=True)
-            sock = ssl_context.wrap_socket(sock, server_side=True)
-        self._set_internal_socket(sock)
+            do_handshake_on_connect = True
+            sock = ssl_context.wrap_socket(sock, server_side=True, 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)
 

{holado-0.2.7 → holado-0.2.8}/src/holado_python/standard_library/socket/echo_server.py

@@ -13,16 +13,17 @@
 
 import logging
 from holado_python.standard_library.socket.blocking_socket import TCPBlockingSocketServer
+from holado.common.handlers.undefined import undefined_argument
 
 logger = logging.getLogger(__name__)
 
 
 
 class EchoTCPBlockingSocketServer(TCPBlockingSocketServer):
-    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 _process_data(self, data):
+    def _process_received_data(self, data):
         return data
 
 

{holado-0.2.7 → holado-0.2.8}/src/holado_python/standard_library/socket/message_socket.py

@@ -17,6 +17,9 @@ import selectors
 from holado_python.standard_library.socket.non_blocking_socket import TCPNonBlockingSocketClient
 import copy
 import threading
+from holado_python.standard_library.socket.blocking_socket import TCPBlockingSocketClient
+from holado_core.common.tools.tools import Tools
+from holado.common.handlers.undefined import undefined_argument
 
 logger = logging.getLogger(__name__)
 
@@ -26,14 +29,14 @@ logger = logging.getLogger(__name__)
 ##########################################################################
 
 
-class MessageTCPSocketClient(TCPNonBlockingSocketClient):
+class MessageSocketClient(object):
     """
-    Base class for blocking socket client.
+    Base class for message socket client.
     """
     __metaclass__ = abc.ABCMeta
     
-    def __init__(self, separator=b'\n', *, name=None, create_ipv4_socket_kwargs=None):
-        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs)
+    def __init__(self, separator=b'\n'):
+        super().__init__()
         
         self.__separator = separator
         self.__messages_lock = threading.Lock()
@@ -47,23 +50,21 @@ class MessageTCPSocketClient(TCPNonBlockingSocketClient):
     def nb_messages(self):
         return len(self.__messages)
     
-    def _service_connection(self, key, mask, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
-        # Read from socket & write in socket
-        super()._service_connection(key, mask, read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+    def _extract_messages_from_data(self, data):
+        while True:
+            ind = data.in_bytes.find(self.__separator)
+            if ind >=0:
+                msg = data.in_bytes[:ind]
+                self._add_message(msg)
+                data.in_bytes = data.in_bytes[ind+len(self.__separator):]
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"[{self.name}] New message (total: {self.nb_messages}): {msg}")
+                elif Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(f"[{self.name}] New message (total: {self.nb_messages})")
+            else:
+                break
         
-        # Extract messages from received data
-        if mask & selectors.EVENT_READ:
-            with self._data_lock:
-                while True:
-                    ind = self._data.in_bytes.find(self.__separator)
-                    if ind >=0:
-                        msg = self._data.in_bytes[:ind]
-                        self.__add_message(msg)
-                        self._data.in_bytes = self._data.in_bytes[ind+len(self.__separator):]
-                    else:
-                        break
-    
-    def __add_message(self, msg):
+    def _add_message(self, msg):
         with self.__messages_lock:
             self.__messages.append(msg)
     
@@ -85,6 +86,44 @@ class MessageTCPSocketClient(TCPNonBlockingSocketClient):
 
 
 
+class MessageTCPBlockingSocketClient(TCPBlockingSocketClient, MessageSocketClient):
+    """
+    Message socket client with TCP blocking socket.
+    """
+    def __init__(self, separator=b'\n', *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument):
+        MessageSocketClient.__init__(self, separator)
+        TCPBlockingSocketClient.__init__(self, name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay)
+
+    def _process_recv_send(self, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        # Read from socket & write in socket
+        super()._process_recv_send(read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+        
+        # Extract messages from received data
+        if self.is_run_with_recv:
+            with self._data_lock:
+                self._extract_messages_from_data(self._data)
+
+
+
+class MessageTCPNonBlockingSocketClient(TCPNonBlockingSocketClient, MessageSocketClient):
+    """
+    Message socket client with TCP non-blocking socket.
+    """
+    def __init__(self, separator=b'\n', *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument):
+        MessageSocketClient.__init__(self, separator)
+        TCPNonBlockingSocketClient.__init__(self, name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay)
+
+    def _service_connection(self, key, mask, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        # Read from socket & write in socket
+        super()._service_connection(key, mask, read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+        
+        # Extract messages from received data
+        if mask & selectors.EVENT_READ:
+            with self._data_lock:
+                self._extract_messages_from_data(self._data)
+
+
+
 
 
 

{holado-0.2.7 → holado-0.2.8}/src/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)