Сравнение 2 словарей с вложенностью без учёта порядка во вложенных списках

#python #python_3x

Есть 2 dict'а:

STANDARD_DATA = {
    'applications': [{
        'application': 'CUSTOMER',
        'platforms': [
            {'forceUpdate': [], 'latest': '1.19', 'minimal': '1.17', 'platform':
'ANDROID'},
            {'forceUpdate': [], 'latest': '1.19', 'minimal': '1.17', 'platform': 'IOS'}
        ]
    }, {
        'application': 'OWNER',
        'platforms': [
            {'forceUpdate': [], 'latest': '1.19', 'minimal': '1.17', 'platform':
'ANDROID'},
            {'forceUpdate': [], 'latest': '1.19', 'minimal': '1.17', 'platform': 'IOS'}
        ]
    }]
}

UPDATED_DATA = {
    'applications': [{
        'application': 'OWNER',
        'platforms': [
            {'forceUpdate': [], 'latest': '1.19', 'minimal': '1.17', 'platform':
'ANDROID'},
            {'forceUpdate': [], 'latest': '1.19', 'minimal': '1.17', 'platform': 'IOS'}
        ]
    }, {
        'application': 'CUSTOMER',
        'platforms': [
            {'forceUpdate': [], 'latest': '1.19', 'minimal': '1.17', 'platform': 'IOS'},
            {'forceUpdate': [], 'latest': '1.19', 'minimal': '1.17', 'platform':
'ANDROID'}
        ]
    }]
}


Т.е. они очень похожи, но данные внутри расположены в разных порядках: OWNER и CUSTOMER
расположены наоборот и внутри CUSTOMER'a ANDROID и IOS поменялись местами.

Вопрос:

Как написать assert при котором эти dict'ы будут равны?

Язык: Python 3.5
    

Ответы

Ответ 1

Для тестов можно использовать TestCase.assertCountEqual() из стандартной библиотеки,
чтобы сравнить списки без учёта порядка. 

Это не помогает для списков вложенных в dict. Чтобы реализовать сравнение без учёта
порядка для произвольного списка и чтобы получить читаемый diff при вызове assertDictEqual(),
можно определить свой класс, который упорядочивает repr() для списка:

class unordered(list):

    def __repr__(self): # for showing the diff
        return "[%s]" % ", ".join(sorted(map(repr, self)))

    def __eq__(self, other): # for comparison
        return repr(self) == repr(other)


Чтобы заменить возможно глубоко вложенные списки в словаре, можно рекурсивную функцию
использовать:

def make_list_unordered(nested):
    for key, value in getattr(nested, 'items', lambda: enumerate(nested))():
        if isinstance(value, (list, dict)):
            if isinstance(value, list):
                nested[key] = unordered(value)
            make_list_unordered(value)  # transform nested items


При желании можно заменять более широкий класс, используя MutableMapping/MutableSequence
для проверки типов вместо dict/list и использовать явный stack вместо рекурсии.


  Как написать assert при котором эти dict'ы будут равны?


#!/usr/bin/env python3
import unittest

class TestUnordered(unittest.TestCase):

    def test_equal_unordered(self):
        self.assertEqual(unordered('abc'), unordered('bac'))

    @unittest.expectedFailure
    def test_unequal_unordered(self):
        # for the correct error message
        self.addTypeEqualityFunc(unordered, 'assertCountEqual')
        self.assertEqual(unordered('abdc'), unordered('bac'))

    def test_nested_dict(self):
        make_list_unordered(STANDARD_DATA)
        make_list_unordered(UPDATED_DATA)
        self.assertEqual(STANDARD_DATA, UPDATED_DATA)


if __name__ == "__main__":
    unittest.main()


При запуске этого теста выводится:

python test-nested-dict.py 
.Fx
======================================================================
FAIL: test_nested_dict (__main__.TestUnordered)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test-nested-dict.py", line 37, in test_nested_dict
    self.assertEqual(STANDARD_DATA, UPDATED_DATA)
AssertionError: {'app[184 chars] '1.17', 'platform': 'IOS'}]}, {'application':[179
chars]}]}]} != {'app[184 chars] '1.18', 'platform': 'IOS'}]}, {'application':[179 chars]}]}]}
Diff is 1270 characters long. Set self.maxDiff to None to see it.

----------------------------------------------------------------------
Ran 3 tests in 0.004s

FAILED (failures=1, expected failures=1)


Что ожидаемо, так как '1.17' != '1.18'. Если поправить значение minimal, то тесты
успешно завершаются.


Ответ 2

Долго гугля смог найти подходящее решение, спасибо автору этого гиста
https://gist.github.com/Back2Basics/0e6456de0395fd200a06

import datetime, time, functools, operator, allure

default_fudge = datetime.timedelta(seconds=0, microseconds=0, days=0)


def deep_eq(_v1, _v2, datetime_fudge=default_fudge, _assert=True):
    """
    Tests for deep equality between two python data structures recursing
    into sub-structures if necessary. Works with all python types including
    iterators and generators. This function was dreampt up to test API responses
    but could be used for anything. Be careful. With deeply nested structures
    you may blow the stack.

    Options:
            datetime_fudge => this is a datetime.timedelta object which, when
                              comparing dates, will accept values that differ
                              by the number of seconds specified
            _assert        => passing yes for this will raise an assertion error
                              when values do not match, instead of returning
                              false (very useful in combination with pdb)
    """
    _deep_eq = functools.partial(deep_eq, datetime_fudge=datetime_fudge,
                                 _assert=_assert)

    def _check_assert(R, a, b, reason=''):
        if _assert and not R:
            assert 0, "an assertion has failed in deep_eq (%s) %s != %s" % (
                reason, str(a), str(b))
        return R

    def _deep_dict_eq(d1, d2):
        k1, k2 = (sorted(d1.keys()), sorted(d2.keys()))
        if k1 != k2:  # keys should be exactly equal
            return _check_assert(False, k1, k2, "keys")

        return _check_assert(operator.eq(sum(_deep_eq(d1[k], d2[k])
                                             for k in k1),
                                         len(k1)), d1, d2, "dictionaries")

    def _deep_iter_eq(l1, l2):
        if len(l1) != len(l2):
            return _check_assert(False, l1, l2, "lengths")
        return _check_assert(operator.eq(sum(_deep_eq(v1, v2)
                                             for v1, v2 in zip(l1, l2)),
                                         len(l1)), l1, l2, "iterables")

    def op(a, b):
        _op = operator.eq
        if type(a) == datetime.datetime and type(b) == datetime.datetime:
            s = datetime_fudge.seconds
            t1, t2 = (time.mktime(a.timetuple()), time.mktime(b.timetuple()))
            l = t1 - t2
            l = -l if l > 0 else l
            return _check_assert((-s if s > 0 else s) <= l, a, b, "dates")
        return _check_assert(_op(a, b), a, b, "values")

    c1, c2 = (_v1, _v2)

    # guard against strings because they are iterable and their
    # elements yield iterables infinitely.
    # I N C E P T I O N

    if isinstance(_v1, str):
        pass
    else:
        if isinstance(_v1, dict):
            op = _deep_dict_eq
        else:
            try:
                c1, c2 = (list(iter(_v1)), list(iter(_v2)))
            except TypeError:
                c1, c2 = _v1, _v2
            else:
                op = _deep_iter_eq

    return op(c1, c2)


В результате при включенным _assert=True так же отображаетя в чем проблема:

R = False, a = '1.17', b = '1.19', reason = 'values'

    def _check_assert(R, a, b, reason=''):
        if _assert and not R:
            assert 0, "an assertion has failed in deep_eq (%s) %s != %s" % (
>               reason, str(a), str(b))
E           AssertionError: an assertion has failed in deep_eq (values) 1.17 != 1.19


Ответ 3

def get_data(dt: dict) -> iter:
    apps = dt['applications']
    for e, app in sorted(enumerate(d['application'] for d in apps), key=lambda a: a[1]):
        yield app, sorted(sorted(d.items()) for d in apps[e]['platforms'])

assert list(get_data(STANDARD_DATA)) == list(get_data(UPDATED_DATA))