fedbiomed.common.message

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)

@classmethod
def reply_create(cls, params: dict) -> Union[TrainReply,
                                             SearchReply,
                                             PingReply,
                                             LogMessage,
                                             ErrorMessage,
                                             AddScalarReply,
                                             ListReply,
                                             TrainingPlanStatusReply,
                                             ApprovalReply,
                                             SecaggReply,
                                             SecaggDeleteReply]:
    """Message reception.

    It creates the adequate message reply to send to the researcher, it maps an instruction (given the key
    "command" in the input dictionary `params`) to a Message object

    It validates:
    - the legacy of the message
    - the structure of the received message

    Raises:
        FedbiomedMessageError: if the message is not allowed te be received by the node (ie if message `command`
            field is not either a train request, search request, a ping request, add scalar request, or
            error message)

    Returns:
        An instance of the corresponding class
    """
    try:
        message_type = params['command']
    except KeyError:
        _msg = ErrorNumbers.FB601.value + ": message type not specified"
        logger.error(_msg)
        raise FedbiomedMessageError(_msg)

    MESSAGE_TYPE_TO_CLASS_MAP = {'train': TrainReply,
                                 'search': SearchReply,
                                 'pong': PingReply,
                                 'log': LogMessage,
                                 'error': ErrorMessage,
                                 'add_scalar': AddScalarReply,
                                 'list': ListReply,
                                 'training-plan-status': TrainingPlanStatusReply,
                                 'approval': ApprovalReply,
                                 'secagg': SecaggReply,
                                 'secagg-delete': SecaggDeleteReply
                                 }

    if message_type not in MESSAGE_TYPE_TO_CLASS_MAP:
        _msg = ErrorNumbers.FB601.value + ": bad message type for request_create: {}".format(message_type)
        logger.error(_msg)
        raise FedbiomedMessageError(_msg)
    return MESSAGE_TYPE_TO_CLASS_MAP[message_type](**params)

@classmethod
def request_create(cls, params: dict) -> Union[TrainRequest,
                                               SearchRequest,
                                               PingRequest,
                                               ListRequest,
                                               TrainingPlanStatusRequest,
                                               ApprovalRequest,
                                               SecaggRequest,
                                               SecaggDeleteRequest]:
    """Creates the adequate message/ request to send to researcher, it maps an instruction (given the key
    "command" in the input dictionary `params`) to a Message object

    It validates:
    - the legacy of the message
    - the structure of the created message

    Raises:
        FedbiomedMessageError: triggered if the message is not allowed te be sent by the node (ie if message
            `command` field is not either a train request, search request or a ping request)

    Returns:
        An instance of the corresponding class (TrainRequest,SearchRequest, PingRequest)
    """
    try:
        message_type = params['command']
    except KeyError:
        _msg = ErrorNumbers.FB601.value + ": message type not specified"
        logger.error(_msg)
        raise FedbiomedMessageError(_msg)

    # mapping message type to an object
    MESSAGE_TYPE_TO_CLASS_MAP = {'train': TrainRequest,
                                 'search': SearchRequest,
                                 'ping': PingRequest,
                                 'list': ListRequest,
                                 'training-plan-status': TrainingPlanStatusRequest,
                                 'approval': ApprovalRequest,
                                 'secagg': SecaggRequest,
                                 'secagg-delete': SecaggDeleteRequest
                                 }

    if message_type not in MESSAGE_TYPE_TO_CLASS_MAP:
        _msg = ErrorNumbers.FB601.value + ": bad message type for reply_create: {}".format(message_type)
        logger.error(_msg)
        raise FedbiomedMessageError(_msg)
    return MESSAGE_TYPE_TO_CLASS_MAP[message_type](**params)

@classmethod
def reply_create(cls, params: Dict[str, Any]) -> Union[TrainReply,
                                                       SearchReply,
                                                       PingReply,
                                                       LogMessage,
                                                       ErrorMessage,
                                                       ListReply,
                                                       AddScalarReply,
                                                       TrainingPlanStatusReply,
                                                       ApprovalReply,
                                                       SecaggReply,
                                                       SecaggDeleteReply]:
    """Message reception (as a mean to reply to node requests, such as a Ping request).

    It creates the adequate message, it maps an instruction (given the key "command" in the input dictionary
    `params`) to a Message object

    It validates:
    - the legacy of the message
    - the structure of the received message

    Raises:
        FedbiomedMessageError: triggered if the message is not allowed to be received by the researcher
        KeyError: triggered if 'command' field is not present in `params`

    Returns:
        An instance of the corresponding Message class
    """
    try:
        message_type = params['command']
    except KeyError:
        _msg = ErrorNumbers.FB601.value + ": message type not specified"
        logger.error(_msg)
        raise FedbiomedMessageError(_msg)

    MESSAGE_TYPE_TO_CLASS_MAP = {'train': TrainReply,
                                 'search': SearchReply,
                                 'pong': PingReply,
                                 'log': LogMessage,
                                 'error': ErrorMessage,
                                 'list': ListReply,
                                 'add_scalar': AddScalarReply,
                                 'training-plan-status': TrainingPlanStatusReply,
                                 'approval': ApprovalReply,
                                 'secagg': SecaggReply,
                                 'secagg-delete': SecaggDeleteReply
                                 }

    if message_type not in MESSAGE_TYPE_TO_CLASS_MAP:
        _msg = ErrorNumbers.FB601.value + ": bad message type for reply_create: {}".format(message_type)
        logger.error(_msg)
        raise FedbiomedMessageError(_msg)
    return MESSAGE_TYPE_TO_CLASS_MAP[message_type](**params)

@classmethod
def request_create(cls, params: Dict[str, Any]) -> Union[TrainRequest,
                                                         SearchRequest,
                                                         PingRequest,
                                                         ListRequest,
                                                         TrainingPlanStatusRequest,
                                                         ApprovalRequest,
                                                         SecaggRequest,
                                                         SecaggDeleteRequest]:

    """Creates the adequate message/request,

    It maps an instruction (given the key "command" in the input dictionary `params`) to a Message object

    It validates:
    - the legacy of the message
    - the structure of the created message

    Args:
        params: dictionary containing the message.

    Raises:
        FedbiomedMessageError: if the message is not allowed to be sent by the researcher
        KeyError: Missing key ub the reqeust

    Returns:
        An instance of the corresponding Message class
    """

    try:
        message_type = params['command']
    except KeyError:
        _msg = ErrorNumbers.FB601.value + ": message type not specified"
        logger.error(_msg)
        raise FedbiomedMessageError(_msg)

    MESSAGE_TYPE_TO_CLASS_MAP = {'train': TrainRequest,
                                 'search': SearchRequest,
                                 'ping': PingRequest,
                                 'list': ListRequest,
                                 'training-plan-status': TrainingPlanStatusRequest,
                                 'approval': ApprovalRequest,
                                 'secagg': SecaggRequest,
                                 'secagg-delete': SecaggDeleteRequest
                                 }

    if message_type not in MESSAGE_TYPE_TO_CLASS_MAP:
        _msg = ErrorNumbers.FB601.value + ": bad message type for request_create: {}".format(message_type)
        logger.error(_msg)
        raise FedbiomedMessageError(_msg)
    return MESSAGE_TYPE_TO_CLASS_MAP[message_type](**params)