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

holado_protobuf/ipc/protobuf/protobuf_messages.py

@@ -25,18 +25,19 @@ from holado_value.common.tools.value_types import ValueTypes
 import inspect
 from typing import NamedTuple
 from holado_core.common.exceptions.holado_exception import HAException
-from google.protobuf.descriptor import FieldDescriptor
 from holado_python.standard_library.typing import Typing
 from holado.common.handlers.undefined import undefined_argument, undefined_value
-from holado_protobuf.ipc.protobuf.protobuf_converter import SortOrder
 
 logger = logging.getLogger(__name__)
 
 try:
     import google.protobuf.message
     import google.protobuf.descriptor
+    from google.protobuf.descriptor import FieldDescriptor
     # import google.protobuf.pyext
     from google.protobuf.internal import api_implementation
+    from holado_protobuf.ipc.protobuf.protobuf_converter import SortOrder
+    
     # logger.info(f"Protobuf internal API implementation is of type '{api_implementation.Type()}'")
     if api_implementation.Type() == 'cpp':
         # from google.protobuf.pyext.cpp_message import GeneratedProtocolMessageType
@@ -65,901 +66,903 @@ class ProtobufMessages(object):
     def is_available(cls):
         return with_protobuf
 
-    @classmethod
-    def is_descriptor_enum(cls, obj):
-        return isinstance(obj, google.protobuf.descriptor.EnumDescriptor)
-
-    @classmethod
-    def is_descriptor_message(cls, obj):
-        return isinstance(obj, google.protobuf.descriptor.Descriptor)
-
-    @classmethod
-    def is_object_message(cls, obj):
-        return isinstance(obj, google.protobuf.message.Message)
-
-    @classmethod
-    def is_object_enum(cls, obj):
-        class_name = type(obj).__name__.lower()
-        return "enum" in class_name
-
-    @classmethod
-    def is_object_repeated(cls, obj):
-        class_name = type(obj).__name__.lower()
-        return "repeated" in class_name
-
-    @classmethod
-    def is_object_map(cls, obj):
-        class_name = type(obj).__name__.lower()
-        return "map" in class_name and hasattr(obj, 'items') and callable(obj.items)
-        # return isinstance(obj, ScalarMap) or isinstance(obj, MessageMap)
-        
-    def is_message_field_set(self, obj, field_name):
-        return self.__is_message_field_set(obj, field_name)
-    
-    def __init__(self): 
-        self.__message_types_by_fullname = {}
-        self.__enum_types_by_fullname = {}
-        self.__enum_data_by_fullname = {}
-        self.__regex_attribute_fullname = re.compile(r'^(.*?)(?:\[(.+)\])?$')
+    if with_protobuf:
         
-        self.__registered_types = []
+        @classmethod
+        def is_descriptor_enum(cls, obj):
+            return isinstance(obj, google.protobuf.descriptor.EnumDescriptor)
+    
+        @classmethod
+        def is_descriptor_message(cls, obj):
+            return isinstance(obj, google.protobuf.descriptor.Descriptor)
+    
+        @classmethod
+        def is_object_message(cls, obj):
+            return isinstance(obj, google.protobuf.message.Message)
     
-    def initialize(self):
-        self._register_types()
+        @classmethod
+        def is_object_enum(cls, obj):
+            class_name = type(obj).__name__.lower()
+            return "enum" in class_name
+    
+        @classmethod
+        def is_object_repeated(cls, obj):
+            class_name = type(obj).__name__.lower()
+            return "repeated" in class_name
+    
+        @classmethod
+        def is_object_map(cls, obj):
+            class_name = type(obj).__name__.lower()
+            return "map" in class_name and hasattr(obj, 'items') and callable(obj.items)
+            # return isinstance(obj, ScalarMap) or isinstance(obj, MessageMap)
+            
+        def is_message_field_set(self, obj, field_name):
+            return self.__is_message_field_set(obj, field_name)
         
-    def import_all_compiled_proto(self, compiled_proto_path, package_name=None, raise_if_not_exist=True):
-        """Register a folder path containing compiled proto files. Usually it corresponds to the parameter '--python_out' passed to proto compiler."""
-        if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"[ProtobufMessages] Importing all compiled proto in '{compiled_proto_path}'...")
+        def __init__(self): 
+            self.__message_types_by_fullname = {}
+            self.__enum_types_by_fullname = {}
+            self.__enum_data_by_fullname = {}
+            self.__regex_attribute_fullname = re.compile(r'^(.*?)(?:\[(.+)\])?$')
+            
+            self.__registered_types = []
         
-        if package_name is None:
-            package_name = ""
+        def initialize(self):
+            self._register_types()
+            
+        def import_all_compiled_proto(self, compiled_proto_path, package_name=None, raise_if_not_exist=True):
+            """Register a folder path containing compiled proto files. Usually it corresponds to the parameter '--python_out' passed to proto compiler."""
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"[ProtobufMessages] Importing all compiled proto in '{compiled_proto_path}'...")
+            
+            if package_name is None:
+                package_name = ""
+            
+            if os.path.exists(compiled_proto_path):
+                if os.path.isfile(compiled_proto_path):
+                    proto_path = os.path.dirname(compiled_proto_path)
+                    sys.path.append(proto_path)
+                    self.__import_compiled_proto(compiled_proto_path, package_name)
+                elif os.path.isdir(compiled_proto_path):
+                    sys.path.append(compiled_proto_path)
+                    self.__import_all_compiled_proto(compiled_proto_path, package_name)
+                else:
+                    raise TechnicalException(f"Unmanaged path '{compiled_proto_path}'")
+            else:
+                msg = f"Path '{compiled_proto_path}' doesn't exist"
+                if raise_if_not_exist:
+                    raise TechnicalException(msg)
+                else:
+                    logger.warning(msg)
         
-        if os.path.exists(compiled_proto_path):
-            if os.path.isfile(compiled_proto_path):
-                proto_path = os.path.dirname(compiled_proto_path)
-                sys.path.append(proto_path)
-                self.__import_compiled_proto(compiled_proto_path, package_name)
-            elif os.path.isdir(compiled_proto_path):
-                sys.path.append(compiled_proto_path)
-                self.__import_all_compiled_proto(compiled_proto_path, package_name)
+        def __import_all_compiled_proto(self, compiled_proto_path, package_name):
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace(f"[ProtobufMessages] Importing all compiled proto in '{compiled_proto_path}' (package: '{package_name}')...")
+            if os.path.isdir(compiled_proto_path):
+                lp = os.listdir(compiled_proto_path)
+                for cp in lp:
+                    if not cp.startswith((".", "_")):
+                        cur_proto_path = os.path.join(compiled_proto_path, cp)
+                        
+                        if os.path.isfile(cur_proto_path):
+                            self.__import_compiled_proto(cur_proto_path, package_name)
+                        elif os.path.isdir(cur_proto_path):
+                            cur_package_name = f"{package_name}.{cp}" if package_name is not None and len(package_name) > 0 else cp
+                            self.__import_all_compiled_proto(cur_proto_path, cur_package_name)
+                        else:
+                            raise TechnicalException(f"Unmanaged path '{cur_proto_path}'")
             else:
                 raise TechnicalException(f"Unmanaged path '{compiled_proto_path}'")
-        else:
-            msg = f"Path '{compiled_proto_path}' doesn't exist"
-            if raise_if_not_exist:
-                raise TechnicalException(msg)
-            else:
-                logger.warning(msg)
-    
-    def __import_all_compiled_proto(self, compiled_proto_path, package_name):
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"[ProtobufMessages] Importing all compiled proto in '{compiled_proto_path}' (package: '{package_name}')...")
-        if os.path.isdir(compiled_proto_path):
-            lp = os.listdir(compiled_proto_path)
-            for cp in lp:
-                if not cp.startswith((".", "_")):
-                    cur_proto_path = os.path.join(compiled_proto_path, cp)
-                    
-                    if os.path.isfile(cur_proto_path):
-                        self.__import_compiled_proto(cur_proto_path, package_name)
-                    elif os.path.isdir(cur_proto_path):
-                        cur_package_name = f"{package_name}.{cp}" if package_name is not None and len(package_name) > 0 else cp
-                        self.__import_all_compiled_proto(cur_proto_path, cur_package_name)
-                    else:
-                        raise TechnicalException(f"Unmanaged path '{cur_proto_path}'")
-        else:
-            raise TechnicalException(f"Unmanaged path '{compiled_proto_path}'")
-    
-    def __import_compiled_proto(self, compiled_proto_file_path, package_name):
-        if not os.path.isfile(compiled_proto_file_path):
-            raise TechnicalException(f"Compiled proto path '{compiled_proto_file_path}' is not a file")
-        if not compiled_proto_file_path.endswith("_pb2.py"):
-            return
-
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-
-            logger.trace(f"[ProtobufMessages] Importing compiled proto file '{compiled_proto_file_path}' (package: '{package_name}')...")
-        
-        filename = os.path.splitext(os.path.basename(compiled_proto_file_path))[0]
-        module_name = f"{package_name}.{filename}" if package_name is not None and len(package_name) > 0 else filename
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"[ProtobufMessages] Importing module '{module_name}'")
-        module = importlib.import_module(module_name)
         
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-        
-            logger.trace(f"[ProtobufMessages] DESCRIPTOR of module '{module_name}': {self.__represent_descriptor(module.DESCRIPTOR)}")
-        module_package = module.DESCRIPTOR.package if hasattr(module.DESCRIPTOR, 'package') else package_name
-        self.__import_compiled_proto_object(module, module_package)
-
-    def __import_compiled_proto_object(self, module_or_object, module_or_object_fullname):
-        # Import message types
-        if hasattr(module_or_object.DESCRIPTOR, 'message_types_by_name'):
-            for mt_name in module_or_object.DESCRIPTOR.message_types_by_name:
-                self.__import_compiled_proto_message(module_or_object, module_or_object_fullname, mt_name)
-            
-        # Import enum types
-        if hasattr(module_or_object.DESCRIPTOR, 'enum_types_by_name'):
-            for et_name in module_or_object.DESCRIPTOR.enum_types_by_name:
-                self.__import_compiled_proto_enum(module_or_object, module_or_object_fullname, et_name)
+        def __import_compiled_proto(self, compiled_proto_file_path, package_name):
+            if not os.path.isfile(compiled_proto_file_path):
+                raise TechnicalException(f"Compiled proto path '{compiled_proto_file_path}' is not a file")
+            if not compiled_proto_file_path.endswith("_pb2.py"):
+                return
+    
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+    
+                logger.trace(f"[ProtobufMessages] Importing compiled proto file '{compiled_proto_file_path}' (package: '{package_name}')...")
             
-        # Import nested types
-        if hasattr(module_or_object.DESCRIPTOR, 'nested_types_by_name'):
-            for nt_name in module_or_object.DESCRIPTOR.nested_types_by_name:
-                nt = module_or_object.DESCRIPTOR.nested_types_by_name[nt_name]
-                if self.is_descriptor_message(nt):
-                    self.__import_compiled_proto_message(module_or_object, module_or_object_fullname, nt_name)
-                elif self.is_descriptor_enum(nt):
-                    self.__import_compiled_proto_enum(module_or_object, module_or_object_fullname, nt_name)
-                else:
-                    raise TechnicalException(f"Unmanaged nested type '{nt_name}' having descriptor: {self.__represent_descriptor(nt)}")
-
-    def __import_compiled_proto_message(self, module_or_object, module_or_object_fullname, message_type_name):
-        if hasattr(module_or_object, message_type_name):
-            mt = getattr(module_or_object, message_type_name)
-            mt_fullname = f"{module_or_object_fullname}.{message_type_name}" if module_or_object_fullname is not None and len(module_or_object_fullname) > 0 else message_type_name
-            self.__message_types_by_fullname[mt_fullname] = mt
-            if Tools.do_log(logger, logging.DEBUG):
-                logger.debug(f"[ProtobufMessages] New managed message type '{mt_fullname}' (type: '{mt.__qualname__}')")
+            filename = os.path.splitext(os.path.basename(compiled_proto_file_path))[0]
+            module_name = f"{package_name}.{filename}" if package_name is not None and len(package_name) > 0 else filename
             if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"[ProtobufMessages] Message type '{mt_fullname}': {Tools.represent_object(mt)}")
+                logger.trace(f"[ProtobufMessages] Importing module '{module_name}'")
+            module = importlib.import_module(module_name)
+            
             if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"[ProtobufMessages] DESCRIPTOR of message type '{mt_fullname}': {self.__represent_descriptor(mt.DESCRIPTOR)}")
             
+                logger.trace(f"[ProtobufMessages] DESCRIPTOR of module '{module_name}': {self.__represent_descriptor(module.DESCRIPTOR)}")
+            module_package = module.DESCRIPTOR.package if hasattr(module.DESCRIPTOR, 'package') else package_name
+            self.__import_compiled_proto_object(module, module_package)
+    
+        def __import_compiled_proto_object(self, module_or_object, module_or_object_fullname):
+            # Import message types
+            if hasattr(module_or_object.DESCRIPTOR, 'message_types_by_name'):
+                for mt_name in module_or_object.DESCRIPTOR.message_types_by_name:
+                    self.__import_compiled_proto_message(module_or_object, module_or_object_fullname, mt_name)
+                
+            # Import enum types
+            if hasattr(module_or_object.DESCRIPTOR, 'enum_types_by_name'):
+                for et_name in module_or_object.DESCRIPTOR.enum_types_by_name:
+                    self.__import_compiled_proto_enum(module_or_object, module_or_object_fullname, et_name)
+                
             # Import nested types
-            self.__import_compiled_proto_object(mt, mt_fullname)
-        else:
-            raise TechnicalException(f"Not found message type '{message_type_name}' in '{module_or_object_fullname}': {Tools.represent_object(module_or_object)}")
-
-    def __import_compiled_proto_enum(self, module_or_object, module_or_object_fullname, enum_type_name):
-        if hasattr(module_or_object, enum_type_name):
-            et = getattr(module_or_object, enum_type_name)
-            et_fullname = f"{module_or_object_fullname}.{enum_type_name}" if module_or_object_fullname is not None and len(module_or_object_fullname) > 0 else enum_type_name
-            self.__enum_types_by_fullname[et_fullname] = et
-            if Tools.do_log(logger, logging.DEBUG):
-                logger.debug(f"[ProtobufMessages] New managed enum type '{et_fullname}' (type: '{Typing.get_object_class_fullname(et)}')")
-            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"[ProtobufMessages] Enum type '{et_fullname}': {Tools.represent_object(et)}")
-            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"[ProtobufMessages] DESCRIPTOR of enum type '{et_fullname}': {self.__represent_descriptor(et.DESCRIPTOR)}")
-        else:
-            raise TechnicalException(f"Not found enum type '{enum_type_name}' in '{module_or_object_fullname}': {Tools.represent_object(module_or_object)}")
-
-    def has_object_type(self, type_fullname):
-        """Return if type fullname is known."""
-        return self.has_message_type(type_fullname) or self.has_enum_type(type_fullname)
-
-    def has_message_type(self, message_type_fullname):
-        """Return if message type fullname is known."""
-        return message_type_fullname in self.__message_types_by_fullname
-
-    def has_enum_type(self, enum_type_fullname):
-        """Return if enum type fullname is known."""
-        return enum_type_fullname in self.__enum_types_by_fullname
-
-    def get_object_type(self, type_fullname):
-        """Return type object for given type fullname."""
-        if self.has_message_type(type_fullname):
-            return self.get_message_type(type_fullname)
-        else:
-            raise FunctionalException(f"Unknown type fullname '{type_fullname}'")
-
-    def get_message_type(self, message_type_fullname):
-        """Return type object for given message type fullname."""
-        if self.has_message_type(message_type_fullname):
-            return self.__message_types_by_fullname[message_type_fullname]
-        else:
-            raise FunctionalException(f"Unknown message type fullname '{message_type_fullname}'")
-
-    def get_enum_type(self, enum_type_fullname):
-        """Return type object for given message type fullname."""
-        if self.has_enum_type(enum_type_fullname):
-            return self.__enum_types_by_fullname[enum_type_fullname]
-        else:
-            raise FunctionalException(f"Unknown enum type fullname '{enum_type_fullname}' (known enums: {list(self.__enum_types_by_fullname.keys())})")
-        
-    def get_enum_name(self, enum_value, enum_type_fullname):
-        enum_type = self.get_enum_type(enum_type_fullname)
-        return self.__get_enum_name(enum_value, enum_type=enum_type)
-
-    def get_enum_value(self, fullname=None, enum_type_fullname=None, enum_name=None):
-        if fullname is not None:
-            enum_type_fullname, enum_name = fullname.rsplit('.', 1)
-        enum_type = self.get_enum_type(enum_type_fullname)
-        return self.__get_enum_value(enum_name, enum_type=enum_type)
-
-    def new_object(self, type_fullname):
-        """Return a new object of given type fullname."""
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"Creating new object of type '{type_fullname}'...")
-        if self.has_object_type(type_fullname):
+            if hasattr(module_or_object.DESCRIPTOR, 'nested_types_by_name'):
+                for nt_name in module_or_object.DESCRIPTOR.nested_types_by_name:
+                    nt = module_or_object.DESCRIPTOR.nested_types_by_name[nt_name]
+                    if self.is_descriptor_message(nt):
+                        self.__import_compiled_proto_message(module_or_object, module_or_object_fullname, nt_name)
+                    elif self.is_descriptor_enum(nt):
+                        self.__import_compiled_proto_enum(module_or_object, module_or_object_fullname, nt_name)
+                    else:
+                        raise TechnicalException(f"Unmanaged nested type '{nt_name}' having descriptor: {self.__represent_descriptor(nt)}")
+    
+        def __import_compiled_proto_message(self, module_or_object, module_or_object_fullname, message_type_name):
+            if hasattr(module_or_object, message_type_name):
+                mt = getattr(module_or_object, message_type_name)
+                mt_fullname = f"{module_or_object_fullname}.{message_type_name}" if module_or_object_fullname is not None and len(module_or_object_fullname) > 0 else message_type_name
+                self.__message_types_by_fullname[mt_fullname] = mt
+                if Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(f"[ProtobufMessages] New managed message type '{mt_fullname}' (type: '{mt.__qualname__}')")
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"[ProtobufMessages] Message type '{mt_fullname}': {Tools.represent_object(mt)}")
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"[ProtobufMessages] DESCRIPTOR of message type '{mt_fullname}': {self.__represent_descriptor(mt.DESCRIPTOR)}")
+                
+                # Import nested types
+                self.__import_compiled_proto_object(mt, mt_fullname)
+            else:
+                raise TechnicalException(f"Not found message type '{message_type_name}' in '{module_or_object_fullname}': {Tools.represent_object(module_or_object)}")
+    
+        def __import_compiled_proto_enum(self, module_or_object, module_or_object_fullname, enum_type_name):
+            if hasattr(module_or_object, enum_type_name):
+                et = getattr(module_or_object, enum_type_name)
+                et_fullname = f"{module_or_object_fullname}.{enum_type_name}" if module_or_object_fullname is not None and len(module_or_object_fullname) > 0 else enum_type_name
+                self.__enum_types_by_fullname[et_fullname] = et
+                if Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(f"[ProtobufMessages] New managed enum type '{et_fullname}' (type: '{Typing.get_object_class_fullname(et)}')")
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"[ProtobufMessages] Enum type '{et_fullname}': {Tools.represent_object(et)}")
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"[ProtobufMessages] DESCRIPTOR of enum type '{et_fullname}': {self.__represent_descriptor(et.DESCRIPTOR)}")
+            else:
+                raise TechnicalException(f"Not found enum type '{enum_type_name}' in '{module_or_object_fullname}': {Tools.represent_object(module_or_object)}")
+    
+        def has_object_type(self, type_fullname):
+            """Return if type fullname is known."""
+            return self.has_message_type(type_fullname) or self.has_enum_type(type_fullname)
+    
+        def has_message_type(self, message_type_fullname):
+            """Return if message type fullname is known."""
+            return message_type_fullname in self.__message_types_by_fullname
+    
+        def has_enum_type(self, enum_type_fullname):
+            """Return if enum type fullname is known."""
+            return enum_type_fullname in self.__enum_types_by_fullname
+    
+        def get_object_type(self, type_fullname):
+            """Return type object for given type fullname."""
             if self.has_message_type(type_fullname):
-                mt = self.get_message_type(type_fullname)
-                res = mt()
+                return self.get_message_type(type_fullname)
             else:
-                raise TechnicalException(f"Unmanaged object creation for type fullname '{type_fullname}' (all managed types are logged at start with level DEBUG)")
-        else:
-            raise TechnicalException(f"Unknown type fullname '{type_fullname}' (all known types are logged at start with level DEBUG)")
-        
-        if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"New object of type '{type_fullname}' => {res}")
-        return res
-
-    def new_message(self, message_type_fullname, fields_table=None, fields_dict=None, serialized_string=None):
-        """Return a new message of given message type fullname.
-        The content of the message can be filled from serialized string, or from field values in a Name/Value table.
-        """
-        res = self.new_object(message_type_fullname)
-        
-        if serialized_string is not None:
-            res.ParseFromString(serialized_string)
-        elif fields_table is not None:
-            if ValueTableManager.verify_table_is_name_value_table(fields_table, raise_exception=False):
-                self.__set_object_fields_with_name_value_table(res, fields_table)
+                raise FunctionalException(f"Unknown type fullname '{type_fullname}'")
+    
+        def get_message_type(self, message_type_fullname):
+            """Return type object for given message type fullname."""
+            if self.has_message_type(message_type_fullname):
+                return self.__message_types_by_fullname[message_type_fullname]
             else:
-                raise TechnicalException(f"When defining parameter fields_table, it must be a Name/Value table")
-        elif fields_dict is not None:
-            self.__set_object_fields_with_dict(res, fields_dict)
-        
-        if Tools.do_log(logger, logging.DEBUG):
-            # logger.debug(f"New message of type '{message_type_fullname}' => {res}")
-            logger.debug(f"New message of type '{message_type_fullname}' => {Tools.represent_object(res)}")
-        return res
-        
-    def get_object_field_names(self, obj, recursive=False, uncollapse_repeated=False, add_repeated_index=False, with_unset=True, sort_order=SortOrder.Definition):
-        res = self.__get_object_field_names(obj, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, is_message_field=False, sort_order=sort_order)
-        # logger.trace(f"Object of type '{self.get_object_type_fullname(obj)}' has field names: {res}")
-        return res
-        
-    def get_message_field_names(self, obj, recursive=False, uncollapse_repeated=False, add_repeated_index=False, with_unset=True):
-        res = self.__get_message_field_names(obj, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset)
-        # logger.trace(f"Message of type '{self.get_object_type_fullname(obj)}' has field names: {res}")
-        return res
-        
-    def get_object_field_values(self, obj, attribute_expression):
-        """
-        Return a list of values for attribute names matching given expression.
-        Attribute name expression can contain "." for sub-fields, and "[]" to access all elements of the repeated field.
-        The list contains only one value unless a repeated field is included in attribute expression with suffix '[]'.
-        """ 
-        attr_names = attribute_expression.split('.')
-        res_list = [(obj, "")]
-        for attr_name in attr_names:
-            old_list = res_list
-            if attr_name.endswith("[]"):
-                if len(old_list) > 1:
-                    raise TechnicalException("Uncollapse two different repeated fields in the same message is not managed.")
-                cur_res = old_list[0][0]
-                cur_fullname = old_list[0][1]
-                real_attr_name = attr_name[:-2]
-                
-                cur_attr_fullname = cur_fullname + '.' + real_attr_name if len(cur_fullname) > 0 else real_attr_name
-                if not hasattr(cur_res, real_attr_name):
-                    raise TechnicalException(f"Attribute '{cur_attr_fullname}' doesn't exist in object [{cur_res}]")
-                
-                res_list = []
-                for index, attr_obj in enumerate(getattr(cur_res, real_attr_name)):
-                    new_attr_fullname = f"{cur_attr_fullname}[{index}]"
-                    res_list.append((attr_obj, new_attr_fullname))
+                raise FunctionalException(f"Unknown message type fullname '{message_type_fullname}'")
+    
+        def get_enum_type(self, enum_type_fullname):
+            """Return type object for given message type fullname."""
+            if self.has_enum_type(enum_type_fullname):
+                return self.__enum_types_by_fullname[enum_type_fullname]
             else:
-                res_list = []
-                for obj, obj_attr_fullname in old_list:
-                    new_attr_fullname = f"{obj_attr_fullname}.{attr_name}"
-                    if self.__has_object_field(obj, field_name=attr_name):
-                        attr_obj = self.__get_object_field(obj, field_name=attr_name)
-                        res_list.append((attr_obj, new_attr_fullname))
-                    else:
-                        raise TechnicalException(f"Attribute '{new_attr_fullname}' doesn't exist in object [{obj}]")
-                    
-        return [obj for obj, _ in res_list]
+                raise FunctionalException(f"Unknown enum type fullname '{enum_type_fullname}' (known enums: {list(self.__enum_types_by_fullname.keys())})")
             
-    def has_object_field(self, obj, attribute_expression, create_field=False):
-        leaf_obj, _, attr_last_name = self.__get_leaf_object_and_attribute_names(obj, attribute_expression, create_field=create_field)
-        return self.__has_object_field(leaf_obj, field_fullname=attr_last_name)
-        
-    def get_object_field_value(self, obj, attribute_expression, create_field=False):
-        """
-        Return the value for attribute name matching given expression.
-        Attribute name expression can contain "." for sub-fields.
-        """ 
-        attr_names = attribute_expression.split('.')
-        res = obj
-        attr_fullname = ""
-        for attr_name in attr_names:
-            if self.__has_object_field(res, field_fullname=attr_name):
-                res = self.__get_object_field(res, field_fullname=attr_name, create_field=create_field)
-                attr_fullname = attr_fullname + '.' + attr_name if len(attr_fullname) > 0 else attr_name
+        def get_enum_name(self, enum_value, enum_type_fullname):
+            enum_type = self.get_enum_type(enum_type_fullname)
+            return self.__get_enum_name(enum_value, enum_type=enum_type)
+    
+        def get_enum_value(self, fullname=None, enum_type_fullname=None, enum_name=None):
+            if fullname is not None:
+                enum_type_fullname, enum_name = fullname.rsplit('.', 1)
+            enum_type = self.get_enum_type(enum_type_fullname)
+            return self.__get_enum_value(enum_name, enum_type=enum_type)
+    
+        def new_object(self, type_fullname):
+            """Return a new object of given type fullname."""
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace(f"Creating new object of type '{type_fullname}'...")
+            if self.has_object_type(type_fullname):
+                if self.has_message_type(type_fullname):
+                    mt = self.get_message_type(type_fullname)
+                    res = mt()
+                else:
+                    raise TechnicalException(f"Unmanaged object creation for type fullname '{type_fullname}' (all managed types are logged at start with level DEBUG)")
             else:
-                attr_name, _ = self.__split_attribute_fullname(attr_name)
-                if len(attr_fullname) > 0:
-                    attr_fullname = attr_fullname + '.' + attr_name
-                    raise FunctionalException(f"Field '{attr_fullname}' doesn't exist in message type '{self.get_object_type_fullname(obj)}' (in sub-message type '{self.get_object_type_fullname(res)}', existing fields: {self.__get_object_descriptor_field_names(res, False)})")
+                raise TechnicalException(f"Unknown type fullname '{type_fullname}' (all known types are logged at start with level DEBUG)")
+            
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"New object of type '{type_fullname}' => {res}")
+            return res
+    
+        def new_message(self, message_type_fullname, fields_table=None, fields_dict=None, serialized_string=None):
+            """Return a new message of given message type fullname.
+            The content of the message can be filled from serialized string, or from field values in a Name/Value table.
+            """
+            res = self.new_object(message_type_fullname)
+            
+            if serialized_string is not None:
+                res.ParseFromString(serialized_string)
+            elif fields_table is not None:
+                if ValueTableManager.verify_table_is_name_value_table(fields_table, raise_exception=False):
+                    self.__set_object_fields_with_name_value_table(res, fields_table)
                 else:
-                    raise FunctionalException(f"Field '{attr_name}' doesn't exist in message type '{self.get_object_type_fullname(obj)}' (existing fields: {self.__get_object_descriptor_field_names(obj, False)})")
+                    raise TechnicalException(f"When defining parameter fields_table, it must be a Name/Value table")
+            elif fields_dict is not None:
+                self.__set_object_fields_with_dict(res, fields_dict)
             
-        return res
+            if Tools.do_log(logger, logging.DEBUG):
+                # logger.debug(f"New message of type '{message_type_fullname}' => {res}")
+                logger.debug(f"New message of type '{message_type_fullname}' => {Tools.represent_object(res)}")
+            return res
             
-    def set_object_field_value(self, obj, attribute_expression, value):
-        if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Setting protobuf object ({id(obj)}) field '{attribute_expression}' with value [{value}] (type: {Typing.get_object_class_fullname(value)})")
-        leaf_obj, leaf_attribute_expression, attr_last_name = self.__get_leaf_object_and_attribute_names(obj, attribute_expression, create_field=True)
+        def get_object_field_names(self, obj, recursive=False, uncollapse_repeated=False, add_repeated_index=False, with_unset=True, sort_order=SortOrder.Definition):
+            res = self.__get_object_field_names(obj, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, is_message_field=False, sort_order=sort_order)
+            # logger.trace(f"Object of type '{self.get_object_type_fullname(obj)}' has field names: {res}")
+            return res
             
-        # Set value
-        if self.__has_object_field(leaf_obj, field_fullname=attr_last_name):
-            self.__set_object_field(leaf_obj, field_fullname=attr_last_name, value=value, create_field=True)
-        else:
-            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"Field '{attr_last_name}' doesn't exist in type '{self.get_object_type_fullname(leaf_obj)}'")
-            attr_name, _ = self.__split_attribute_fullname(attr_last_name)
-            if leaf_attribute_expression is not None:
-                attr_fullname = leaf_attribute_expression + '.' + attr_name
-                raise FunctionalException(f"Field '{attr_fullname}' doesn't exist in object type '{self.get_object_type_fullname(obj)}' (in sub-message type '{self.get_object_type_fullname(leaf_obj)}', existing fields: {self.__get_object_descriptor_field_names(leaf_obj, False)})")
-            else:
-                raise FunctionalException(f"Field '{attr_name}' doesn't exist in object type '{self.get_object_type_fullname(obj)}' (existing fields: {self.__get_object_descriptor_field_names(obj, False)})")
+        def get_message_field_names(self, obj, recursive=False, uncollapse_repeated=False, add_repeated_index=False, with_unset=True):
+            res = self.__get_message_field_names(obj, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset)
+            # logger.trace(f"Message of type '{self.get_object_type_fullname(obj)}' has field names: {res}")
+            return res
             
-    def __get_leaf_object_and_attribute_names(self, obj, attribute_expression, create_field=False):
-        try:
-            leaf_attribute_expression, attr_last_name = attribute_expression.rsplit('.', 1)
-        except ValueError:
-            leaf_obj = obj
-            leaf_attribute_expression = None
-            attr_last_name = attribute_expression
-        else:
-            # Get "leaf" object (in object tree) containing the leaf attribute to set
-            leaf_obj = self.get_object_field_value(obj, leaf_attribute_expression, create_field=create_field)
-        return leaf_obj, leaf_attribute_expression, attr_last_name
-
-    def __get_object_field_names(self, obj, recursive=False, uncollapse_repeated=False, add_repeated_index=True, with_unset=True, prefix="", is_message_field=False, sort_order=SortOrder.Definition):
-        res = []
-        if uncollapse_repeated and ProtobufMessages.is_object_repeated(obj):
-            if add_repeated_index:
-                for index, value in enumerate(obj):
-                    new_prefix = f"{prefix}[{index}]"
+        def get_object_field_values(self, obj, attribute_expression):
+            """
+            Return a list of values for attribute names matching given expression.
+            Attribute name expression can contain "." for sub-fields, and "[]" to access all elements of the repeated field.
+            The list contains only one value unless a repeated field is included in attribute expression with suffix '[]'.
+            """ 
+            attr_names = attribute_expression.split('.')
+            res_list = [(obj, "")]
+            for attr_name in attr_names:
+                old_list = res_list
+                if attr_name.endswith("[]"):
+                    if len(old_list) > 1:
+                        raise TechnicalException("Uncollapse two different repeated fields in the same message is not managed.")
+                    cur_res = old_list[0][0]
+                    cur_fullname = old_list[0][1]
+                    real_attr_name = attr_name[:-2]
+                    
+                    cur_attr_fullname = cur_fullname + '.' + real_attr_name if len(cur_fullname) > 0 else real_attr_name
+                    if not hasattr(cur_res, real_attr_name):
+                        raise TechnicalException(f"Attribute '{cur_attr_fullname}' doesn't exist in object [{cur_res}]")
+                    
+                    res_list = []
+                    for index, attr_obj in enumerate(getattr(cur_res, real_attr_name)):
+                        new_attr_fullname = f"{cur_attr_fullname}[{index}]"
+                        res_list.append((attr_obj, new_attr_fullname))
+                else:
+                    res_list = []
+                    for obj, obj_attr_fullname in old_list:
+                        new_attr_fullname = f"{obj_attr_fullname}.{attr_name}"
+                        if self.__has_object_field(obj, field_name=attr_name):
+                            attr_obj = self.__get_object_field(obj, field_name=attr_name)
+                            res_list.append((attr_obj, new_attr_fullname))
+                        else:
+                            raise TechnicalException(f"Attribute '{new_attr_fullname}' doesn't exist in object [{obj}]")
+                        
+            return [obj for obj, _ in res_list]
+                
+        def has_object_field(self, obj, attribute_expression, create_field=False):
+            leaf_obj, _, attr_last_name = self.__get_leaf_object_and_attribute_names(obj, attribute_expression, create_field=create_field)
+            return self.__has_object_field(leaf_obj, field_fullname=attr_last_name)
+            
+        def get_object_field_value(self, obj, attribute_expression, create_field=False):
+            """
+            Return the value for attribute name matching given expression.
+            Attribute name expression can contain "." for sub-fields.
+            """ 
+            attr_names = attribute_expression.split('.')
+            res = obj
+            attr_fullname = ""
+            for attr_name in attr_names:
+                if self.__has_object_field(res, field_fullname=attr_name):
+                    res = self.__get_object_field(res, field_fullname=attr_name, create_field=create_field)
+                    attr_fullname = attr_fullname + '.' + attr_name if len(attr_fullname) > 0 else attr_name
+                else:
+                    attr_name, _ = self.__split_attribute_fullname(attr_name)
+                    if len(attr_fullname) > 0:
+                        attr_fullname = attr_fullname + '.' + attr_name
+                        raise FunctionalException(f"Field '{attr_fullname}' doesn't exist in message type '{self.get_object_type_fullname(obj)}' (in sub-message type '{self.get_object_type_fullname(res)}', existing fields: {self.__get_object_descriptor_field_names(res, False)})")
+                    else:
+                        raise FunctionalException(f"Field '{attr_name}' doesn't exist in message type '{self.get_object_type_fullname(obj)}' (existing fields: {self.__get_object_descriptor_field_names(obj, False)})")
+                
+            return res
+                
+        def set_object_field_value(self, obj, attribute_expression, value):
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Setting protobuf object ({id(obj)}) field '{attribute_expression}' with value [{value}] (type: {Typing.get_object_class_fullname(value)})")
+            leaf_obj, leaf_attribute_expression, attr_last_name = self.__get_leaf_object_and_attribute_names(obj, attribute_expression, create_field=True)
+                
+            # Set value
+            if self.__has_object_field(leaf_obj, field_fullname=attr_last_name):
+                self.__set_object_field(leaf_obj, field_fullname=attr_last_name, value=value, create_field=True)
+            else:
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"Field '{attr_last_name}' doesn't exist in type '{self.get_object_type_fullname(leaf_obj)}'")
+                attr_name, _ = self.__split_attribute_fullname(attr_last_name)
+                if leaf_attribute_expression is not None:
+                    attr_fullname = leaf_attribute_expression + '.' + attr_name
+                    raise FunctionalException(f"Field '{attr_fullname}' doesn't exist in object type '{self.get_object_type_fullname(obj)}' (in sub-message type '{self.get_object_type_fullname(leaf_obj)}', existing fields: {self.__get_object_descriptor_field_names(leaf_obj, False)})")
+                else:
+                    raise FunctionalException(f"Field '{attr_name}' doesn't exist in object type '{self.get_object_type_fullname(obj)}' (existing fields: {self.__get_object_descriptor_field_names(obj, False)})")
+                
+        def __get_leaf_object_and_attribute_names(self, obj, attribute_expression, create_field=False):
+            try:
+                leaf_attribute_expression, attr_last_name = attribute_expression.rsplit('.', 1)
+            except ValueError:
+                leaf_obj = obj
+                leaf_attribute_expression = None
+                attr_last_name = attribute_expression
+            else:
+                # Get "leaf" object (in object tree) containing the leaf attribute to set
+                leaf_obj = self.get_object_field_value(obj, leaf_attribute_expression, create_field=create_field)
+            return leaf_obj, leaf_attribute_expression, attr_last_name
+    
+        def __get_object_field_names(self, obj, recursive=False, uncollapse_repeated=False, add_repeated_index=True, with_unset=True, prefix="", is_message_field=False, sort_order=SortOrder.Definition):
+            res = []
+            if uncollapse_repeated and ProtobufMessages.is_object_repeated(obj):
+                if add_repeated_index:
+                    for index, value in enumerate(obj):
+                        new_prefix = f"{prefix}[{index}]"
+                        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                            logger.trace(f"Adding field names of repeated with prefix '{new_prefix}' (type: {Typing.get_object_class_fullname(value)})")
+                        res.extend(self.__get_object_field_names(value, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, prefix=new_prefix, is_message_field=is_message_field, sort_order=sort_order))
+                else:
+                    new_prefix = f"{prefix}[]"
+                    value = obj[0]
                     if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
                         logger.trace(f"Adding field names of repeated with prefix '{new_prefix}' (type: {Typing.get_object_class_fullname(value)})")
                     res.extend(self.__get_object_field_names(value, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, prefix=new_prefix, is_message_field=is_message_field, sort_order=sort_order))
-            else:
-                new_prefix = f"{prefix}[]"
-                value = obj[0]
+            elif (recursive or not is_message_field) and ProtobufMessages.is_object_map(obj):
+                sorted_dict = dict(sorted(obj.items()))
+                for key, value in sorted_dict.items():
+                    key_prefix = f"{prefix}[{key}]" if len(prefix) > 0 else key
+                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                        logger.trace(f"Adding field names of object of prefix '{key_prefix}' (type: {Typing.get_object_class_fullname(value)})")
+                    res.extend(self.__get_object_field_names(value, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, prefix=key_prefix, is_message_field=is_message_field))
+            elif (recursive or not is_message_field) and ProtobufMessages.is_object_message(obj):
                 if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                    logger.trace(f"Adding field names of repeated with prefix '{new_prefix}' (type: {Typing.get_object_class_fullname(value)})")
-                res.extend(self.__get_object_field_names(value, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, prefix=new_prefix, is_message_field=is_message_field, sort_order=sort_order))
-        elif (recursive or not is_message_field) and ProtobufMessages.is_object_map(obj):
-            sorted_dict = dict(sorted(obj.items()))
-            for key, value in sorted_dict.items():
-                key_prefix = f"{prefix}[{key}]" if len(prefix) > 0 else key
+                    logger.trace(f"Adding field names of message of prefix '{prefix}' (type: {Typing.get_object_class_fullname(obj)})")
+                res.extend(self.__get_message_field_names(obj, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, prefix=prefix, sort_order=sort_order))
+            elif len(prefix) > 0:
                 if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                    logger.trace(f"Adding field names of object of prefix '{key_prefix}' (type: {Typing.get_object_class_fullname(value)})")
-                res.extend(self.__get_object_field_names(value, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, prefix=key_prefix, is_message_field=is_message_field))
-        elif (recursive or not is_message_field) and ProtobufMessages.is_object_message(obj):
-            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"Adding field names of message of prefix '{prefix}' (type: {Typing.get_object_class_fullname(obj)})")
-            res.extend(self.__get_message_field_names(obj, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, prefix=prefix, sort_order=sort_order))
-        elif len(prefix) > 0:
-            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"Adding field name '{prefix}' (value type: {Typing.get_object_class_fullname(obj)})")
-            res.append(prefix)
-        else:
-            # logger.trace(f"Adding field name '{attr_name}' (value type: {Typing.get_object_class_fullname(attr_val)})")
-            raise TechnicalException(f"Object has no field and prefix is empty (object: {obj} ; type: {Typing.get_object_class_fullname(obj)})")
-        return res
-
-    def __get_message_field_names(self, obj, recursive=False, uncollapse_repeated=False, add_repeated_index=True, with_unset=True, prefix="", sort_order=SortOrder.Definition):
-        res = []
-        attribute_names = self.__get_object_descriptor_field_names(obj, sort_order=sort_order)
-        for attr_name in attribute_names:
-            attr_val = getattr(obj, attr_name)
-            new_prefix = f"{prefix + '.' if len(prefix) > 0 else ''}{attr_name}"
-            
-            # Skip field not set
-            if not with_unset:
-                set_status = self.__is_message_field_set(obj, attr_name)
-                if set_status == False:
-                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                        logger.trace(f"Hide unset field '{attr_name}' in object type '{self.get_object_type_fullname(obj)}' (field type: {Typing.get_object_class_fullname(attr_val)})")
-                    continue
-            
-            # Skip optional fields that are not set
-            if self.__is_message_field_optional(obj, attr_name):
-                set_status = self.__is_message_field_set(obj, attr_name)
-                if set_status == False:
-                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                        logger.trace(f"Hide unset optional field '{attr_name}' in object type '{self.get_object_type_fullname(obj)}' (field type: {Typing.get_object_class_fullname(attr_val)})")
-                    continue
-            
-            # Skip oneof field that is not set
-            if self.__is_message_field_oneof_field(obj, attr_name):
-                set_status = self.__is_message_field_set(obj, attr_name)
-                if set_status == False:
-                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                        logger.trace(f"Hide unset oneof field '{attr_name}' in object type '{self.get_object_type_fullname(obj)}' (field type: {Typing.get_object_class_fullname(attr_val)})")
-                    continue
-            
-            res.extend(self.__get_object_field_names(attr_val, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, prefix=new_prefix, is_message_field=True, sort_order=sort_order))
-        return res
-    
-    def __is_message_field_oneof_field(self, obj, field_name):
-        field_descr = self.__get_object_field_descriptor(obj, field_name)
-        res = (field_descr.label == FieldDescriptor.LABEL_OPTIONAL 
-               and field_descr.containing_oneof is not None
-               and field_descr.has_presence)
-        return res
-    
-    def __is_message_field_optional(self, obj, field_name):
-        field_descr = self.__get_object_field_descriptor(obj, field_name)
-        res = (field_descr.label == FieldDescriptor.LABEL_OPTIONAL 
-               and field_descr.containing_oneof is not None and len(field_descr.containing_oneof.fields) == 1
-               and field_descr.has_presence)
-        return res
-    
-    def __is_message_field_repeated(self, obj, field_name):
-        field_descr = self.__get_object_field_descriptor(obj, field_name)
-        return (field_descr.label == FieldDescriptor.LABEL_REPEATED)
-    
-    def __is_message_field_required(self, obj, field_name):
-        field_descr = self.__get_object_field_descriptor(obj, field_name)
-        return (field_descr.label == FieldDescriptor.LABEL_REQUIRED)
-    
-    def __is_message_field_set(self, obj, field_name):
-        """
-        If field can distinguish between unpopulated and default values, return if field is set, else return None.
-        """
-        try:
-            return obj.HasField(field_name)
-        except ValueError:
-            # logger.trace(f"Field '{field_name}' is not optional. Got error: {exc}")
-            return None
+                    logger.trace(f"Adding field name '{prefix}' (value type: {Typing.get_object_class_fullname(obj)})")
+                res.append(prefix)
+            else:
+                # logger.trace(f"Adding field name '{attr_name}' (value type: {Typing.get_object_class_fullname(attr_val)})")
+                raise TechnicalException(f"Object has no field and prefix is empty (object: {obj} ; type: {Typing.get_object_class_fullname(obj)})")
+            return res
+    
+        def __get_message_field_names(self, obj, recursive=False, uncollapse_repeated=False, add_repeated_index=True, with_unset=True, prefix="", sort_order=SortOrder.Definition):
+            res = []
+            attribute_names = self.__get_object_descriptor_field_names(obj, sort_order=sort_order)
+            for attr_name in attribute_names:
+                attr_val = getattr(obj, attr_name)
+                new_prefix = f"{prefix + '.' if len(prefix) > 0 else ''}{attr_name}"
+                
+                # Skip field not set
+                if not with_unset:
+                    set_status = self.__is_message_field_set(obj, attr_name)
+                    if set_status == False:
+                        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                            logger.trace(f"Hide unset field '{attr_name}' in object type '{self.get_object_type_fullname(obj)}' (field type: {Typing.get_object_class_fullname(attr_val)})")
+                        continue
+                
+                # Skip optional fields that are not set
+                if self.__is_message_field_optional(obj, attr_name):
+                    set_status = self.__is_message_field_set(obj, attr_name)
+                    if set_status == False:
+                        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                            logger.trace(f"Hide unset optional field '{attr_name}' in object type '{self.get_object_type_fullname(obj)}' (field type: {Typing.get_object_class_fullname(attr_val)})")
+                        continue
+                
+                # Skip oneof field that is not set
+                if self.__is_message_field_oneof_field(obj, attr_name):
+                    set_status = self.__is_message_field_set(obj, attr_name)
+                    if set_status == False:
+                        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                            logger.trace(f"Hide unset oneof field '{attr_name}' in object type '{self.get_object_type_fullname(obj)}' (field type: {Typing.get_object_class_fullname(attr_val)})")
+                        continue
+                
+                res.extend(self.__get_object_field_names(attr_val, recursive=recursive, uncollapse_repeated=uncollapse_repeated, add_repeated_index=add_repeated_index, with_unset=with_unset, prefix=new_prefix, is_message_field=True, sort_order=sort_order))
+            return res
+        
+        def __is_message_field_oneof_field(self, obj, field_name):
+            field_descr = self.__get_object_field_descriptor(obj, field_name)
+            res = (field_descr.label == FieldDescriptor.LABEL_OPTIONAL 
+                   and field_descr.containing_oneof is not None
+                   and field_descr.has_presence)
+            return res
         
-    def __get_object_descriptor_field_names(self, obj, raise_exception=True, sort_order=SortOrder.Definition):
-        #TODO EKL: manage oneof fields => return only the name of the oneof field that is defined 
-        if hasattr(obj, 'DESCRIPTOR'):
-            descriptor = getattr(obj, 'DESCRIPTOR')
-            # TODO: When it will be possible with python generated code, remove from result the deprecated fields
-            # logger.info(f"+++++++++++++ descriptor: {self.__represent_descriptor(descriptor)}")
-            res = [f.name for f in descriptor.fields if not hasattr(f, "isDeprecated")]
-            if sort_order == SortOrder.Alphabetic:
-                res.sort()
+        def __is_message_field_optional(self, obj, field_name):
+            field_descr = self.__get_object_field_descriptor(obj, field_name)
+            res = (field_descr.label == FieldDescriptor.LABEL_OPTIONAL 
+                   and field_descr.containing_oneof is not None and len(field_descr.containing_oneof.fields) == 1
+                   and field_descr.has_presence)
             return res
-        else:
-            # return Typing.get_object_attribute_names(obj)
-            if raise_exception:
+        
+        def __is_message_field_repeated(self, obj, field_name):
+            field_descr = self.__get_object_field_descriptor(obj, field_name)
+            return (field_descr.label == FieldDescriptor.LABEL_REPEATED)
+        
+        def __is_message_field_required(self, obj, field_name):
+            field_descr = self.__get_object_field_descriptor(obj, field_name)
+            return (field_descr.label == FieldDescriptor.LABEL_REQUIRED)
+        
+        def __is_message_field_set(self, obj, field_name):
+            """
+            If field can distinguish between unpopulated and default values, return if field is set, else return None.
+            """
+            try:
+                return obj.HasField(field_name)
+            except ValueError:
+                # logger.trace(f"Field '{field_name}' is not optional. Got error: {exc}")
+                return None
+            
+        def __get_object_descriptor_field_names(self, obj, raise_exception=True, sort_order=SortOrder.Definition):
+            #TODO EKL: manage oneof fields => return only the name of the oneof field that is defined 
+            if hasattr(obj, 'DESCRIPTOR'):
+                descriptor = getattr(obj, 'DESCRIPTOR')
+                # TODO: When it will be possible with python generated code, remove from result the deprecated fields
+                # logger.info(f"+++++++++++++ descriptor: {self.__represent_descriptor(descriptor)}")
+                res = [f.name for f in descriptor.fields if not hasattr(f, "isDeprecated")]
+                if sort_order == SortOrder.Alphabetic:
+                    res.sort()
+                return res
+            else:
+                # return Typing.get_object_attribute_names(obj)
+                if raise_exception:
+                    raise TechnicalException(f"Not found attribute 'DESCRIPTOR' in object of type '{self.get_object_type_fullname(obj)}' [{obj}]")
+                else:
+                    return []
+                
+        def __get_object_field_descriptor(self, obj, field_name):
+            if hasattr(obj, 'DESCRIPTOR'):
+                descriptor = getattr(obj, 'DESCRIPTOR')
+                if field_name in descriptor.fields_by_name:
+                    return descriptor.fields_by_name[field_name]
+                else:
+                    raise FunctionalException(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}'")
+            else:
                 raise TechnicalException(f"Not found attribute 'DESCRIPTOR' in object of type '{self.get_object_type_fullname(obj)}' [{obj}]")
+                
+        def __has_object_field(self, obj, field_name=None, field_fullname=None):
+            param_in_brackets = None
+            if field_name is None:
+                field_name, param_in_brackets = self.__split_attribute_fullname(field_fullname)
+                
+            if len(field_name) == 0:
+                # Manage field_fullname in format "[XXX]"
+                if param_in_brackets is not None:
+                    if self.is_object_repeated(obj):
+                        if Converter.is_integer(param_in_brackets):
+                            li_index = int(param_in_brackets)
+                            res = li_index < len(obj)
+                        else:
+                            raise FunctionalException(f"For repeated objects, the parameter in brackets must be an integer (field fullname: '{field_fullname}')")
+                    elif self.is_object_map(obj):
+                        res = param_in_brackets in obj
+                        # if not res:
+                        #     logger.trace(f"++++++ Key '{param_in_brackets}' in not in map {obj}")
+                    else:
+                        raise TechnicalException(f"Unexpected brackets in field fullname '{field_fullname}' for object of type '{self.get_object_type_fullname(obj)}'")
+                else:
+                    raise TechnicalException(f"Unexpected field " + f"fullname '{field_fullname}'" if field_fullname is not None else f"name '{field_name}'")
+            elif self.is_object_map(obj):
+                res = field_name in obj
             else:
-                return []
+                res = field_name in self.__get_object_descriptor_field_names(obj, False)
+                
+            if not res:
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}' (existing fields: {self.__get_object_descriptor_field_names(obj, False)})")
+            return res
+        
+        def __get_object_field_type_fullname(self, obj, field_name):
+            if not self.__has_object_field(obj, field_name):
+                raise FunctionalException()
             
-    def __get_object_field_descriptor(self, obj, field_name):
-        if hasattr(obj, 'DESCRIPTOR'):
-            descriptor = getattr(obj, 'DESCRIPTOR')
-            if field_name in descriptor.fields_by_name:
-                return descriptor.fields_by_name[field_name]
+            field_descr = self.__get_object_field_descriptor(obj, field_name)
+            if field_descr.message_type:
+                return self.get_object_type_fullname(descriptor=field_descr.message_type)
+            elif field_descr.enum_type:
+                return self.get_object_type_fullname(descriptor=field_descr.enum_type)
             else:
-                raise FunctionalException(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}'")
-        else:
-            raise TechnicalException(f"Not found attribute 'DESCRIPTOR' in object of type '{self.get_object_type_fullname(obj)}' [{obj}]")
-            
-    def __has_object_field(self, obj, field_name=None, field_fullname=None):
-        param_in_brackets = None
-        if field_name is None:
-            field_name, param_in_brackets = self.__split_attribute_fullname(field_fullname)
+                return field_descr.type
+        
+        def __get_object_field(self, obj, field_name=None, field_fullname=None, create_field=False):
+            param_in_brackets = None
+            if field_name is None:
+                field_name, param_in_brackets = self.__split_attribute_fullname(field_fullname)
             
-        if len(field_name) == 0:
-            # Manage field_fullname in format "[XXX]"
-            if param_in_brackets is not None:
-                if self.is_object_repeated(obj):
-                    if Converter.is_integer(param_in_brackets):
-                        li_index = int(param_in_brackets)
-                        res = li_index < len(obj)
+            if len(field_name) == 0:
+                # Manage field_fullname in format "[XXX]"
+                if param_in_brackets is not None:
+                    if self.is_object_repeated(obj):
+                        if Converter.is_integer(param_in_brackets):
+                            li_index = int(param_in_brackets)
+                            res = self.__get_object_repeated_by_index(obj, li_index, add_index=create_field)
+                        else:
+                            raise FunctionalException(f"For repeated objects, the parameter in brackets must be an integer (field fullname: '{field_fullname}')")
+                    elif self.is_object_map(obj):
+                        res = obj[param_in_brackets]
                     else:
-                        raise FunctionalException(f"For repeated objects, the parameter in brackets must be an integer (field fullname: '{field_fullname}')")
-                elif self.is_object_map(obj):
-                    res = param_in_brackets in obj
-                    # if not res:
-                    #     logger.trace(f"++++++ Key '{param_in_brackets}' in not in map {obj}")
+                        raise TechnicalException(f"Unexpected brackets in field fullname '{field_fullname}' for object of type '{self.get_object_type_fullname(obj)}'")
                 else:
-                    raise TechnicalException(f"Unexpected brackets in field fullname '{field_fullname}' for object of type '{self.get_object_type_fullname(obj)}'")
-            else:
-                raise TechnicalException(f"Unexpected field " + f"fullname '{field_fullname}'" if field_fullname is not None else f"name '{field_name}'")
-        elif self.is_object_map(obj):
-            res = field_name in obj
-        else:
-            res = field_name in self.__get_object_descriptor_field_names(obj, False)
+                    raise TechnicalException(f"Unexpected field " + f"fullname '{field_fullname}'" if field_fullname is not None else f"name '{field_name}'")
             
-        if not res:
-            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}' (existing fields: {self.__get_object_descriptor_field_names(obj, False)})")
-        return res
-    
-    def __get_object_field_type_fullname(self, obj, field_name):
-        if not self.__has_object_field(obj, field_name):
-            raise FunctionalException()
-        
-        field_descr = self.__get_object_field_descriptor(obj, field_name)
-        if field_descr.message_type:
-            return self.get_object_type_fullname(descriptor=field_descr.message_type)
-        elif field_descr.enum_type:
-            return self.get_object_type_fullname(descriptor=field_descr.enum_type)
-        else:
-            return field_descr.type
-    
-    def __get_object_field(self, obj, field_name=None, field_fullname=None, create_field=False):
-        param_in_brackets = None
-        if field_name is None:
-            field_name, param_in_brackets = self.__split_attribute_fullname(field_fullname)
-        
-        if len(field_name) == 0:
-            # Manage field_fullname in format "[XXX]"
-            if param_in_brackets is not None:
-                if self.is_object_repeated(obj):
+            elif self.is_object_map(obj):
+                res = obj[field_name]
+                
+            elif hasattr(obj, field_name):
+                if param_in_brackets is not None:
                     if Converter.is_integer(param_in_brackets):
                         li_index = int(param_in_brackets)
-                        res = self.__get_object_repeated_by_index(obj, li_index, add_index=create_field)
+                        res = self.__get_object_repeated_field_by_index(obj, field_name, li_index, add_index=create_field)
                     else:
-                        raise FunctionalException(f"For repeated objects, the parameter in brackets must be an integer (field fullname: '{field_fullname}')")
-                elif self.is_object_map(obj):
-                    res = obj[param_in_brackets]
+                        res = getattr(obj, field_name)[param_in_brackets]
                 else:
-                    raise TechnicalException(f"Unexpected brackets in field fullname '{field_fullname}' for object of type '{self.get_object_type_fullname(obj)}'")
+                    res = getattr(obj, field_name)
+                
+                # Manage enum
+                res = self.__get_enum_name_if_field_is_enum(res, obj=obj, field_name=field_name)
+                
+            elif self.__has_object_field(obj, field_name=field_name):
+                if create_field:
+                    field_type_fullname = self.__get_object_field_type_fullname(obj, field_name)
+                    if isinstance(field_type_fullname, int):
+                        raise TechnicalException("Unexpected case: the native types are expected to exist in object")
+                    res = self.new_object(field_type_fullname)
+                    setattr(obj, field_name, res)
+                else:
+                    raise FunctionalException(f"Field '{field_name}' exists in type '{self.get_object_type_fullname(obj)}' but not in instance [{obj}]")
             else:
-                raise TechnicalException(f"Unexpected field " + f"fullname '{field_fullname}'" if field_fullname is not None else f"name '{field_name}'")
+                raise FunctionalException(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}'")
+    
+            return res
         
-        elif self.is_object_map(obj):
-            res = obj[field_name]
+        def __get_object_repeated_by_index(self, obj, index, add_index=False):
+            if not ProtobufMessages.is_object_repeated(obj):
+                raise FunctionalException(f"Object of type '{self.get_object_type_fullname(obj)}' is not a repeated")
             
-        elif hasattr(obj, field_name):
-            if param_in_brackets is not None:
-                if Converter.is_integer(param_in_brackets):
-                    li_index = int(param_in_brackets)
-                    res = self.__get_object_repeated_field_by_index(obj, field_name, li_index, add_index=create_field)
+            # Add repeated element if it doesn't exist
+            if len(obj) < index + 1:
+                if add_index:
+                    for _ in range(index + 1 - len(obj)):
+                        res = obj.add()
                 else:
-                    res = getattr(obj, field_name)[param_in_brackets]
-            else:
-                res = getattr(obj, field_name)
-            
-            # Manage enum
-            res = self.__get_enum_name_if_field_is_enum(res, obj=obj, field_name=field_name)
-            
-        elif self.__has_object_field(obj, field_name=field_name):
-            if create_field:
-                field_type_fullname = self.__get_object_field_type_fullname(obj, field_name)
-                if isinstance(field_type_fullname, int):
-                    raise TechnicalException("Unexpected case: the native types are expected to exist in object")
-                res = self.new_object(field_type_fullname)
-                setattr(obj, field_name, res)
+                    raise FunctionalException(f"Index {index} exceeds repeated length {len(obj)}")
             else:
-                raise FunctionalException(f"Field '{field_name}' exists in type '{self.get_object_type_fullname(obj)}' but not in instance [{obj}]")
-        else:
-            raise FunctionalException(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}'")
-
-        return res
-    
-    def __get_object_repeated_by_index(self, obj, index, add_index=False):
-        if not ProtobufMessages.is_object_repeated(obj):
-            raise FunctionalException(f"Object of type '{self.get_object_type_fullname(obj)}' is not a repeated")
+                res = obj[index]
+                
+            return res
         
-        # Add repeated element if it doesn't exist
-        if len(obj) < index + 1:
-            if add_index:
-                for _ in range(index + 1 - len(obj)):
-                    res = obj.add()
-            else:
-                raise FunctionalException(f"Index {index} exceeds repeated length {len(obj)}")
-        else:
-            res = obj[index]
+        def __get_object_repeated_field_by_index(self, obj, field_name, index, add_index=False):
+            field_obj = getattr(obj, field_name)
+            if not ProtobufMessages.is_object_repeated(field_obj):
+                raise FunctionalException(f"Field '{field_name}' is not a repeated in type '{self.get_object_type_fullname(obj)}'")
+            if len(field_obj) < index + 1 and not add_index:
+                raise FunctionalException(f"Index {index} exceeds repeated length {len(field_obj)} (field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])")
             
-        return res
-    
-    def __get_object_repeated_field_by_index(self, obj, field_name, index, add_index=False):
-        field_obj = getattr(obj, field_name)
-        if not ProtobufMessages.is_object_repeated(field_obj):
-            raise FunctionalException(f"Field '{field_name}' is not a repeated in type '{self.get_object_type_fullname(obj)}'")
-        if len(field_obj) < index + 1 and not add_index:
-            raise FunctionalException(f"Index {index} exceeds repeated length {len(field_obj)} (field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])")
+            return self.__get_object_repeated_by_index(field_obj, index, add_index)
         
-        return self.__get_object_repeated_by_index(field_obj, index, add_index)
+        def get_object_type_fullname(self, obj=None, obj_class=None, descriptor=None):
+            # None type
+            if obj is None and obj_class is None and descriptor is None:
+                return None.__class__.__name__
     
-    def get_object_type_fullname(self, obj=None, obj_class=None, descriptor=None):
-        # None type
-        if obj is None and obj_class is None and descriptor is None:
-            return None.__class__.__name__
-
-        # Object -> object class
-        if obj is not None:
-            return self.get_object_type_fullname(obj_class=type(obj))
-
-        # Object class -> object class descriptor
-        if hasattr(obj_class, 'DESCRIPTOR'):
-            return self.get_object_type_fullname(descriptor=obj_class.DESCRIPTOR)
-        
-        # Extract information from descriptor
-        if descriptor:
-            if hasattr(descriptor, 'full_name'):
-                return descriptor.full_name
-            elif descriptor.containing_type is not None:
-                containing_fullname = self.get_object_type_fullname(obj_class=descriptor.containing_type)
-                return containing_fullname + '.' + descriptor.name
-            else:
-                raise TechnicalException(f"Failed to extract type fullname from descriptor: {self.__represent_descriptor(descriptor)}")
+            # Object -> object class
+            if obj is not None:
+                return self.get_object_type_fullname(obj_class=type(obj))
+    
+            # Object class -> object class descriptor
+            if hasattr(obj_class, 'DESCRIPTOR'):
+                return self.get_object_type_fullname(descriptor=obj_class.DESCRIPTOR)
             
-        # Extract information from classzhDM
-        if obj_class.__module__.endswith('_pb2'):
-            package_name = os.path.splitext(obj_class.__module__)[0]
-            return package_name + '.' + obj_class.__name__
-        else:
-            return obj_class.__module__ + '.' + obj_class.__name__
-
-    def __set_object_fields_with_name_value_table(self, obj, table):
-        # Verify table structure
-        ValueTableManager.verify_table_is_name_value_table(table)
-        
-        for row in table.rows:
-            if row.get_cell(1).value_type not in [ValueTypes.NotApplicable]:
-                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                    logger.trace(f"Setting protobuf object field with row ({row})")
-                
-                name = row.get_cell(0).value
-                value = row.get_cell(1).value
-                
-                self.set_object_field_value(obj, name, value)
+            # Extract information from descriptor
+            if descriptor:
+                if hasattr(descriptor, 'full_name'):
+                    return descriptor.full_name
+                elif descriptor.containing_type is not None:
+                    containing_fullname = self.get_object_type_fullname(obj_class=descriptor.containing_type)
+                    return containing_fullname + '.' + descriptor.name
+                else:
+                    raise TechnicalException(f"Failed to extract type fullname from descriptor: {self.__represent_descriptor(descriptor)}")
                 
-    def __set_object_fields_with_dict(self, obj, values_dict):
-        for name, value in values_dict.items():
-            self.set_object_field_value(obj, name, value)
+            # Extract information from classzhDM
+            if obj_class.__module__.endswith('_pb2'):
+                package_name = os.path.splitext(obj_class.__module__)[0]
+                return package_name + '.' + obj_class.__name__
+            else:
+                return obj_class.__module__ + '.' + obj_class.__name__
     
-    def __check_field_value_to_set_is_valid(self, value):
-        if value is undefined_argument or value is undefined_value:
-            raise ValueError(f"Special objects undefined_* are not valid field values")
-        
-    def __set_object_field(self, obj, field_name=None, field_fullname=None, value=None, create_field=False):
-        in_brackets_str = None
-        if field_name is None:
-            field_name, in_brackets_str = self.__split_attribute_fullname(field_fullname)
-        if not self.__has_object_field(obj, field_name):
-            raise TechnicalException(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}'")
-        self.__check_field_value_to_set_is_valid(value)
+        def __set_object_fields_with_name_value_table(self, obj, table):
+            # Verify table structure
+            ValueTableManager.verify_table_is_name_value_table(table)
+            
+            for row in table.rows:
+                if row.get_cell(1).value_type not in [ValueTypes.NotApplicable]:
+                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                        logger.trace(f"Setting protobuf object field with row ({row})")
+                    
+                    name = row.get_cell(0).value
+                    value = row.get_cell(1).value
+                    
+                    self.set_object_field_value(obj, name, value)
+                    
+        def __set_object_fields_with_dict(self, obj, values_dict):
+            for name, value in values_dict.items():
+                self.set_object_field_value(obj, name, value)
         
-        try:
-            if hasattr(obj, field_name):
-                if in_brackets_str is not None:
-                    from holado_test.scenario.step_tools import StepTools
-                    in_brackets_obj = StepTools.evaluate_scenario_parameter(in_brackets_str)
-                    if isinstance(in_brackets_obj, int):
-                        li_index = in_brackets_obj
-                        self.__set_object_repeated_field_by_index(obj, field_name, li_index, value, add_index=create_field)
-                    else:
+        def __check_field_value_to_set_is_valid(self, value):
+            if value is undefined_argument or value is undefined_value:
+                raise ValueError(f"Special objects undefined_* are not valid field values")
+            
+        def __set_object_field(self, obj, field_name=None, field_fullname=None, value=None, create_field=False):
+            in_brackets_str = None
+            if field_name is None:
+                field_name, in_brackets_str = self.__split_attribute_fullname(field_fullname)
+            if not self.__has_object_field(obj, field_name):
+                raise TechnicalException(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}'")
+            self.__check_field_value_to_set_is_valid(value)
+            
+            try:
+                if hasattr(obj, field_name):
+                    if in_brackets_str is not None:
+                        from holado_test.scenario.step_tools import StepTools
+                        in_brackets_obj = StepTools.evaluate_scenario_parameter(in_brackets_str)
+                        if isinstance(in_brackets_obj, int):
+                            li_index = in_brackets_obj
+                            self.__set_object_repeated_field_by_index(obj, field_name, li_index, value, add_index=create_field)
+                        else:
+                            field_obj = getattr(obj, field_name)
+                            field_obj[in_brackets_obj] = value
+                    elif self.is_object_map(getattr(obj, field_name)):
                         field_obj = getattr(obj, field_name)
-                        field_obj[in_brackets_obj] = value
-                elif self.is_object_map(getattr(obj, field_name)):
-                    field_obj = getattr(obj, field_name)
-                    for key in value:
-                        field_obj[key] = value[key]
-                elif self.is_object_repeated(getattr(obj, field_name)):
-                    self.__set_object_repeated_field(obj, field_name, value, add_index=True)
-                else:
-                    field_type_fullname = self.__get_object_field_type_fullname(obj, field_name)
-                    if isinstance(field_type_fullname, int):
-                        self.__set_object_field_attr(obj, field_name, value)
+                        for key in value:
+                            field_obj[key] = value[key]
+                    elif self.is_object_repeated(getattr(obj, field_name)):
+                        self.__set_object_repeated_field(obj, field_name, value, add_index=True)
                     else:
-                        field_descr = self.__get_object_field_descriptor(obj, field_name)
-                        # logger.trace(f"+++++ Setting field '{field_name}' of descriptor: {self.__represent_descriptor(field_descr)}")
-                        if field_descr.enum_type is not None:
-                            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                                logger.trace(f"Setting enum field '{field_name}' (type: {field_type_fullname}) with value [{value}] (type: {Typing.get_object_class_fullname(value)})")
-                            enum_value = self.__get_enum_value(value, enum_type_descriptor=field_descr.enum_type)
-                            self.__set_object_field_attr(obj, field_name, enum_value)
+                        field_type_fullname = self.__get_object_field_type_fullname(obj, field_name)
+                        if isinstance(field_type_fullname, int):
+                            self.__set_object_field_attr(obj, field_name, value)
                         else:
-                            field_obj = getattr(obj, field_name)
-                            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                                logger.trace(f"Setting field '{field_name}' (type: {field_type_fullname}) with value [{value}] (type: {Typing.get_object_class_fullname(value)})")
+                            field_descr = self.__get_object_field_descriptor(obj, field_name)
+                            # logger.trace(f"+++++ Setting field '{field_name}' of descriptor: {self.__represent_descriptor(field_descr)}")
+                            if field_descr.enum_type is not None:
+                                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                                    logger.trace(f"Setting enum field '{field_name}' (type: {field_type_fullname}) with value [{value}] (type: {Typing.get_object_class_fullname(value)})")
+                                enum_value = self.__get_enum_value(value, enum_type_descriptor=field_descr.enum_type)
+                                self.__set_object_field_attr(obj, field_name, enum_value)
+                            else:
+                                field_obj = getattr(obj, field_name)
+                                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                                    logger.trace(f"Setting field '{field_name}' (type: {field_type_fullname}) with value [{value}] (type: {Typing.get_object_class_fullname(value)})")
+                                try:
+                                    self.__set_object_value(field_obj, value)
+                                except HAException as exc:
+                                    raise TechnicalException(f"Unmanaged set of value [{value}] (type: {Typing.get_object_class_fullname(value)}) in field of type '{field_type_fullname}' (field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])\n  -> {exc.message}") from exc
+                                except Exception as exc:
+                                    raise TechnicalException(f"Unmanaged set of value [{value}] (type: {Typing.get_object_class_fullname(value)}) in field of type '{field_type_fullname}' (field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])\n  -> {str(exc)}") from exc
+                elif self.__has_object_field(obj, field_name=field_name):
+                    if create_field:
+                        field_type_fullname = self.__get_object_field_type_fullname(obj, field_name)
+                        if isinstance(field_type_fullname, int):
+                            self.__set_object_field_attr(obj, field_name, value)
+                        else:
+                            res = self.new_object(field_type_fullname)
                             try:
-                                self.__set_object_value(field_obj, value)
-                            except HAException as exc:
-                                raise TechnicalException(f"Unmanaged set of value [{value}] (type: {Typing.get_object_class_fullname(value)}) in field of type '{field_type_fullname}' (field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])\n  -> {exc.message}") from exc
+                                self.__set_object_value(res, value)
                             except Exception as exc:
-                                raise TechnicalException(f"Unmanaged set of value [{value}] (type: {Typing.get_object_class_fullname(value)}) in field of type '{field_type_fullname}' (field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])\n  -> {str(exc)}") from exc
-            elif self.__has_object_field(obj, field_name=field_name):
-                if create_field:
-                    field_type_fullname = self.__get_object_field_type_fullname(obj, field_name)
-                    if isinstance(field_type_fullname, int):
-                        self.__set_object_field_attr(obj, field_name, value)
+                                raise TechnicalException(f"Unmanaged set of value [{value}] (type: {Typing.get_object_class_fullname(value)}) in field of type '{field_type_fullname}' (field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])\n  -> {exc.message}") from exc
+                            setattr(obj, field_name, res)
                     else:
-                        res = self.new_object(field_type_fullname)
-                        try:
-                            self.__set_object_value(res, value)
-                        except Exception as exc:
-                            raise TechnicalException(f"Unmanaged set of value [{value}] (type: {Typing.get_object_class_fullname(value)}) in field of type '{field_type_fullname}' (field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])\n  -> {exc.message}") from exc
-                        setattr(obj, field_name, res)
+                        raise FunctionalException(f"Field '{field_name}' exists in type '{self.get_object_type_fullname(obj)}' but not in instance [{obj}]")
                 else:
-                    raise FunctionalException(f"Field '{field_name}' exists in type '{self.get_object_type_fullname(obj)}' but not in instance [{obj}]")
+                    raise FunctionalException(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}'")
+            except (FunctionalException, TechnicalException):
+                raise
+            except Exception as exc:
+                if hasattr(obj, field_name):
+                    field_obj = getattr(obj, field_name)
+                    raise TechnicalException(f"Failed to set field '{field_name}' (type: '{Typing.get_object_class_fullname(field_obj)}') with value [{value}] (type '{Typing.get_object_class_fullname(value)}')") from exc
+                else:
+                    raise TechnicalException(f"Failed to set field '{field_name}' (type: Unknown) with value [{value}] (type '{Typing.get_object_class_fullname(value)}')") from exc
+                    
+        def __set_object_field_attr(self, obj, field_name, value):
+            if value is None:
+                obj.ClearField(field_name)
             else:
-                raise FunctionalException(f"Field '{field_name}' doesn't exist in type '{self.get_object_type_fullname(obj)}'")
-        except (FunctionalException, TechnicalException):
-            raise
-        except Exception as exc:
-            if hasattr(obj, field_name):
-                field_obj = getattr(obj, field_name)
-                raise TechnicalException(f"Failed to set field '{field_name}' (type: '{Typing.get_object_class_fullname(field_obj)}') with value [{value}] (type '{Typing.get_object_class_fullname(value)}')") from exc
+                setattr(obj, field_name, value)
+    
+        def __get_enum_name_if_field_is_enum(self, value, field_descriptor=None, obj=None, field_name=None):
+            if field_descriptor is None:
+                field_descriptor = self.__get_object_field_descriptor(obj, field_name)
+            if field_descriptor.enum_type is not None:
+                enum_name = self.__get_enum_name(value, enum_type_descriptor=field_descriptor.enum_type)
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"Getting enum field '{field_descriptor.name}' (type: {field_descriptor.enum_type} ; full_name: {field_descriptor.full_name}): value [{value}] -> name [{enum_name}]")
+                return enum_name
             else:
-                raise TechnicalException(f"Failed to set field '{field_name}' (type: Unknown) with value [{value}] (type '{Typing.get_object_class_fullname(value)}')") from exc
+                return value
+    
+        def __get_enum_name(self, name_or_value, enum_type=None, enum_type_descriptor=None):
+            if enum_type is None and enum_type_descriptor is None:
+                raise TechnicalException(f"Parameter 'enum_type' or 'enum_type_descriptor' must be defined")
+            if enum_type is not None:
+                enum_type_descriptor = enum_type.DESCRIPTOR
                 
-    def __set_object_field_attr(self, obj, field_name, value):
-        if value is None:
-            obj.ClearField(field_name)
-        else:
-            setattr(obj, field_name, value)
-
-    def __get_enum_name_if_field_is_enum(self, value, field_descriptor=None, obj=None, field_name=None):
-        if field_descriptor is None:
-            field_descriptor = self.__get_object_field_descriptor(obj, field_name)
-        if field_descriptor.enum_type is not None:
-            enum_name = self.__get_enum_name(value, enum_type_descriptor=field_descriptor.enum_type)
-            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"Getting enum field '{field_descriptor.name}' (type: {field_descriptor.enum_type} ; full_name: {field_descriptor.full_name}): value [{value}] -> name [{enum_name}]")
-            return enum_name
-        else:
-            return value
-
-    def __get_enum_name(self, name_or_value, enum_type=None, enum_type_descriptor=None):
-        if enum_type is None and enum_type_descriptor is None:
-            raise TechnicalException(f"Parameter 'enum_type' or 'enum_type_descriptor' must be defined")
-        if enum_type is not None:
-            enum_type_descriptor = enum_type.DESCRIPTOR
-            
-        if isinstance(name_or_value, str):
-            return name_or_value
-        elif isinstance(name_or_value, int):
-            if name_or_value in enum_type_descriptor.values_by_number:
-                return self.__get_enum_name_for_value(enum_type_descriptor, name_or_value)
+            if isinstance(name_or_value, str):
+                return name_or_value
+            elif isinstance(name_or_value, int):
+                if name_or_value in enum_type_descriptor.values_by_number:
+                    return self.__get_enum_name_for_value(enum_type_descriptor, name_or_value)
+                else:
+                    raise FunctionalException(f"Enum type '{enum_type_descriptor.full_name}' has no value '{name_or_value}' (possible values: {[k for k in enum_type_descriptor.values_by_number]})")
+            elif self.is_object_repeated(name_or_value):
+                return [self.__get_enum_name(v, enum_type_descriptor=enum_type_descriptor) for v in name_or_value]
             else:
-                raise FunctionalException(f"Enum type '{enum_type_descriptor.full_name}' has no value '{name_or_value}' (possible values: {[k for k in enum_type_descriptor.values_by_number]})")
-        elif self.is_object_repeated(name_or_value):
-            return [self.__get_enum_name(v, enum_type_descriptor=enum_type_descriptor) for v in name_or_value]
-        else:
-            raise TechnicalException(f"Unexpected value type '{Typing.get_object_class_fullname(name_or_value)}'")
-    
-    def __get_enum_name_for_value(self, enum_type_descriptor, value):
-        enum_type_fullname = self.get_object_type_fullname(descriptor=enum_type_descriptor)
-        if not enum_type_fullname in self.__enum_data_by_fullname:
-            self.__load_enum_data(enum_type_fullname, enum_type_descriptor)
-        return self.__enum_data_by_fullname[enum_type_fullname].values_by_number[value].name
+                raise TechnicalException(f"Unexpected value type '{Typing.get_object_class_fullname(name_or_value)}'")
         
-    def __get_enum_value(self, name_or_value, enum_type=None, enum_type_descriptor=None):
-        if enum_type is None and enum_type_descriptor is None:
-            raise TechnicalException(f"Parameter 'enum_type' or 'enum_type_descriptor' must be defined")
-        if enum_type is not None:
-            enum_type_descriptor = enum_type.DESCRIPTOR
+        def __get_enum_name_for_value(self, enum_type_descriptor, value):
+            enum_type_fullname = self.get_object_type_fullname(descriptor=enum_type_descriptor)
+            if not enum_type_fullname in self.__enum_data_by_fullname:
+                self.__load_enum_data(enum_type_fullname, enum_type_descriptor)
+            return self.__enum_data_by_fullname[enum_type_fullname].values_by_number[value].name
             
-        if isinstance(name_or_value, str):
-            if name_or_value in enum_type_descriptor.values_by_name:
-                return enum_type_descriptor.values_by_name[name_or_value].number
-            else:
-                raise FunctionalException(f"Enum type '{enum_type_descriptor.full_name}' has no name '{name_or_value}' (possible names: {[k for k in enum_type_descriptor.values_by_name]})")
-        else:
-            return name_or_value
-    
-    def __load_enum_data(self, enum_type_fullname, enum_type_descriptor):
-        if enum_type_fullname in self.__enum_data_by_fullname:
-            raise TechnicalException(f"Data of enum type '{enum_type_fullname}' was already loaded")
-        data = NamedTuple('EnumData', values_by_number=dict)
-        data.values_by_number = {}
-        for value in enum_type_descriptor.values:
-            if value.number not in data.values_by_number or value.index > data.values_by_number[value.number].index:
-                data.values_by_number[value.number] = value
-        self.__enum_data_by_fullname[enum_type_fullname] = data
-    
-    def __set_object_value(self, field_obj, value, raise_exception=True):
-        res = False
-        for hpt in self.__registered_types:
-            if hpt.is_instance_of(field_obj):
-                res = hpt.set_object_value(field_obj, value, raise_exception=raise_exception)
-                if res:
-                    break
+        def __get_enum_value(self, name_or_value, enum_type=None, enum_type_descriptor=None):
+            if enum_type is None and enum_type_descriptor is None:
+                raise TechnicalException(f"Parameter 'enum_type' or 'enum_type_descriptor' must be defined")
+            if enum_type is not None:
+                enum_type_descriptor = enum_type.DESCRIPTOR
                 
-        if not res and raise_exception:
-            field_classes = inspect.getmro(type(field_obj))
-            registered_types_str = ', '.join([f"{t} ({t.protobuf_class()})" for t in self.__registered_types])
-            raise TechnicalException(f"Failed to manage type of field {Typing.get_object_class_fullname(field_obj)} (classes: {field_classes}) with registered types (and internal types): {registered_types_str}")
-        return res
-    
-    def __set_object_repeated_field(self, obj, field_name, values, add_index=False):
-        if not isinstance(values, list):
-            raise FunctionalException(f"For repeated field '{field_name}', parameter 'values' is not a list (type: {Typing.get_object_class_fullname(values)})")
+            if isinstance(name_or_value, str):
+                if name_or_value in enum_type_descriptor.values_by_name:
+                    return enum_type_descriptor.values_by_name[name_or_value].number
+                else:
+                    raise FunctionalException(f"Enum type '{enum_type_descriptor.full_name}' has no name '{name_or_value}' (possible names: {[k for k in enum_type_descriptor.values_by_name]})")
+            else:
+                return name_or_value
         
-        for index, value in enumerate(values):
-            self.__set_object_repeated_field_by_index(obj, field_name, index, value, add_index)
-    
-    def __set_object_repeated_field_by_index(self, obj, field_name, index, value, add_index=False):
-        repeated_field_obj = getattr(obj, field_name)
-        if not ProtobufMessages.is_object_repeated(repeated_field_obj):
-            raise FunctionalException(f"Field '{field_name}' is not a repeated in type '{self.get_object_type_fullname(obj)}'")
-        self.__check_field_value_to_set_is_valid(value)
+        def __load_enum_data(self, enum_type_fullname, enum_type_descriptor):
+            if enum_type_fullname in self.__enum_data_by_fullname:
+                raise TechnicalException(f"Data of enum type '{enum_type_fullname}' was already loaded")
+            data = NamedTuple('EnumData', values_by_number=dict)
+            data.values_by_number = {}
+            for value in enum_type_descriptor.values:
+                if value.number not in data.values_by_number or value.index > data.values_by_number[value.number].index:
+                    data.values_by_number[value.number] = value
+            self.__enum_data_by_fullname[enum_type_fullname] = data
         
-        field_descr = self.__get_object_field_descriptor(obj, field_name)
-        if field_descr.message_type is not None:
-            # Get field object at given index
-            if len(repeated_field_obj) < index + 1:
-                if add_index:
-                    for _ in range(index + 1 - len(repeated_field_obj)):
-                        obj_at_index = repeated_field_obj.add()
+        def __set_object_value(self, field_obj, value, raise_exception=True):
+            res = False
+            for hpt in self.__registered_types:
+                if hpt.is_instance_of(field_obj):
+                    res = hpt.set_object_value(field_obj, value, raise_exception=raise_exception)
+                    if res:
+                        break
+                    
+            if not res and raise_exception:
+                field_classes = inspect.getmro(type(field_obj))
+                registered_types_str = ', '.join([f"{t} ({t.protobuf_class()})" for t in self.__registered_types])
+                raise TechnicalException(f"Failed to manage type of field {Typing.get_object_class_fullname(field_obj)} (classes: {field_classes}) with registered types (and internal types): {registered_types_str}")
+            return res
+        
+        def __set_object_repeated_field(self, obj, field_name, values, add_index=False):
+            if not isinstance(values, list):
+                raise FunctionalException(f"For repeated field '{field_name}', parameter 'values' is not a list (type: {Typing.get_object_class_fullname(values)})")
+            
+            for index, value in enumerate(values):
+                self.__set_object_repeated_field_by_index(obj, field_name, index, value, add_index)
+        
+        def __set_object_repeated_field_by_index(self, obj, field_name, index, value, add_index=False):
+            repeated_field_obj = getattr(obj, field_name)
+            if not ProtobufMessages.is_object_repeated(repeated_field_obj):
+                raise FunctionalException(f"Field '{field_name}' is not a repeated in type '{self.get_object_type_fullname(obj)}'")
+            self.__check_field_value_to_set_is_valid(value)
+            
+            field_descr = self.__get_object_field_descriptor(obj, field_name)
+            if field_descr.message_type is not None:
+                # Get field object at given index
+                if len(repeated_field_obj) < index + 1:
+                    if add_index:
+                        for _ in range(index + 1 - len(repeated_field_obj)):
+                            obj_at_index = repeated_field_obj.add()
+                    else:
+                        raise FunctionalException(f"Index {index} exceeds repeated length {len(repeated_field_obj)} (field '{field_name}' in type '{self.get_object_type_fullname(obj)}')")
                 else:
-                    raise FunctionalException(f"Index {index} exceeds repeated length {len(repeated_field_obj)} (field '{field_name}' in type '{self.get_object_type_fullname(obj)}')")
-            else:
-                obj_at_index = repeated_field_obj[index]
-                
-            # Set field object value
-            try:
-                self.__set_object_value(obj_at_index, value)
-            except Exception as exc:
-                raise TechnicalException(f"Unmanaged set of value [{value}] (type: {Typing.get_object_class_fullname(value)}) in repeated field of type '{self.get_object_type_fullname(obj_at_index)}' (at index {index} of field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])\n  -> {exc.message}") from exc
-        else:
-            if field_descr.enum_type is not None:
-                value_to_set = self.__get_enum_value(value, enum_type_descriptor=field_descr.enum_type)
+                    obj_at_index = repeated_field_obj[index]
+                    
+                # Set field object value
+                try:
+                    self.__set_object_value(obj_at_index, value)
+                except Exception as exc:
+                    raise TechnicalException(f"Unmanaged set of value [{value}] (type: {Typing.get_object_class_fullname(value)}) in repeated field of type '{self.get_object_type_fullname(obj_at_index)}' (at index {index} of field '{field_name}' in object of type '{self.get_object_type_fullname(obj)}' [{obj}])\n  -> {exc.message}") from exc
             else:
-                value_to_set = value
-                
-            if len(repeated_field_obj) < index:
-                if add_index:
-                    for _ in range(index - len(repeated_field_obj)):
-                        repeated_field_obj.append(type(value)())
+                if field_descr.enum_type is not None:
+                    value_to_set = self.__get_enum_value(value, enum_type_descriptor=field_descr.enum_type)
+                else:
+                    value_to_set = value
+                    
+                if len(repeated_field_obj) < index:
+                    if add_index:
+                        for _ in range(index - len(repeated_field_obj)):
+                            repeated_field_obj.append(type(value)())
+                    else:
+                        raise FunctionalException(f"Index {index} exceeds repeated length {len(repeated_field_obj)} (field '{field_name}' in object [{obj}])")
+                    
+                if len(repeated_field_obj) == index:
+                    if add_index:
+                        try:
+                            repeated_field_obj.append(value_to_set)
+                        except Exception as exc:
+                            raise TechnicalException(f"Failed to add value [{value_to_set}] in repeated field at index {index} (field '{field_name}' in type '{self.get_object_type_fullname(obj)}')") from exc
+                    else:
+                        raise FunctionalException(f"Index {index} exceeds repeated length {len(repeated_field_obj)} (field '{field_name}' in type '{self.get_object_type_fullname(obj)}')")
                 else:
-                    raise FunctionalException(f"Index {index} exceeds repeated length {len(repeated_field_obj)} (field '{field_name}' in object [{obj}])")
-                
-            if len(repeated_field_obj) == index:
-                if add_index:
                     try:
-                        repeated_field_obj.append(value_to_set)
+                        repeated_field_obj[index] = value_to_set
                     except Exception as exc:
-                        raise TechnicalException(f"Failed to add value [{value_to_set}] in repeated field at index {index} (field '{field_name}' in type '{self.get_object_type_fullname(obj)}')") from exc
+                        raise TechnicalException(f"Failed to set value [{value_to_set}] in repeated field at index {index} (field '{field_name}' in type '{self.get_object_type_fullname(obj)}')") from exc
+                
+        def __split_attribute_fullname(self, attr_fullname):
+            m = self.__regex_attribute_fullname.match(attr_fullname)
+            res = [m.group(1), m.group(2)]
+            # logger.trace(f"++++++++++ __split_attribute_fullname('{attr_fullname}') => {res}")
+            return res
+    
+        def __represent_descriptor(self, descr, indent=0):
+            res_str = [str(type(descr))]
+            for name, value in Typing.get_object_attributes(descr):
+                if "_by_" in name:
+                    res_str.append(f"    {name}:")
+                    for el in value:
+                        res_str.append(f"        {el}: {self.__represent_descriptor(value[el], 8) if 'Descriptor' in str(type(value[el])) else value[el]}")
                 else:
-                    raise FunctionalException(f"Index {index} exceeds repeated length {len(repeated_field_obj)} (field '{field_name}' in type '{self.get_object_type_fullname(obj)}')")
-            else:
-                try:
-                    repeated_field_obj[index] = value_to_set
-                except Exception as exc:
-                    raise TechnicalException(f"Failed to set value [{value_to_set}] in repeated field at index {index} (field '{field_name}' in type '{self.get_object_type_fullname(obj)}')") from exc
+                    # if name == "containing_type":
+                        res_str.append(f"    {name}: {value}")
+                    # else:
+                    #     res_str.append(f"    {name}: {self.__represent_descriptor(value, 4) if 'Descriptor' in str(type(value)) else value}")
+            return Tools.indent_string(indent, "\n".join(res_str))
             
-    def __split_attribute_fullname(self, attr_fullname):
-        m = self.__regex_attribute_fullname.match(attr_fullname)
-        res = [m.group(1), m.group(2)]
-        # logger.trace(f"++++++++++ __split_attribute_fullname('{attr_fullname}') => {res}")
-        return res
-
-    def __represent_descriptor(self, descr, indent=0):
-        res_str = [str(type(descr))]
-        for name, value in Typing.get_object_attributes(descr):
-            if "_by_" in name:
-                res_str.append(f"    {name}:")
-                for el in value:
-                    res_str.append(f"        {el}: {self.__represent_descriptor(value[el], 8) if 'Descriptor' in str(type(value[el])) else value[el]}")
+        def _register_types(self):
+            # Duration must be registered before Message
+            from holado_protobuf.ipc.protobuf.types.google.protobuf import Duration as hpt_Duration
+            self.register_type(hpt_Duration)
+    
+            # Timestamp must be registered before Message
+            from holado_protobuf.ipc.protobuf.types.google.protobuf import Timestamp as hpt_Timestamp
+            self.register_type(hpt_Timestamp)
+    
+            from holado_protobuf.ipc.protobuf.types.google.protobuf import Message as hpt_Message
+            self.register_type(hpt_Message)
+    
+        def register_type(self, protobuf_type, index=None):
+            """
+            Register a holado protobuf type (subclass of holado_protobuf.ipc.protobuf.abstracts.type.Type)
+            """
+            if protobuf_type in self.__registered_types:
+                raise TechnicalException(f"Protobuf type '{protobuf_type.__class__.__name__}' is already registered")
+            
+            if index is not None:
+                self.__registered_types.insert(index, protobuf_type)
             else:
-                # if name == "containing_type":
-                    res_str.append(f"    {name}: {value}")
-                # else:
-                #     res_str.append(f"    {name}: {self.__represent_descriptor(value, 4) if 'Descriptor' in str(type(value)) else value}")
-        return Tools.indent_string(indent, "\n".join(res_str))
-        
-    def _register_types(self):
-        # Duration must be registered before Message
-        from holado_protobuf.ipc.protobuf.types.google.protobuf import Duration as hpt_Duration
-        self.register_type(hpt_Duration)
-
-        # Timestamp must be registered before Message
-        from holado_protobuf.ipc.protobuf.types.google.protobuf import Timestamp as hpt_Timestamp
-        self.register_type(hpt_Timestamp)
-
-        from holado_protobuf.ipc.protobuf.types.google.protobuf import Message as hpt_Message
-        self.register_type(hpt_Message)
-
-    def register_type(self, protobuf_type, index=None):
-        """
-        Register a holado protobuf type (subclass of holado_protobuf.ipc.protobuf.abstracts.type.Type)
-        """
-        if protobuf_type in self.__registered_types:
-            raise TechnicalException(f"Protobuf type '{protobuf_type.__class__.__name__}' is already registered")
-        
-        if index is not None:
-            self.__registered_types.insert(index, protobuf_type)
-        else:
-            self.__registered_types.append(protobuf_type)
+                self.__registered_types.append(protobuf_type)