holado 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

holado_python/standard_library/csv.py

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# 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.
+#################################################
+
+import logging
+import csv
+from holado_core.common.tables.table_with_header import TableWithHeader
+from holado_core.common.tables.table_row import TableRow
+from holado.common.context.session_context import SessionContext
+from holado_core.common.tables.table import Table
+from holado_core.common.tables.table_manager import TableManager
+from holado_data.data.generator.base import BaseGenerator
+
+logger = logging.getLogger(__name__)
+
+
+
+
+class CsvManager():
+    # Default settings for CSV files: dialect Excel but with ';' delimiter
+    default_dialect = "excel"
+    default_delimiter = ";"
+    default_quotechar = None
+    default_quoting = None
+
+    @classmethod
+    def __get_path_manager(cls):
+        return SessionContext.instance().path_manager
+    
+    @classmethod
+    def _get_csv_kwargs(cls, dialect, delimiter, quotechar, quoting):
+        csv_kwargs = {}
+        
+        if dialect is not None:
+            csv_kwargs['dialect'] = dialect
+        elif cls.default_dialect is not None:
+            csv_kwargs['dialect'] = cls.default_dialect
+            
+        if delimiter is not None:
+            csv_kwargs['delimiter'] = delimiter
+        elif cls.default_delimiter is not None:
+            csv_kwargs['delimiter'] = cls.default_delimiter
+            
+        if quotechar is not None:
+            csv_kwargs['quotechar'] = quotechar
+        elif cls.default_quotechar is not None:
+            csv_kwargs['quotechar'] = cls.default_quotechar
+            
+        if quoting is not None:
+            csv_kwargs['quoting'] = quoting
+        elif cls.default_quoting is not None:
+            csv_kwargs['quoting'] = cls.default_quoting
+            
+        return csv_kwargs
+        
+    @classmethod
+    def table_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None, with_header=True):
+        csv_kwargs = cls._get_csv_kwargs(dialect, delimiter, quotechar, quoting)
+        
+        with open(path, 'r', encoding=encoding) as fin:
+            if with_header:
+                dr = csv.DictReader(fin, **csv_kwargs)
+                
+                res = TableWithHeader()
+                res.header = TableRow(cells_content=dr.fieldnames)
+                
+                for row in dr:
+                    nrow=dict(row)
+                    res.add_row(contents_by_colname=nrow)
+            else:
+                reader = csv.reader(fin, **csv_kwargs)
+                
+                res = Table()
+                for row in reader:
+                    res.add_row(cells_content=row)
+        
+        return res
+        
+    @classmethod
+    def dict_list_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        dg = cls.dict_generator_with_content_of_CSV_file(path, encoding, dialect, delimiter, quotechar, quoting)
+        return [d for d in dg]
+    
+    @classmethod
+    def dict_generator_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        csv_kwargs = cls._get_csv_kwargs(dialect, delimiter, quotechar, quoting)
+        
+        class DictCSVGenerator(BaseGenerator):
+            def __init__(self, path, encoding, csv_kwargs):
+                super().__init__(name="dict CSV generator")
+                
+                self.__path = path
+                self.__encoding = encoding
+                self.__csv_kwargs = csv_kwargs
+                
+                self.__fin = None
+                self.__dict_reader = None
+            
+            def __open_file_if_needed(self):
+                if self.__fin is None:
+                    self.__fin = open(self.__path, 'r', encoding=self.__encoding)
+                    self.__dict_reader = csv.DictReader(self.__fin, **self.__csv_kwargs)
+            
+            def __close_file(self):
+                self.__dict_reader = None
+                self.__fin.close()
+                self.__fin = None
+                
+            def __next__(self):
+                self.__open_file_if_needed()
+                try:
+                    return dict(next(self.__dict_reader))
+                except StopIteration as exc:
+                    self.__close_file()
+                    raise exc
+        
+        return DictCSVGenerator(path, encoding, csv_kwargs)
+    
+    @classmethod
+    def tuple_list_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        tg = cls.tuple_generator_with_content_of_CSV_file(path, encoding, dialect, delimiter, quotechar, quoting)
+        return [t for t in tg]
+    
+    @classmethod
+    def tuple_generator_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        csv_kwargs = cls._get_csv_kwargs(dialect, delimiter, quotechar, quoting)
+        
+        class TupleCSVGenerator(BaseGenerator):
+            def __init__(self, path, encoding, csv_kwargs):
+                super().__init__(name="tuple CSV generator")
+                
+                self.__path = path
+                self.__encoding = encoding
+                self.__csv_kwargs = csv_kwargs
+                
+                self.__fin = None
+                self.__reader = None
+            
+            def __open_file_if_needed(self):
+                if self.__fin is None:
+                    self.__fin = open(self.__path, 'r', encoding=self.__encoding)
+                    self.__reader = csv.reader(self.__fin, **self.__csv_kwargs)
+            
+            def __close_file(self):
+                self.__reader = None
+                self.__fin.close()
+                self.__fin = None
+                
+            def __next__(self):
+                self.__open_file_if_needed()
+                try:
+                    return tuple(next(self.__reader))
+                except StopIteration as exc:
+                    self.__close_file()
+                    raise exc
+        
+        return TupleCSVGenerator(path, encoding, csv_kwargs)
+    
+    @classmethod
+    def create_csv_file(cls, path, table, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        csv_kwargs = cls._get_csv_kwargs(dialect, delimiter, quotechar, quoting)
+        
+        cls.__get_path_manager().makedirs(path)
+        
+        with open(path, 'w', encoding=encoding) as fout:
+            if TableManager.is_table_with_header(table):
+                fieldnames = table.header.cells_content
+                dw = csv.DictWriter(fout, fieldnames=fieldnames, **csv_kwargs)
+                
+                dw.writeheader()
+                for row in table.rows:
+                    rowdict = {fieldnames[i]:row[i].string_content for i in range(len(fieldnames))}
+                    dw.writerow(rowdict)
+            else:
+                writer = csv.writer(fout, **csv_kwargs)
+                for row in table.rows:
+                    cells_content = [c.string_content for c in row]
+                    writer.writerow(cells_content)
+    
+    @classmethod
+    def merge_csv(cls, input_paths, output_path=None, sort_column=None, with_header=True):
+        input_tables = [cls.table_with_content_of_CSV_file(ip, with_header=with_header) for ip in input_paths]
+        
+        # Merge tables
+        output_table = input_tables[0]
+        for i in range(1, len(input_tables)):
+            output_table.extend(input_tables[i])
+        
+        # Sort rows
+        if sort_column is not None:
+            output_table.sort(names=[sort_column])
+        
+        if output_path is not None:
+            cls.create_csv_file(output_path, output_table)
+        else:
+            return output_table
+    

holado_python/standard_library/hashlib.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# 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.
+#################################################
+
+import logging
+import hashlib
+from holado_core.common.exceptions.technical_exception import TechnicalException
+
+logger = logging.getLogger(__name__)
+
+
+
+
+class HashTools(object):
+    
+    @classmethod
+    def code(cls, content, code_size=None, prefix=None):
+        hex_size = code_size
+        if hex_size is not None:
+            if prefix is not None:
+                hex_size = hex_size - len(prefix)
+            hex_size = hex_size // 2 * 2
+        
+        res = cls.hexblake2(content, hex_size=hex_size)
+        
+        if prefix is not None:
+            res = prefix + res
+        
+        return res
+        
+    @classmethod
+    def hexmd5(cls, content):
+        hash_obj = hashlib.md5()
+        cls._update_hash(hash_obj, content)
+        return hash_obj.hexdigest()
+    
+    @classmethod
+    def hexblake2(cls, content, hex_size=None, **hash_kwargs):
+        if hex_size is not None:
+            if isinstance(hex_size, int):
+                digest_size = hex_size // 2
+            else:
+                raise TechnicalException(f"Parameter hex_size must be an integer")
+            hash_kwargs['digest_size'] = digest_size
+        
+        hash_obj = hashlib.blake2b(**hash_kwargs)
+        cls._update_hash(hash_obj, content)
+        return hash_obj.hexdigest()
+    
+    @classmethod
+    def _update_hash(cls, hash_obj, content):
+        # Manage list separately for memory purpose
+        done = False
+        if not isinstance(content, str): 
+            try:
+                for cont in content:
+                    if type(cont) != bytes:
+                        cont = cont.encode('utf-8')
+                    hash_obj.update(cont)
+                done = True
+            except TypeError:
+                done = False
+    
+        if not done:
+            if type(content) != bytes:
+                content = content.encode('utf-8')
+            hash_obj.update(content)
+    
+    
+    
+    
+    

holado_python/standard_library/multiprocessing.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# 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.
+#################################################
+
+import logging
+import typing
+import multiprocessing.context
+import multiprocessing.queues
+from holado_python.standard_library.queue import IterableQueue
+
+logger = logging.getLogger(__name__)
+
+
+class IterableJoinableQueue(multiprocessing.queues.JoinableQueue, typing.Iterable):
+    
+    __sentinel = IterableQueue.Sentinel()
+    
+    def __init__(self, maxsize=0, block_on_get=True, block_on_get_timeout=None, block_on_put=True, block_on_put_timeout=None):
+        super().__init__(maxsize if maxsize else 0, ctx=multiprocessing.context._default_context.get_context())
+        self.__block_on_get = block_on_get if block_on_get is not None else True
+        self.__block_on_get_timeout = block_on_get_timeout
+        self.__block_on_put = block_on_put if block_on_put is not None else True
+        self.__block_on_put_timeout = block_on_put_timeout
+
+    def __iter__(self):
+        return iter(self.get, self.__sentinel)
+
+    def __len__(self):
+        return self.qsize()
+
+    def close(self):
+        self.put(self.__sentinel)
+            
+    def get(self):
+        res = super().get(block=self.__block_on_get, timeout=self.__block_on_get_timeout)
+        
+        # Put again the sentinel in case of multiple readers
+        if self.is_sentinel(res):
+            self.put(res)
+            
+        return res
+    
+    def put(self, item):
+        return super().put(item, block=self.__block_on_put, timeout=self.__block_on_put_timeout)
+    
+    def is_sentinel(self, item):
+        return item == self.__sentinel
+    
+    
+    
+    
+    

holado_python/standard_library/queue.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# 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.
+#################################################
+
+import logging
+import queue
+import typing
+
+logger = logging.getLogger(__name__)
+
+
+class IterableQueue(queue.Queue, typing.Iterable):
+    
+    class Sentinel(object):
+        def __eq__(self, __o: object) -> bool:
+            return isinstance(__o, IterableQueue.Sentinel)
+        
+    __sentinel = Sentinel()
+    
+    
+    def __init__(self, maxsize=0, block_on_get=True, block_on_get_timeout=None, block_on_put=True, block_on_put_timeout=None):
+        super().__init__(maxsize if maxsize else 0)
+        self.__block_on_get = block_on_get if block_on_get is not None else True
+        self.__block_on_get_timeout = block_on_get_timeout
+        self.__block_on_put = block_on_put if block_on_put is not None else True
+        self.__block_on_put_timeout = block_on_put_timeout
+
+    def __iter__(self):
+        return iter(self.get, self.__sentinel)
+
+    def __len__(self):
+        return self.qsize()
+
+    def close(self):
+        self.put(self.__sentinel)
+            
+    def get(self):
+        res = super().get(block=self.__block_on_get, timeout=self.__block_on_get_timeout)
+        
+        # Put again the sentinel in case of multiple readers
+        if self.is_sentinel(res):
+            self.put(res)
+            
+        return res
+    
+    def put(self, item):
+        return super().put(item, block=self.__block_on_put, timeout=self.__block_on_put_timeout)
+    
+    def is_sentinel(self, item):
+        return item == self.__sentinel
+    
+
+class IterableLifoQueue(IterableQueue):
+    '''Copyt of implementation of queue.LifoQueue but inheriting of IterableQueue.'''
+
+    def _init(self, maxsize):
+        self.queue = []
+
+    def _qsize(self):
+        return len(self.queue)
+
+    def _put(self, item):
+        self.queue.append(item)
+
+    def _get(self):
+        return self.queue.pop()
+    
+    
+    

holado_python/standard_library/socket/blocking_socket.py

@@ -0,0 +1,136 @@
+
+#################################################
+# 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.
+#################################################
+
+import logging
+import socket
+from holado_python.standard_library.socket.socket import SocketClient, SocketServer
+import abc
+from holado_multitask.multithreading.loopfunctionthreaded import LoopFunctionThreaded
+
+logger = logging.getLogger(__name__)
+
+
+##########################################################################
+## Clients
+##########################################################################
+
+
+class BlockingSocketClient(SocketClient):
+    """
+    Base class for blocking socket client.
+    """
+    __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)
+    
+
+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 create_ipv4_socket(self, host, port, **kwargs):
+        ssl_context, kwargs = self._new_ssl_context_if_required(**kwargs)
+        
+        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)
+
+
+
+
+##########################################################################
+## Servers
+##########################################################################
+
+
+class BlockingSocketServer(SocketServer):
+    """
+    Base class for socket servers.
+    """
+    __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 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
+    
+    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.
+        Note: current implementation is simple and supports only one connection at a time.
+        """
+        read_kwargs = read_kwargs if read_kwargs is not None else {}
+        write_kwargs = write_kwargs if write_kwargs is not None else {}
+        
+        conn, _ = self.accept()
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[{self.name}] New connection: {conn}")
+        with conn:
+            while True:
+                data = conn.read(read_bufsize, **read_kwargs)
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug(f"[{self.name}] Received: {data}")
+                    
+                if not data:
+                    break
+                result = self._process_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()
+
+
+
+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 create_ipv4_socket(self, host, port, **kwargs):
+        ssl_context, kwargs = self._new_ssl_context_if_required(server_side=True, **kwargs)
+        
+        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)
+

holado_python/standard_library/socket/echo_server.py

@@ -0,0 +1,28 @@
+
+#################################################
+# 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.
+#################################################
+
+import logging
+from holado_python.standard_library.socket.blocking_socket import TCPBlockingSocketServer
+
+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 _process_data(self, data):
+        return data
+
+

holado_python/standard_library/socket/message_socket.py

@@ -0,0 +1,91 @@
+
+#################################################
+# 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.
+#################################################
+
+import logging
+import abc
+import selectors
+from holado_python.standard_library.socket.non_blocking_socket import TCPNonBlockingSocketClient
+import copy
+import threading
+
+logger = logging.getLogger(__name__)
+
+
+##########################################################################
+## Clients
+##########################################################################
+
+
+class MessageTCPSocketClient(TCPNonBlockingSocketClient):
+    """
+    Base class for blocking 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)
+        
+        self.__separator = separator
+        self.__messages_lock = threading.Lock()
+        self.__messages = []
+
+    @property
+    def messages(self):
+        return self.__messages
+    
+    @property
+    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)
+        
+        # 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):
+        with self.__messages_lock:
+            self.__messages.append(msg)
+    
+    def read_message(self):
+        res = None
+        with self.__messages_lock:
+            if len(self.__messages) > 0:
+                res = self.__messages.pop(0)
+        return res
+    
+    def read_messages(self):
+        with self.__messages_lock:
+            res = copy.copy(self.__messages)
+            self.__messages.clear()
+        return res
+    
+    def write_message(self, msg_bytes):
+        self.write(msg_bytes + self.__separator)
+
+
+
+
+
+
+