markdown 字典比较

Posted 2021-05-06

def print_error(exp, act, path=[]):
    if path != []:
        print 'MATCH LIST ITEM: %s' % '>>'.join(path)
    print 'EXPECTED: %s' % str(exp)
    print 'ACTUAL: %s' % str(act)
    print ''

def copy_append(lst, item):
    foo = lst[:]
    foo.append(str(item))
    return foo

def deep_check(comp, compto, path=[], print_errors=True):
    # Total number of errors found, is needed for when
    # testing the similarity of dicts
    errors = 0

    if isinstance(comp, list):
        # If the types are not the same then it is probably a critical error
        # return a number to represent how important this is
        if not isinstance(compto, list):
            if print_errors:
                print_error(comp, 'NOT_LIST', path)
            return 1

        # We don't want to destroy the original lists
        comp_copy = comp[:]
        compto_copy = compto[:]

        # Remove items that are both is comp and compto
        # and find items that are only in comp
        for item in comp_copy[:]:
            try:
                compto_copy.remove(item)
                # Only is removed if the item is in compto_copy
                comp_copy.remove(item)
            except ValueError:
                # dicts need to be handled differently 
                if isinstance(item, dict):
                    continue
                if print_errors:
                    print_error(item, 'NOT_FOUND', path)
                errors += 1

        # Find non-dicts that are only in compto
        for item in compto_copy[:]:
            if isinstance(item, dict):
                continue
            compto_copy.remove(item)
            if print_errors:
                print_error('NOT_FOUND', item, path)
            errors += 1

        # Now both copies only have dicts

        # This is the part that compares dicts with the minimum
        # errors between them, it is expensive since each dict in comp_copy
        # has to be compared against each dict in compto_copy
        for c in comp_copy:
            lowest_errors = None
            lowest_value = None
            for ct in compto_copy:
                errors_in = deep_check(c, ct, path, print_errors=False)

                # Get and store the minimum errors
                if errors_in < lowest_errors or lowest_errors is None:
                    lowest_errors = errors_in
                    lowest_value = ct
            if lowest_errors is not None:
                errors += lowest_errors
                # Has to have print_errors passed incase the list of dicts
                # contains a list of dicts
                deep_check(c, lowest_value, path, print_errors)
                compto_copy.remove(lowest_value)

        return errors

    if not isinstance(compto, dict):
        # If the types are not the same then it is probably a critical error
        # return a number to represent how important this is
        if print_errors:
            print_error(comp, 'NOT_DICT')
        return 1
    for key, value in compto.iteritems():
        try:
            comp[key]
        except KeyError:
            if print_errors:
                print_error('NO_KEY', key, copy_append(path, key))
            errors += 1

    for key, value in comp.iteritems():
        try:
            tovalue = compto[key]
        except KeyError:
            if print_errors:
                print_error(value, 'NOT_FOUND', copy_append(path, key))
            errors += 1
            continue

        if isinstance(value, (list, dict)):
            errors += deep_check(value, tovalue, copy_append(path, key), print_errors)
        else:
            if value != tovalue:
                if print_errors:
                    print_error(value, tovalue, copy_append(path, key))
                errors += 1

    return errors

# Contents