def as_valid_qualification_dict()

in mephisto/data_model/qualification.py [0:0]

• 48 lines of code
• 14 McCabe index (conditional complexity)

def as_valid_qualification_dict(qual_dict: Dict[str, Any]) -> Dict[str, Any]:
    """
    Check to ensure that a qualification dict properly checks
    against a Mephisto qualification
    """
    required_keys = [
        "qualification_name",
        "comparator",
        "value",
        "applicable_providers",
    ]
    for key in required_keys:
        if key not in qual_dict:
            raise AssertionError(
                f"Required key {key} not in qualification dict {qual_dict}"
            )

    qual_name = qual_dict["qualification_name"]
    if type(qual_name) is not str or len(qual_name) == 0:
        raise AssertionError(
            f"Qualification name '{qual_name}' is not a string with length > 0"
        )

    comparator = qual_dict["comparator"]
    if comparator not in SUPPORTED_COMPARATORS:
        raise AssertionError(
            f"Qualification comparator '{comparator}' not in supported list: {SUPPORTED_COMPARATORS}'"
        )

    value = qual_dict["value"]

    if (
        comparator in [QUAL_GREATER, QUAL_LESS, QUAL_GREATER_EQUAL, QUAL_LESS_EQUAL]
        and type(value) != int
    ):
        raise AssertionError(
            f"Value {value} is not valid for comparator {comparator}, must be an int"
        )

    if comparator in [QUAL_EXISTS, QUAL_NOT_EXIST] and value is not None:
        raise AssertionError(
            f"Value {value} is not valid for comparator {comparator}, must be None"
        )

    if comparator in [QUAL_IN_LIST, QUAL_NOT_IN_LIST] and type(value) != list:
        raise AssertionError(
            f"Value {value} is not valid for comparator {comparator}, must be a list"
        )

    if qual_dict["applicable_providers"] is not None:
        assert (
            type(qual_dict["applicable_providers"]) == list
        ), "Applicable providers must be a string list of providers or none."
        valid_providers = get_valid_provider_types()
        for provider_name in qual_dict["applicable_providers"]:
            assert (
                provider_name in valid_providers
            ), f"Noted applicable provider name {provider_name} not in list of usable providers: {valid_providers}"

    return qual_dict