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

holado_ais/ais/ais_messages.py

@@ -21,7 +21,6 @@ from holado_core.common.tools.string_tools import StrTools
 from holado_binary.ipc.binary import Binary
 from holado_core.common.tools.tools import Tools
 from holado_python.standard_library.typing import Typing
-from holado_ais.ais.patch_pyais import HATagBlock, HA_ais_to_nmea_0183
 import copy
 
 logger = logging.getLogger(__name__)
@@ -29,6 +28,7 @@ logger = logging.getLogger(__name__)
 try:
     import pyais
     from bitarray import bitarray
+    from holado_ais.ais.patch_pyais import HATagBlock, HA_ais_to_nmea_0183
     with_pyais = True
     
     # Patch pyais with some fixes
@@ -36,7 +36,6 @@ try:
 except Exception as exc:
     if Tools.do_log(logger, logging.DEBUG):
         logger.debug(f"AIS is not available. Initialization failed on error: {exc}")
-    logger.warning(f"AIS is not available. Initialization failed on error: {exc}")
     with_pyais = False
 
 
@@ -47,157 +46,159 @@ class AISMessages(object):
     def is_available(cls):
         return with_pyais
     
-    def __init__(self):
-        self.__tag_block_group_id = 0
-    
-    def default_message_data(self, msg_type:int):
-        """Return default data values for required data by pyais but not functionnaly required.
-        It is useful when generating custom messages, for example for tests.
-        """
-        return {}
-    
-    def new_message_as_bitarray_bytes(self, msg_type:int, data:Union[dict,TableWithHeader]):
-        msg = self.new_message(msg_type, data)
-        res = self.convert_message_to_bytes(msg)
-        return res
-    
-    def new_message(self, msg_type:int, data:Union[dict,TableWithHeader]):
-        if isinstance(data, TableWithHeader):
-            data = self.__convert_table_to_dict(data)
-        if not isinstance(data, dict):
-            raise TechnicalException(f"Unexpected data type '{Typing.get_object_class_fullname(data)}'")
+    if with_pyais:
         
-        message_type = self.__get_message_type(msg_type)
-        res = message_type.create(**data)
-        return res
-
-    def decode(self, *args, encoded_msg=None, parts_separator=b'\n'):
-        if encoded_msg is not None:
-            if isinstance(encoded_msg, str):
-                encoded_bytes = encoded_msg.encode("utf-8")
-            elif isinstance(encoded_msg, bytes):
-                encoded_bytes = encoded_msg
-            else:
-                raise TechnicalException(f"Parameter 'encoded_msg' must be of type str or bytes")
-            args = encoded_bytes.split(parts_separator)
-        return pyais.decode(*args, error_if_checksum_invalid=True)
-    
-    def decode_message(self, msg_type:int, bit_array:Union[str,bitarray]):
-        if isinstance(bit_array, str):
-            if StrTools.is_hex(bit_array) and not StrTools.is_bitarray(bit_array):
-                bit_array = Binary.convert_hex_str_to_bin_str(bit_array)
-            bit_array = bitarray(bit_array)
-        if not isinstance(bit_array, bitarray):
-            raise TechnicalException(f"Bad parameter 'bit_array' (accepted types: bitarray, str)")
-            
-        message_type = self.__get_message_type(msg_type)
-        return message_type.from_bitarray(bit_array)
-    
-    def encode_raw_payload(self, payload_hex: str, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
-        from pyais.util import encode_ascii_6
+        def __init__(self):
+            self.__tag_block_group_id = 0
         
-        payload_bitarray = bitarray()
-        payload_bitarray.frombytes(bytes.fromhex(payload_hex))
-        payload_ascii6, fill_bits = encode_ascii_6(payload_bitarray)
+        def default_message_data(self, msg_type:int):
+            """Return default data values for required data by pyais but not functionnaly required.
+            It is useful when generating custom messages, for example for tests.
+            """
+            return {}
         
-        seq_id = kwargs.pop('seq_id') if 'seq_id' in kwargs else self.__tag_block_group_id % 10
-        radio_channel = kwargs['radio_channel'] if 'radio_channel' in kwargs else 'A'
-        group_id = kwargs.pop('group_id') if 'group_id' in kwargs else None
+        def new_message_as_bitarray_bytes(self, msg_type:int, data:Union[dict,TableWithHeader]):
+            msg = self.new_message(msg_type, data)
+            res = self.convert_message_to_bytes(msg)
+            return res
         
-        sentences = HA_ais_to_nmea_0183(payload_ascii6, talker_id, radio_channel, fill_bits, seq_id)
-        return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
+        def new_message(self, msg_type:int, data:Union[dict,TableWithHeader]):
+            if isinstance(data, TableWithHeader):
+                data = self.__convert_table_to_dict(data)
+            if not isinstance(data, dict):
+                raise TechnicalException(f"Unexpected data type '{Typing.get_object_class_fullname(data)}'")
+            
+            message_type = self.__get_message_type(msg_type)
+            res = message_type.create(**data)
+            return res
+    
+        def decode(self, *args, encoded_msg=None, parts_separator=b'\n'):
+            if encoded_msg is not None:
+                if isinstance(encoded_msg, str):
+                    encoded_bytes = encoded_msg.encode("utf-8")
+                elif isinstance(encoded_msg, bytes):
+                    encoded_bytes = encoded_msg
+                else:
+                    raise TechnicalException(f"Parameter 'encoded_msg' must be of type str or bytes")
+                args = encoded_bytes.split(parts_separator)
+            return pyais.decode(*args, error_if_checksum_invalid=True)
         
-    def encode(self, data, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
-        if isinstance(data, pyais.messages.Payload):
-            return self.encode_msg(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
-        elif isinstance(data, dict):
-            return self.encode_data(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
-        elif isinstance(data, TableWithHeader):
-            return self.encode_table(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
-        else:
-            raise TechnicalException(f"Unexpected data type '{Typing.get_object_class_fullname(data)}'")
-    
-    def encode_msg(self, msg, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
-        if not isinstance(msg, pyais.messages.Payload):
-            raise TechnicalException(f"Parameter 'msg' is not an AIS message (obtained type: {Typing.get_object_class_fullname(msg)})")
+        def decode_message(self, msg_type:int, bit_array:Union[str,bitarray]):
+            if isinstance(bit_array, str):
+                if StrTools.is_hex(bit_array) and not StrTools.is_bitarray(bit_array):
+                    bit_array = Binary.convert_hex_str_to_bin_str(bit_array)
+                bit_array = bitarray(bit_array)
+            if not isinstance(bit_array, bitarray):
+                raise TechnicalException(f"Bad parameter 'bit_array' (accepted types: bitarray, str)")
+                
+            message_type = self.__get_message_type(msg_type)
+            return message_type.from_bitarray(bit_array)
         
-        seq_id = kwargs.pop('seq_id') if 'seq_id' in kwargs else self.__tag_block_group_id % 10
-        group_id = kwargs.pop('group_id') if 'group_id' in kwargs else None
+        def encode_raw_payload(self, payload_hex: str, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+            from pyais.util import encode_ascii_6
+            
+            payload_bitarray = bitarray()
+            payload_bitarray.frombytes(bytes.fromhex(payload_hex))
+            payload_ascii6, fill_bits = encode_ascii_6(payload_bitarray)
+            
+            seq_id = kwargs.pop('seq_id') if 'seq_id' in kwargs else self.__tag_block_group_id % 10
+            radio_channel = kwargs['radio_channel'] if 'radio_channel' in kwargs else 'A'
+            group_id = kwargs.pop('group_id') if 'group_id' in kwargs else None
+            
+            sentences = HA_ais_to_nmea_0183(payload_ascii6, talker_id, radio_channel, fill_bits, seq_id)
+            return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
+            
+        def encode(self, data, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+            if isinstance(data, pyais.messages.Payload):
+                return self.encode_msg(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
+            elif isinstance(data, dict):
+                return self.encode_data(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
+            elif isinstance(data, TableWithHeader):
+                return self.encode_table(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
+            else:
+                raise TechnicalException(f"Unexpected data type '{Typing.get_object_class_fullname(data)}'")
         
-        sentences = pyais.encode_msg(msg, seq_id=seq_id, talker_id=talker_id, **kwargs)
-        return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
-    
-    def encode_data(self, data, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
-        if not isinstance(data, dict):
-            raise TechnicalException(f"Parameter 'data' is not a dict (obtained type: {Typing.get_object_class_fullname(data)})")
+        def encode_msg(self, msg, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+            if not isinstance(msg, pyais.messages.Payload):
+                raise TechnicalException(f"Parameter 'msg' is not an AIS message (obtained type: {Typing.get_object_class_fullname(msg)})")
+            
+            seq_id = kwargs.pop('seq_id') if 'seq_id' in kwargs else self.__tag_block_group_id % 10
+            group_id = kwargs.pop('group_id') if 'group_id' in kwargs else None
+            
+            sentences = pyais.encode_msg(msg, seq_id=seq_id, talker_id=talker_id, **kwargs)
+            return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
         
-        seq_id = kwargs.pop('seq_id') if 'seq_id' in kwargs else self.__tag_block_group_id % 10
-        group_id = kwargs.pop('group_id') if 'group_id' in kwargs else None
+        def encode_data(self, data, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+            if not isinstance(data, dict):
+                raise TechnicalException(f"Parameter 'data' is not a dict (obtained type: {Typing.get_object_class_fullname(data)})")
+            
+            seq_id = kwargs.pop('seq_id') if 'seq_id' in kwargs else self.__tag_block_group_id % 10
+            group_id = kwargs.pop('group_id') if 'group_id' in kwargs else None
+            
+            sentences = pyais.encode_dict(data, seq_id=seq_id, talker_id=talker_id, **kwargs)
+            return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
         
-        sentences = pyais.encode_dict(data, seq_id=seq_id, talker_id=talker_id, **kwargs)
-        return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
-    
-    def encode_table(self, table, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
-        data = self.__convert_table_to_dict(table)
-        return self.encode_data(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
-    
-    def __encode_add_tag_block(self, encoded_sentences, tag_block: HATagBlock = None, with_tag_block=True, group_id=None):
-        from pyais.messages import TagBlockGroup
+        def encode_table(self, table, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+            data = self.__convert_table_to_dict(table)
+            return self.encode_data(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
         
-        if not with_tag_block:
-            return encoded_sentences
+        def __encode_add_tag_block(self, encoded_sentences, tag_block: HATagBlock = None, with_tag_block=True, group_id=None):
+            from pyais.messages import TagBlockGroup
+            
+            if not with_tag_block:
+                return encoded_sentences
+            
+            res = []
+            nb_sentences = len(encoded_sentences)
+            if nb_sentences > 1 and group_id is None:
+                group_id = self.__tag_block_group_id
+                # Increment group_id for next message needing a group_id
+                self.__new_tag_block_group_id()
+            elif nb_sentences == 1:
+                # No group tag block is needed
+                group_id = None
+            
+            for index, sentence in enumerate(encoded_sentences):
+                sentence_tag_block = copy.deepcopy(tag_block) if index == 0 else None
+                if group_id is not None:
+                    if sentence_tag_block is None:
+                        sentence_tag_block = HATagBlock()
+                    sentence_tag_block._group = TagBlockGroup(msg_id=index+1, total=nb_sentences, group_id=group_id)
+                
+                if sentence_tag_block is not None:
+                    res.append('\\' + sentence_tag_block.to_raw().decode() + '\\' + sentence)
+                else:
+                    res.append(sentence)
+            
+            return res
         
-        res = []
-        nb_sentences = len(encoded_sentences)
-        if nb_sentences > 1 and group_id is None:
-            group_id = self.__tag_block_group_id
-            # Increment group_id for next message needing a group_id
-            self.__new_tag_block_group_id()
-        elif nb_sentences == 1:
-            # No group tag block is needed
-            group_id = None
+        def __new_tag_block_group_id(self):
+            self.__tag_block_group_id += 1
+            if self.__tag_block_group_id > 9999:
+                self.__tag_block_group_id = 0
+            return self.__tag_block_group_id
         
-        for index, sentence in enumerate(encoded_sentences):
-            sentence_tag_block = copy.deepcopy(tag_block) if index == 0 else None
-            if group_id is not None:
-                if sentence_tag_block is None:
-                    sentence_tag_block = HATagBlock()
-                sentence_tag_block._group = TagBlockGroup(msg_id=index+1, total=nb_sentences, group_id=group_id)
-            
-            if sentence_tag_block is not None:
-                res.append('\\' + sentence_tag_block.to_raw().decode() + '\\' + sentence)
-            else:
-                res.append(sentence)
+        def convert_message_to_binary_str(self, msg):
+            return msg.to_bitarray().to01()
         
-        return res
-    
-    def __new_tag_block_group_id(self):
-        self.__tag_block_group_id += 1
-        if self.__tag_block_group_id > 9999:
-            self.__tag_block_group_id = 0
-        return self.__tag_block_group_id
-    
-    def convert_message_to_binary_str(self, msg):
-        return msg.to_bitarray().to01()
-    
-    def convert_message_to_bytes(self, msg):
-        return msg.to_bitarray().tobytes()
-    
-    def __get_message_type(self, msg_type:int):
-        import importlib
-        module = importlib.import_module('pyais.messages')
-        res = getattr(module, f"MessageType{msg_type}")
-        return res
+        def convert_message_to_bytes(self, msg):
+            return msg.to_bitarray().tobytes()
         
-    def __convert_table_to_dict(self, table):
-        if not ValueTableManager.is_table_with_header(table):
-            raise TechnicalException(f"Parameter 'table' is not a table with header (obtained type: {Typing.get_object_class_fullname(table)})")
+        def __get_message_type(self, msg_type:int):
+            import importlib
+            module = importlib.import_module('pyais.messages')
+            res = getattr(module, f"MessageType{msg_type}")
+            return res
+            
+        def __convert_table_to_dict(self, table):
+            if not ValueTableManager.is_table_with_header(table):
+                raise TechnicalException(f"Parameter 'table' is not a table with header (obtained type: {Typing.get_object_class_fullname(table)})")
+            
+            if ValueTableManager.verify_table_is_name_value_table(table, raise_exception=False):
+                res = ValueTableConverter.convert_name_value_table_2_dict(table)
+            else:
+                res = ValueTableConverter.convert_table_with_header_to_dict(table)
+            return res
         
-        if ValueTableManager.verify_table_is_name_value_table(table, raise_exception=False):
-            res = ValueTableConverter.convert_name_value_table_2_dict(table)
-        else:
-            res = ValueTableConverter.convert_table_with_header_to_dict(table)
-        return res
-    
     
     

holado_core/common/tools/path_manager.py

@@ -122,10 +122,14 @@ class PathManager(object):
         else:
             os.replace(src, dst)
     
+    def get_user_home_path(self):
+        import pathlib
+        return str(pathlib.Path.home())
+    
     def get_local_resources_path(self, name=None):
-        base_path = os.getenv('HOLADO_TEST_LOCAL_RESOURCES_BASEDIR')
+        base_path = os.getenv('HOLADO_LOCAL_RESOURCES_BASEDIR')
         if base_path is None:
-            raise Exception("Missing environment variable HOLADO_TEST_LOCAL_RESOURCES_BASEDIR with HolAdo local resources base path")
+            base_path = os.path.join(self.get_user_home_path(), '.holado', 'resources')
         
         if name is not None:
             return os.path.join(base_path, name)
@@ -133,9 +137,9 @@ class PathManager(object):
             return base_path
     
     def get_reports_path(self, name=None):
-        base_path = os.getenv('HOLADO_TEST_OUTPUT_BASEDIR')
+        base_path = os.getenv('HOLADO_OUTPUT_BASEDIR')
         if base_path is None:
-            raise Exception("Missing environment variable HOLADO_TEST_OUTPUT_BASEDIR with HolAdo output base path")
+            base_path = os.path.join(self.get_user_home_path(), '.holado', 'output')
         
         if name is not None:
             return os.path.join(base_path, "reports", name)

holado_grpc/api/rpc/grpc_client.py

@@ -47,135 +47,139 @@ class GRpcClient(object):
     def is_available(cls):
         return with_grpc_requests
     
-    def __init__(self, name, endpoint, **kwargs):
-        self.__name = name
-        self.__endpoint = endpoint
-        self.__kwargs = kwargs
-        self.__client = grpc_requests.client.get_by_endpoint(endpoint, **kwargs)
-        
-        self.__func_grpc_services = None
-        self.__func_protobuf_converter = None
-        self.__func_protobuf_messages = None
-    
-    def initialize(self, func_grpc_services, func_protobuf_converter, func_protobuf_messages):
-        self.__func_grpc_services = func_grpc_services
-        self.__func_protobuf_converter = func_protobuf_converter
-        self.__func_protobuf_messages = func_protobuf_messages
+    if with_grpc_requests:
+        def __init__(self, name, endpoint, **kwargs):
+            self.__name = name
+            self.__endpoint = endpoint
+            self.__kwargs = kwargs
+            self.__client = grpc_requests.client.get_by_endpoint(endpoint, **kwargs)
+            
+            self.__func_grpc_services = None
+            self.__func_protobuf_converter = None
+            self.__func_protobuf_messages = None
         
-    @property
-    def __grpc_services(self):
-        return self.__func_grpc_services()
-
-    @property
-    def __protobuf_converter(self):
-        return self.__func_protobuf_converter()
-
-    @property
-    def __protobuf_messages(self):
-        return self.__func_protobuf_messages()
-    
-    @property
-    def name(self):
-        return self.__name
+        def initialize(self, func_grpc_services, func_protobuf_converter, func_protobuf_messages):
+            self.__func_grpc_services = func_grpc_services
+            self.__func_protobuf_converter = func_protobuf_converter
+            self.__func_protobuf_messages = func_protobuf_messages
+            
+        @property
+        def __grpc_services(self):
+            return self.__func_grpc_services()
     
-    @property    
-    def internal_client(self) -> grpc_requests.client.Client:
-        return self.__client
+        @property
+        def __protobuf_converter(self):
+            return self.__func_protobuf_converter()
     
-    def request(self, service, method, request, raw_output=False, **kwargs):
-        """
-        :param request: request data in json or proto format
-        :param raw_output: if method should return a proto object or a json oject (default: False)
-        :param kwargs: other arguments for underlying grpc_requests method, or further underlying grpc method (ex: 'timeout')
-        :returns: if raw_output==True, returns a proto object, else returns a json object with proto data
-        """
-        logger.info(f"Requesting {service}.{method} with data [{request}] (raw_output: {raw_output} ; kwargs:{kwargs})")
+        @property
+        def __protobuf_messages(self):
+            return self.__func_protobuf_messages()
         
-        # Set a default timeout
-        raise_on_timeout = False
-        if kwargs is None:
-            kwargs = {}
-        if 'timeout' not in kwargs:
-            kwargs['timeout'] = Config.join_timeout_seconds
-            raise_on_timeout = True
-        timeout = kwargs['timeout'] if 'timeout' in kwargs else None
+        @property
+        def name(self):
+            return self.__name
         
-        success = False
-        last_exc = None
-        for try_nb in range(1,4):
-            try:
-                # Ask always raw_output=True, so that we get a Protobuf instance, and then conversion is done if needed
-                res_proto = self.internal_client.request(service, method, request, raw_output=True, **kwargs)
-            except Exception as exc:
-                last_exc = exc
-                exc_str = str(exc)
-                msg_list = [
-                    f"Request failed (try {try_nb}):",
-                    f"    method: {service}.{method}",
-                    f"    data:",
-                    Tools.indent_string(8, str(request)),
-                    f"    raw_output: {raw_output}",
-                    f"    kwargs: {kwargs}",
-                    f"    error:",
-                    Tools.indent_string(8, exc_str) ]
-                exc_msg = "\n".join(msg_list)
-                if "status = StatusCode.UNAVAILABLE" in exc_str:
-                    logger.warning("Service temporarily unavailable:\n" + exc_msg)
-                    time.sleep(1)
-                    continue
-                elif "status = StatusCode.DEADLINE_EXCEEDED" in exc_str:
-                    if raise_on_timeout:
-                        raise TimeoutTechnicalException(exc_msg)
-                    else:
-                        logger.warning(f"Timeout ({timeout} s) occured while requesting:\n" + exc_msg)
+        @property    
+        def internal_client(self) -> grpc_requests.client.Client:
+            return self.__client
+        
+        def request(self, service, method, request, raw_output=False, **kwargs):
+            """
+            :param request: request data in json or proto format
+            :param raw_output: if method should return a proto object or a json oject (default: False)
+            :param kwargs: other arguments for underlying grpc_requests method, or further underlying grpc method (ex: 'timeout')
+            :returns: if raw_output==True, returns a proto object, else returns a json object with proto data
+            """
+            logger.info(f"Requesting {service}.{method} with data [{request}] (raw_output: {raw_output} ; kwargs:{kwargs})")
+            
+            # Set a default timeout
+            raise_on_timeout = False
+            if kwargs is None:
+                kwargs = {}
+            if 'timeout' not in kwargs:
+                kwargs['timeout'] = Config.join_timeout_seconds
+                raise_on_timeout = True
+            timeout = kwargs['timeout'] if 'timeout' in kwargs else None
+            
+            success = False
+            last_exc = None
+            for try_nb in range(1,4):
+                try:
+                    # Ask always raw_output=True, so that we get a Protobuf instance, and then conversion is done if needed
+                    res_proto = self.internal_client.request(service, method, request, raw_output=True, **kwargs)
+                except Exception as exc:
+                    last_exc = exc
+                    exc_str = str(exc)
+                    msg_list = [
+                        f"Request failed (try {try_nb}):",
+                        f"    method: {service}.{method}",
+                        f"    data:",
+                        Tools.indent_string(8, str(request)),
+                        f"    raw_output: {raw_output}",
+                        f"    kwargs: {kwargs}",
+                        f"    error:",
+                        Tools.indent_string(8, exc_str) ]
+                    exc_msg = "\n".join(msg_list)
+                    if "status = StatusCode.UNAVAILABLE" in exc_str:
+                        logger.warning("Service temporarily unavailable:\n" + exc_msg)
                         time.sleep(1)
                         continue
-                elif "status = " in exc_str:
-                    raise FunctionalException(exc_msg) from exc
+                    elif "status = StatusCode.DEADLINE_EXCEEDED" in exc_str:
+                        if raise_on_timeout:
+                            raise TimeoutTechnicalException(exc_msg)
+                        else:
+                            logger.warning(f"Timeout ({timeout} s) occured while requesting:\n" + exc_msg)
+                            time.sleep(1)
+                            continue
+                    elif "status = " in exc_str:
+                        raise FunctionalException(exc_msg) from exc
+                    else:
+                        raise TechnicalException(exc_msg) from exc
                 else:
-                    raise TechnicalException(exc_msg) from exc
-            else:
-                success = True
-                break
-        
-        if not success:
-            if "status = " in exc_msg:
-                raise FunctionalException(exc_msg) from last_exc
-            else:
-                raise TechnicalException(exc_msg) from last_exc
+                    success = True
+                    break
             
-        # Manage result conversion if needed
-        # Note: this step is done manually since grpc_requests has some limitations when raw_output=False:
-        #     - Field with default values are not set in json result
-        #     - Some field types are badly managed (ex: uint64 fields appear as string in json)
-        if raw_output == True:
-            if isinstance(res_proto, grpc._channel._MultiThreadedRendezvous):
-                return list(res_proto)
+            if not success:
+                if "status = " in exc_msg:
+                    raise FunctionalException(exc_msg) from last_exc
+                else:
+                    raise TechnicalException(exc_msg) from last_exc
+                
+            # Manage result conversion if needed
+            # Note: this step is done manually since grpc_requests has some limitations when raw_output=False:
+            #     - Field with default values are not set in json result
+            #     - Some field types are badly managed (ex: uint64 fields appear as string in json)
+            if raw_output == True:
+                if isinstance(res_proto, grpc._channel._MultiThreadedRendezvous):
+                    return list(res_proto)
+                else:
+                    return res_proto
             else:
-                return res_proto
-        else:
-            if isinstance(res_proto, grpc._channel._MultiThreadedRendezvous):
-                res = [self.__protobuf_converter.convert_protobuf_object_to_json_object(cur_res) for cur_res in res_proto]
+                if isinstance(res_proto, grpc._channel._MultiThreadedRendezvous):
+                    res = [self.__protobuf_converter.convert_protobuf_object_to_json_object(cur_res) for cur_res in res_proto]
+                else:
+                    res = self.__protobuf_converter.convert_protobuf_object_to_json_object(res_proto)
+                return res
+                
+        def get_request_data_type_fullname(self, service, method):
+            method_descriptor = self.__grpc_services.get_method_descriptor(service, method)
+            return method_descriptor.input_type.full_name
+            
+        def build_request_data(self, service, method, params_table=None, params_dict=None, as_proto=False):
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace(f"Building request data for service method '{service}.{method}'")
+            if as_proto is not None and as_proto:
+                method_descriptor = self.__grpc_services.get_method_descriptor(service, method)
+                res = self.__protobuf_messages.new_message(method_descriptor.input_type.full_name, fields_table=params_table, fields_dict=params_dict)
             else:
-                res = self.__protobuf_converter.convert_protobuf_object_to_json_object(res_proto)
-            return res
+                if params_table is not None:
+                    res = ValueTableConverter.convert_name_value_table_2_json_object(params_table)
+                elif params_dict is not None:
+                    res = params_dict
+                else:
+                    res = {}
             
-    def get_request_data_type_fullname(self, service, method):
-        method_descriptor = self.__grpc_services.get_method_descriptor(service, method)
-        return method_descriptor.input_type.full_name
+            return res
         
-    def build_request_data(self, service, method, params_table=None, params_dict=None, as_proto=False):
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"Building request data for service method '{service}.{method}'")
-        if as_proto is not None and as_proto:
-            method_descriptor = self.__grpc_services.get_method_descriptor(service, method)
-            res = self.__protobuf_messages.new_message(method_descriptor.input_type.full_name, fields_table=params_table, fields_dict=params_dict)
-        else:
-            if params_table is not None:
-                res = ValueTableConverter.convert_name_value_table_2_json_object(params_table)
-            elif params_dict is not None:
-                res = params_dict
-            else:
-                res = {}
         
-        return res
+        

holado_helper/docker/logging.conf

@@ -1,7 +1,9 @@
-[logger_root]
+[holado]
 #level=INFO
 level=DEBUG
 #level=TRACE
+log_on_console=False
+log_in_file=True
 
 [loggers_levels]
 holado=INFO