def is_invalid()

in reinvent-2020/aws-smart-recycle/pi/lambda/gg-pi-recycle/greengrasssdk/stream_manager/utilinternal.py [0:0]

• 83 lines of code
• 41 McCabe index (conditional complexity)

    def is_invalid(o):
        if not hasattr(o, "_validations_map"):
            return False
        if not hasattr(o, "_types_map"):
            return False
        for prop_name, validations in o._validations_map.items():
            if not hasattr(o, prop_name):
                return "Object is malformed, missing property: {}".format(prop_name)
            # Validate all properties on lists
            if type(getattr(o, prop_name)) == list:
                for i, v in enumerate(getattr(o, prop_name)):
                    result = UtilInternal.is_invalid(v)
                    if result:
                        return "Property {}[{}] is invalid because {}".format(prop_name, i, result)

            # Recurse down to check validity of objects within objects
            result = UtilInternal.is_invalid(getattr(o, prop_name))
            if result:
                return "Property {} is invalid because {}".format(prop_name, result)

            # Validate the property
            if "required" in validations and validations["required"] and getattr(o, prop_name) is None:
                return "Property {} is required, but was None".format(prop_name)
            if (
                "minLength" in validations
                and getattr(o, prop_name) is not None
                and len(getattr(o, prop_name)) < validations["minLength"]
            ):
                return "Property {} must have a minimum length of {}, but found length of {}".format(
                    prop_name, validations["minLength"], len(getattr(o, prop_name))
                )
            if (
                "maxLength" in validations
                and getattr(o, prop_name) is not None
                and len(getattr(o, prop_name)) > validations["maxLength"]
            ):
                return "Property {} must have a maximum length of {}, but found length of {}".format(
                    prop_name, validations["maxLength"], len(getattr(o, prop_name))
                )
            if (
                "minItems" in validations
                and getattr(o, prop_name) is not None
                and len(getattr(o, prop_name)) < validations["minItems"]
            ):
                return "Property {} must have at least {} items, but found {}".format(
                    prop_name, validations["minItems"], len(getattr(o, prop_name))
                )
            if (
                "maxItems" in validations
                and getattr(o, prop_name) is not None
                and len(getattr(o, prop_name)) > validations["maxItems"]
            ):
                return "Property {} must have at most {} items, but found {}".format(
                    prop_name, validations["maxItems"], len(getattr(o, prop_name))
                )
            if (
                "maximum" in validations
                and getattr(o, prop_name) is not None
                and getattr(o, prop_name) > validations["maximum"]
            ):
                return "Property {} must be at most {}".format(prop_name, validations["maximum"])
            if (
                "minimum" in validations
                and getattr(o, prop_name) is not None
                and getattr(o, prop_name) < validations["minimum"]
            ):
                return "Property {} must be at least {}".format(prop_name, validations["minimum"])
            if (
                "pattern" in validations
                and getattr(o, prop_name) is not None
                and re.fullmatch(validations["pattern"], getattr(o, prop_name)) is None
            ):
                return "Property {} must match regex {}".format(prop_name, validations["pattern"])

        for prop_name, types in o._types_map.items():
            # Validate all properties with their respective types
            if "type" in types and getattr(o, prop_name) is not None:
                result = isinstance(getattr(o, prop_name), types["type"])
                if not result:
                    return "Property {} is invalid because it must be of type {}".format(
                        prop_name, types["type"].__name__
                    )
                if types["type"] == list and "subtype" in types:
                    for i, v in enumerate(getattr(o, prop_name)):
                        result = isinstance(v, types["subtype"])
                        if not result:
                            return "Property {}[{}] is invalid because it must be of type {}".format(
                                prop_name, i, types["subtype"].__name__
                            )

        return False