Message

@classmethod
def fields(cls):
    """Get dataclass fields"""
    return list(cls.__dataclass_fields__.keys())

@classmethod
def from_proto(
    cls,
    proto: ProtobufMessage
) -> Dict[str, Any]:
    """Converts given protobuf to python Dict"""

    dict_ = {}
    one_ofs = proto.DESCRIPTOR.oneofs_by_name
    for field in proto.DESCRIPTOR.fields:

        one_of_field = False
        for one_of, _ in one_ofs.items():
            if field.name == proto.WhichOneof(one_of):
                one_of_field = True


        # If the field is oneof and options are in message type
        if one_of_field and field.type == FieldDescriptor.TYPE_MESSAGE:

            field_ = cls.__dataclass_fields__[field.name]
            args = get_args(field_.type)

            # Make sure oneof message is typed as Optional
            if not args:
                raise FedbiomedMessageError(
                    f"Please make sure the field '{field_.name}' in dataclass '{cls.__name__}' "
                    "is typed as Optional[<dataclass>]. The field that are typed as `oneof` "
                    "in proto file should be typed as Optional in python dataclass"
                )

            if not hasattr(args[0], "__PROTO_TYPE__"):
                raise FedbiomedMessageError(f"Dataclass {args[0]} should have attribute '__PROTO_TYPE__'")

            dict_.update(
                {field.name: args[0].from_proto(getattr(proto, field.name))}
            )

        # Detects the types that are declared as `optional`
        # NOTE: In proto3 all fields are labeled as `LABEL_OPTIONAL` by default.
        # However, if the field is labeled as `optional` explicitly, it will have
        # presence, otherwise, `has_presence` returns False
        elif field.has_presence and field.label == FieldDescriptor.LABEL_OPTIONAL:

            # If proto has the field it means that the value is not None
            if proto.HasField(field.name):
                dict_.update({field.name: getattr(proto, field.name)})

        elif field.label == FieldDescriptor.LABEL_REPEATED:

            if field.type == FieldDescriptor.TYPE_MESSAGE:
                dict_.update({field.name: dict(getattr(proto, field.name))})
            else:
                dict_.update({field.name: list(getattr(proto, field.name))})

        else:
            dict_.update({field.name: getattr(proto, field.name)})

    return cls(**dict_)

def get_dict(self) -> Dict[str, Any]:
    """Returns pairs (Message class attributes name, attributes values) into a dictionary

    Returns:
        Message as dictionary
    """
    return self.__dict__

def get_param(self, param: str):
    """Get the value of a given param

    Args:
        param: name of the param
    """
    return getattr(self, param)

def to_proto(self):
    """Converts recursively python dataclass to gRPC proto"""

    proto_dict = {}
    for key, _ in self.__dataclass_fields__.items():
        param = self.get_param(key)
        if hasattr(param, '__PROTO_TYPE__'):
            proto_dict.update({key: self.get_param(key).to_proto()})
        else:
            proto_dict.update({key: self.get_param(key)})

    return self.__PROTO_TYPE__(**proto_dict)

@classmethod
def format_incoming_message(cls, params: Dict[str, Any]) -> Message:
    """Format a dictionary representing an incoming message into the appropriate Message class.

    Packs the input into the appropriate Message class representing an incoming message.
    The type of Message class is inferred from the `command` key in the input dictionary.
    This function also validates:

    - the legacy of the message
    - the structure of the received message

    Attributes:
        params: the dictionary of key-value pairs extracted from the received message.

    Raises:
        FedbiomedMessageError: if 'command' field is not present in `params`
        FedbiomedMessageError: if the component is not allowed to receive the message

    Returns:
        The received message formatted as an instance of the appropriate Message class
    """
    MessageFactory._raise_for_missing_command(params)
    message_type = params['command']
    MessageFactory._validate_message_type_or_raise(message_type, cls.INCOMING_MESSAGE_TYPE_TO_CLASS_MAP)
    return cls.INCOMING_MESSAGE_TYPE_TO_CLASS_MAP[message_type](**params)

@classmethod
def format_outgoing_message(cls, params: Dict[str, Any]) -> Message:
    """Format a dictionary representing an outgoing message into the appropriate Message class.

    Packs the input into the appropriate Message class representing an outbound message.
    The type of Message class is inferred from the `command` key in the input dictionary.
    This function also validates:

    - the legacy of the message
    - the structure of the received message

    Attributes:
        params: the dictionary of key-value pairs to be packed into the outgoing message.

    Raises:
        FedbiomedMessageError: if 'command' field is not present in `params`
        FedbiomedMessageError: if the component is not allowed to send the message

    Returns:
        The outbound message formatted as an instance of the appropriate Message class
    """

    MessageFactory._raise_for_missing_command(params)
    message_type = params['command']
    MessageFactory._validate_message_type_or_raise(message_type, cls.OUTGOING_MESSAGE_TYPE_TO_CLASS_MAP)
    params['protocol_version'] = str(__messaging_protocol_version__)  # inject procotol version only in outgoing msg
    return cls.OUTGOING_MESSAGE_TYPE_TO_CLASS_MAP[message_type](**params)