python-deepcompare 2.1.0

A library for deep comparison of data structures consisting of `dict`, `list` and `tuple`.

deepcompare

deepcompare is a library to deeply compare data structures with each other. It can check if two data structures contain the same data, or if a data structure is a subset of another data structure. The library supports Sequence (e.g. list or tuple) and Mapping (e.g. dict) types for the deep comparison.

Installation

With a correctly configured pipenv toolchain:

pipenv install python-deepcompare

You may also use classic pip to install the package:

pip install python-deepcompare

Getting started

How it works

• As a default, the comparison treats all Sequence and all Mapping types the same (e.g. (1, 2, 3) is equal to [1, 2, 3]). To enable strict type checks, use the strict keyword argument.
• The partial_compare method checks if the data structure given as the second parameter is a subset of the data structure given as the first parameter.
  • For Mapping types this means, that all keys of the second data structure are also keys on the first data structure, and the values of the keys are also equal (e.g. {'a': 1, 'b': 2} is a subset of {'a': 1, 'b': 2, 'c': 3}, but {'a': 1, 'b': 2, 'd': 4} is not).
  • For Sequence types this means, that all values of the second data structure are also values of the first data structure, and the values are in the same order (e.g. [1, 3, 5] is a subset of [1, 2, 3, 4, 5], but [1, 5, 3] is not).

Usage

import deepcompare

# test if two data structures are equal, but the types to not need to match exactly
deepcompare.compare(
    {'key1': (1, 2, 3), 'key2': {'key3': [4, 5, 6]}},
    {'key1': [1, 2, 3], 'key2': {'key3': (4, 5, 6)}},
)  # returns: True

# test if two data structures are equal, and make sure the types match exactly
deepcompare.compare(
    {'key1': (1, 2, 3), 'key2': {'key3': [4, 5, 6]}},
    {'key1': [1, 2, 3], 'key2': {'key3': (4, 5, 6)}},
    strict=True,
)  # returns: False

# test if the second data structure is contained within the first, but
# the types to not need to match exactly
deepcompare.partial_compare(
    {'key1': (1, 2, 3), 'key2': {'key3': [4, 5, 6]}, 'key4': True},
    {'key1': [1, 2], 'key2': {'key3': (4, 6)}},
)  # returns: True

# test if the second data structure is contained within the first, and
# make sure the types match exactly
deepcompare.partial_compare(
    {'key1': (1, 2, 3), 'key2': {'key3': [4, 5, 6]}, 'key4': True},
    {'key1': [1, 2], 'key2': {'key3': (4, 6)}},
    strict=True,
)  # returns: False

List of developers

• Andreas Stocker [e-mail], Lead Developer