def METHOD_NAME(
    op,  # type: Operation
    request_data,  # type: JSONDict
):
    # type: (...) -> None
    """
    Checks that one security option is used at time.
    :param op: operation to be considered
    :type op: :class:`bravado_core.operation.Operation`
    :param request_data:
    :type request_data: dict
    :raise: SwaggerSecurityValidationError
    """
    security_types = set(
        definition.type
        for security_requirement in op.security_requirements
        for definition in itervalues(security_requirement.security_definitions)
    )
    # At the moment we are handling only apiKey securities
    if 'apiKey' in security_types:
        matched_security_indexes = []
        for security_index, security_params_list in enumerate(op.security_requirements):
            if all([request_data.get(security_param.name) is not None for security_param in security_params_list]):
                matched_security_indexes.append(security_index)
        if len(matched_security_indexes) == 0:
            raise SwaggerSecurityValidationError('No security definition used.')
        if len(matched_security_indexes) > 1:
            # if more than one security defs are matched then check if one security definition contains all the others
            # ie. consider sec1: requires parameter sec1 and sec2: requires parameter sec2
            # if an operation defines two securities like [{"sec1": []}, {"sec1": [], "sec2": []}]
            # it is acceptable to have:
            #   sec1 parameter only (match the first security)
            #   sec1 and sec2 (match the second security)
            # extract all the security matched security definition and sort them for decreasing length
            matched_security_definitions = sorted(
                (
                    set(security)
                    for index, security in enumerate(op.acceptable_security_definition_combinations)
                    if index in matched_security_indexes
                ),
                key=len,
                reverse=True,
            )
            # have all the security definition the same length?
            # if yes is not possible to discriminate the security definition matched
            all_same_length = (len(matched_security_definitions[0]) == len(matched_security_definitions[-1]))
            # is the longest security definition a superset for all the others?
            # if no there is no way to discriminate the security definition matched
            exists_superset = all(
                matched_security_definitions[0].issuperset(security_definition)
                for security_definition in matched_security_definitions
            )
            if all_same_length or not exists_superset:
                raise SwaggerSecurityValidationError(
                    "More than one security definition is in use at the same time ({0})".format(
                        ', '.join(
                            str(security)
                            for index, security in enumerate(op.acceptable_security_definition_combinations)
                            if index in matched_security_indexes
                        ),
                    ),
                )