util.arns

def same_resource_type(self, arn_in_database):
    """Given an arn, see if it has the same resource type"""

    # 1. If the RAW ARN in the database is *, then it doesn't have a resource type
    if arn_in_database == "*":
        return False

    # 2. ARNs should have the same service
    elements = arn_in_database.split(":", 5)
    if self.service_prefix != elements[2]:
        return False

    # 3. Add support for resource type wildcards, per #204
    # When specifying an ARN and setting a * on the resource type (e.g. instead of db:instance it is *:*),
    #   multiple ARNs can match.
    #   Previously, this would fail and return empty results.
    #   Now it correctly returns the full list of matching ARNs and corresponding actions.
    resource_type_arn_to_test = parse_arn_for_resource_type(self.arn)
    if resource_type_arn_to_test == '*':
        return True

    # 4. Match patterns for complicated resource strings, leveraging the standardized format of the Raw ARN format
    # table/${TableName} should not match `table/${TableName}/backup/${BackupName}`
    resource_string_arn_in_database = get_resource_string(arn_in_database)

    split_resource_string_in_database = re.split(':|/', resource_string_arn_in_database)
    # logger.debug(str(split_resource_string_in_database))
    arn_format_list = []
    for elem in split_resource_string_in_database:
        if "${" not in elem:
            arn_format_list.append(elem)
        else:
            # If an element says something like ${TableName}, normalize it to an empty string
            arn_format_list.append("")

    split_resource_string_to_test = re.split(':|/', self.resource_string)
    # 4b: If we have a confusing resource string, the length of the split resource string list
    #  should at least be the same
    # Again, table/${TableName} (len of 2) should not match `table/${TableName}/backup/${BackupName}` (len of 4)
    if len(split_resource_string_to_test) != len(arn_format_list):
        return False

    # 4c: See if the non-normalized fields match
    for i in range(len(arn_format_list)):
        # If the field is not normalized to empty string, then make sure the resource type segments match
        # So, using table/${TableName}/backup/${BackupName} as an example:
        # table should match, backup should match,
        # and length of the arn_format_list should be the same as split_resource_string_to_test
        # If all conditions match, then the ARN format is the same.
        if arn_format_list[i] != "":
            if arn_format_list[i] == split_resource_string_to_test[i]:
                pass
            elif split_resource_string_to_test[i] == "*":
                pass
            else:
                return False

    # 4. Special type for S3 bucket objects and CodeCommit repos
    # Note: Each service can only have one of these, so these are definitely exceptions
    exclusion_list = ["${ObjectName}", "${RepositoryName}", "${BucketName}"]
    resource_path_arn_in_database = elements[5]
    if resource_path_arn_in_database in exclusion_list:
        logger.debug("Special type: %s", resource_path_arn_in_database)
        # If we've made it this far, then it is a special type
        # return True
        # Presence of / would mean it's an object in both so it matches
        if "/" in self.resource_string and "/" in elements[5]:
            return True
        # / not being present in either means it's a bucket in both so it matches
        elif "/" not in self.resource_string and "/" not in elements[5]:
            return True
        # If there is a / in one but not in the other, it does not match
        else:
            return False

    # 5. If we've made it this far, then it should pass
    return True