assert-matcher 0.9__py2.py3-none-any.whl

assert_matcher/__init__.py

@@ -0,0 +1 @@
+VERSION = '0.9'

assert_matcher/approx.py

@@ -0,0 +1,35 @@
+from datetime import datetime, timedelta
+
+import pytest
+from _pytest.python_api import ApproxBase
+
+
+def approx(expected, rel=None, abs=None, nan_ok=False):
+    if isinstance(expected, datetime):
+        if rel is not None:
+            raise TypeError("rel doesn't make sense with a datetime")
+        return ApproxDatetime(expected, abs=abs)
+
+    return pytest.approx(expected, rel=rel, abs=abs, nan_ok=nan_ok)
+
+
+class ApproxDatetime(ApproxBase):
+    """Perform approximate comparisons between datetime."""
+    default_abs = timedelta(seconds=1)
+
+    def __init__(self, expected, abs=None):
+        assert isinstance(expected, datetime)
+
+        if abs is None:
+            abs = self.default_abs
+        elif isinstance(abs, int):
+            abs = timedelta(seconds=abs)
+
+        assert abs >= timedelta(0), f"absolute tolerance can't be negative: {abs}"
+        super().__init__(expected, abs=abs)
+
+    def __repr__(self):
+        return f"approx({self.expected} ± {self.abs})"
+
+    def __eq__(self, actual: object) -> bool:
+        return abs(self.expected - actual) <= self.abs

assert_matcher/compare.py

@@ -0,0 +1,244 @@
+import pprint
+from collections import defaultdict
+from collections.abc import Mapping, Set
+from functools import partial
+from itertools import count
+
+from _pytest._io.saferepr import safeformat, saferepr
+from _pytest.assertion.util import issequence, assertrepr_compare
+
+from .matchers import Matcher, MatcherDict
+
+
+def pytest_assertrepr_compare(config, op: str, left, right):
+    import shutil
+    import _pytest._code
+
+    verbose = config.get_verbosity() if hasattr(config, "get_verbosity") \
+        else config.getoption("verbose")
+    if verbose > 1:
+        left_repr = safeformat(left)
+        right_repr = safeformat(right)
+    else:
+        hspace = max(80, shutil.get_terminal_size().columns - 10)
+        hspace -= len("E       AssertionError: assert") + len(op) + 2  # 2 spaces
+        left_repr = saferepr(left, maxsize=hspace // 2)
+        right_repr = saferepr(right, maxsize=hspace - len(left_repr))
+
+    try:
+        explanation = to_lines(compare(config, op, left, right))
+        # NOTE: not calling _compare_eq_iterable() anywhere for now
+    except Exception:
+        crash = _pytest._code.ExceptionInfo.from_current()._getreprcrash()
+        explanation = [
+            "assert_matcher comparison failed:",
+            f"  {crash}",
+            "Probably an object has a faulty __repr__.",
+        ]
+
+    if not explanation:
+        return None
+
+    summary = f"{left_repr} {op} {right_repr}"
+    return [summary] + explanation
+
+
+def compare(config, op, left, right):
+    explanation = []
+    for test, explain in EXPLAINERS[op]:
+        if test(left, right):
+            return explain(config, left, right)
+    return explanation
+
+
+def compare_eq(config, left, right):
+    return compare(config, "==", left, right) or [f"{left!r} != {right!r}"]
+
+
+# Explainers framework
+
+EXPLAINERS = defaultdict(list)
+
+
+def register_explainer(op, test, explain=None):
+    if explain is None:
+        return partial(register_explainer, op, test)
+    EXPLAINERS[op].append((test, explain))
+    return explain  # Return the function when we use this as a decorator
+
+
+def both(test):
+    return lambda left, right: test(left) and test(right)
+
+
+def bothis(cls):
+    return lambda left, right: isinstance(left, cls) and isinstance(right, cls)
+
+
+def anyis(cls):
+    return lambda left, right: isinstance(left, cls) or isinstance(right, cls)
+
+
+@register_explainer("==", anyis(MatcherDict))
+def _explain_m_dict(config, left, right):
+    if isinstance(left, MatcherDict) and isinstance(right, MatcherDict):
+        return ["Should not compare two M.dict() instances"]
+
+    if isinstance(left, MatcherDict):
+        matcher_side, val, matcher, left_d, right_d = "Left", right, left, left.d, right
+    else:
+        matcher_side, val, matcher, left_d, right_d = "Right", left, right, left, right.d
+
+    explanation = _dict_extra(matcher_side, matcher.d, val)
+
+    # NOTE: not using sets here to use the matchers keys order
+    diff = _dict_diff(config, [k for k in matcher.d if k in val], left_d, right_d)
+    return explanation + diff
+
+
+@register_explainer("==", bothis(Mapping))
+def _explain_dict(config, left, right):
+    explanation = []
+
+    for side, more, less in [("Left", left, right), ("Right", right, left)]:
+        explanation.extend(_dict_extra(side, more, less))
+
+    # NOTE: not using sets here to preserve keys order
+    diff = _dict_diff(config, [k for k in right if k in left], left, right)
+    return explanation + diff
+
+
+def _dict_extra(side, more, less):
+    explanation = []
+    extra = {k: v for k, v in more.items() if k not in less}
+    if extra:
+        n = len(extra)
+        explanation.append(f"{side} contains {n} more item{'' if n == 1 else 's'}:")
+        explanation.extend(pprint.pformat(extra).splitlines())
+    return explanation
+
+
+def _dict_diff(config, keys, left, right):
+    # NOTE: we use simple key with no ["..."] wrapping to make it cleaner
+    items = {k: compare_eq(config, left[k], right[k]) for k in keys if left[k] != right[k]}
+    return Explanation(prefix="Differing items:", items=items) if items else []
+
+
+class Missing:
+    def __str__(self):
+        return "<missing>"
+
+    __repr__ = __str__
+
+
+missing = Missing()
+
+
+@register_explainer("==", anyis(Matcher))
+def _explain_m(config, left, right):
+    if isinstance(left, Matcher) and isinstance(right, Matcher):
+        return ["Should not compare two M() instances"]
+
+    if isinstance(left, Matcher):
+        matcher, left_d = left, left.attrs
+        right_d = {k: getattr(right, k, missing) for k in left_d}
+    else:
+        matcher, right_d = right, right.attrs
+        left_d = {k: getattr(left, k, missing) for k in right_d}
+
+    return _dict_diff(config, matcher.attrs, left_d, right_d)
+
+
+@register_explainer("==", bothis(Set))
+def _explain_set(config, left, right):
+    return assertrepr_compare(config, "==", left, right)
+
+
+@register_explainer("==", bothis(str))
+def _explain_str(config, left, right):
+    return assertrepr_compare(config, "==", left, right)
+
+
+# TODO: catch a situation when some item was removed in the middle?
+#       what about swap?
+@register_explainer("==", both(issequence))
+def _explain_seq(config, left, right):
+    if isinstance(left, bytes) and isinstance(right, bytes):
+        return assertrepr_compare(config, "==", left, right)
+
+    explanation = []
+    for i, l, r in zip(count(), left, right):
+        if l != r:  # noqa
+            explanation = Explanation("First mismatch:", {f"[{i}]": compare_eq(config, l, r)})
+            # NOTE: we are ignoring other mismatches, and "First mismatch:" above won't be shown
+            #       if the below section will yield nothing
+            break
+
+    len_diff = len(left) - len(right)
+    if len_diff:
+        if len_diff > 0:
+            side, extra = "Left", left[len(right)]
+        else:
+            side, extra = "Right", right[len(left)]
+            len_diff = -len_diff
+
+        if len_diff == 1:
+            explanation += [f"{side} contains one more item: {extra!r}"]
+        else:
+            explanation += [f"{side} contains {len_diff} more items, first one: {extra!r}"]
+    return explanation
+
+
+class Explanation(dict):
+    """An explanation of a diff for dicts and objects.
+
+    Converted to lines of strings before returning to pytest. This delaying of rendering allows to
+    join keys when we find differences in nested structures.
+
+    Allows separating diff collection from rendering partially. We want to reuse some of
+    the _pytest.assertion.util code, so we work with both this and list[str].
+    """
+    def __init__(self, prefix, items):
+        self._prefix = prefix
+        self.update(items)
+
+    def add(self, other, reverse=False):
+        if not other:
+            return self
+        elif isinstance(other, list):
+            rendered = [self._prefix] + to_lines(self)
+            return other + rendered if reverse else rendered + other
+        raise NotImplementedError
+
+    def __add__(self, other):
+        return self.add(other)
+
+    def __radd__(self, other):
+        return self.add(other, reverse=True)
+
+
+def to_lines(expl, path=""):
+    """Coerce explanation to lines of strings"""
+    if isinstance(expl, list):
+        return expl
+
+    # NOTE: we only escape string keys if they contain "." for readablity.
+    #       This makes object attrs look the same as dict keys though.
+    def escape_key(k):
+        return repr(k) if not k.startswith("[") and "." in k else k
+
+    explanation = []
+    for k, lines in expl.items():
+        # full_path = f"{path}.{escape_key(k)}" if path else escape_key(k)
+        if path:
+            full_path = path + k if k.startswith("[") else f"{path}.{escape_key(k)}"
+        else:
+            full_path = escape_key(k)
+        if isinstance(lines, dict):
+            explanation.extend(to_lines(lines, path=full_path))
+        elif len(lines) == 1:
+            explanation.append(f"{full_path}: " + lines[0])
+        else:
+            explanation.append(f"{full_path}:")
+            explanation.extend(["  " + l for l in lines])  # noqa
+    return explanation

assert_matcher/matchers.py

@@ -0,0 +1,150 @@
+import re
+
+
+class MatcherRegex:
+    """Special class to eq by matching regex"""
+    def __init__(self, pattern, flags=0):
+        self.regex = re.compile(pattern, flags)
+
+    def __repr__(self):
+        flags = self.regex.flags & ~32  # 32 is default
+        if flags:
+            return f"M.re(r'{self.regex.pattern}', {flags})"
+        else:
+            return f"r'{self.regex.pattern}'"
+
+    def __eq__(self, other):
+        return self.regex.search(other)
+
+
+class MatcherDict:
+    """Special class to eq by matching only presented dict keys"""
+    # NOTE: can't inherit from dict because that makes D() == M.dict() to not call our __eq__,
+    #       if D is a subclass of a dict
+    def __init__(self, __d=None, **keys):
+        self.d = __d or {}
+        if keys:
+            self.d = self.d.copy()
+            self.d.update(keys)
+
+    def __repr__(self):
+        return f"M.dict({', '.join(f'{k}={repr(v)}' for k, v in self.d.items())})"
+
+    def __len__(self):
+        return len(self.d)
+
+    def __eq__(self, other):
+        missing = object()
+        return all(other.get(name, missing) == v for name, v in self.d.items())
+
+
+class MatcherAny:
+    """Equals to anything, a way to ignore parts of data structures on comparison"""
+    def __repr__(self):
+        return "M.any"
+
+    def __eq__(self, other):
+        return True
+
+
+class MatcherAnyOf:
+    def __init__(self, *items):
+        self.items = items
+
+    def __repr__(self) -> str:
+        inner = ", ".join(map(repr, self.items))
+        return f"M.any_of({inner})"
+
+    def __eq__(self, other: object) -> bool:
+        return other in self.items
+
+
+class MatcherUnordered:
+    """Compare list contents, but do not care about ordering. (E.g. sort lists first,
+    then compare.) If you care about ordering, then just compare lists directly."""
+    def __init__(self, items):
+        self.items = sorted(items)
+
+    def __repr__(self):
+        inner = ", ".join(map(repr, self.items))
+        return f"M.unordered({inner})"
+
+    def __eq__(self, other):
+        return self.items == sorted(other)
+
+
+class MatcherIsa:
+    def __init__(self, *types):
+        assert all(isinstance(t, type) for t in types)
+        self.types = types
+
+    def __repr__(self):
+        inner = ", ".join(t.__name__ for t in self.types)
+        return f"M.isa({inner})"
+
+    def __eq__(self, other):
+        return isinstance(other, self.types)
+
+
+class Matcher:
+    """Special class to eq by existing attrs. Also provides contructors for other types of matching:
+        - regex
+        - dict
+        - unordered sequence
+        - by class
+        - "any of"
+        - any wildcard
+
+    The purpose is to simplify asserts containing objects and nested data structures, i.e.:
+
+        assert result.errors == [
+            M(message=M.re("^Smth went wrong:"), extensions=M.dict(code=523)),
+            M(message=M.any, tags=M.unordered("one", "two")),
+        ]
+
+    Here all the structures like lists and dicts are followed as usual both outside and inside
+    a mather object. These could be freely intermixed.
+    """
+    def __init__(self, **attrs):
+        self.attrs = attrs
+
+    def __repr__(self):
+        name = "M"
+        attrs = self.attrs
+        if "__class__" in attrs:
+            name += "." + attrs["__class__"].__name__
+            attrs = {k: v for k, v in attrs.items() if k != "__class__"}
+        return f"{name}({', '.join(f'{k}={repr(v)}' for k, v in attrs.items())})"
+
+    def __eq__(self, other):
+        # Unforturnately this doesn't work with classes with slots
+        # self.__class__ = other.__class__
+        missing = object()
+        return all(getattr(other, name, missing) == v for name, v in self.attrs.items())
+
+    any = MatcherAny()
+
+    @staticmethod
+    def any_of(*items):
+        return MatcherAnyOf(*items)
+
+    @staticmethod
+    def re(pattern, flags=0):
+        return MatcherRegex(pattern, flags)
+
+    @staticmethod
+    def dict(_d=None, **keys):
+        return MatcherDict(_d, **keys)
+
+    @staticmethod
+    def unordered(*elems):
+        return MatcherUnordered(elems)
+
+    @staticmethod
+    def isa(*elems):
+        return MatcherIsa(*elems)
+
+    def approx(expected, rel=None, abs=None, nan_ok=False):
+        from .approx import approx  # Requires pytest
+
+        return approx(expected, rel=rel, abs=abs, nan_ok=nan_ok)

assert_matcher/plugin.py

@@ -0,0 +1,9 @@
+import pytest
+
+from .matchers import Matcher
+from .compare import pytest_assertrepr_compare  # noqa
+
+
+@pytest.fixture
+def M():
+    return Matcher

assert_matcher-0.9.dist-info/METADATA

@@ -0,0 +1,224 @@
+Metadata-Version: 2.4
+Name: assert-matcher
+Version: 0.9
+Summary: Makes comparing nested data structures easy and glancable
+Author: Alexander Schepanovski
+Author-email: suor.web@gmail.com
+License: BSD-2-Clause
+Keywords: tests
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+
+# Assert Matcher [![Build Status](https://github.com/Suor/assert-matcher/actions/workflows/ci.yml/badge.svg)](https://github.com/Suor/assert-matcher/actions/workflows/test.yml?query=branch%3Amaster)
+
+The purpose of this library is to simplify asserts containing objects and nested data structures, i.e.:
+
+```python
+def test_smth(M):  # A special Matcher fixture
+    # ...
+    assert result.errors == [
+        M(message=M.re("^Smth went wrong:"), extensions=M.dict(code=523)),
+        M(message=M.any, tags=M.unordered("one", "two")),
+    ]
+```
+
+Here all the structures like lists and dicts are followed as usual both outside and inside
+a matcher object, while the matcher object and other helpers provide their own equality. These could be freely intermixed.
+
+Alternatively may import Matcher directly this is more verbose but also more universal, i.e. works outside of pytest:
+
+```python
+from assert_matcher import Matcher as M
+```
+
+
+## Installation
+
+```bash
+pip install git+https://github.com/Suor/assert-matcher.git@master
+# pip install assert-matcher  # not released yet
+```
+
+## Matchers
+
+The `M` fixture provides a number of matchers to help you write more expressive assertions.
+
+#### `M(**attrs)`
+
+Matches an object's attributes.
+
+```python
+User = namedtuple("User", ["name", "email", "is_active"])
+
+users = [User("Alice", "alice@example.com", True), User("Bob", "bob@example.com", False)]
+
+assert users == [
+    M(name="Alice", is_active=True),
+    M(name="Bob", is_active=False),
+]
+```
+
+#### `M.re(pattern, flags=0)`
+
+Matches a string against a regular expression using `re.search`.
+
+```python
+assert "hello world" == M.re(r"h.*o")
+```
+
+#### `M.dict(d=None, **kwargs)`
+
+Matches a dictionary against a subset of keys. It checks that the keys exist and their values match, but ignores other keys.
+
+```python
+assert {"a": 1, "b": 2} == M.dict(a=1)
+```
+
+#### M.any
+
+Matches any value. This is useful when you want to ignore a particular field value in a larger data structure, but still want to test for a key presence.
+
+```python
+assert {"a": 1, "b": 2, "c": "hi"} == M.dict(a=1, b=M.any)
+```
+
+#### `M.any_of(*items)`
+
+Matches if the value is one of the provided items.
+
+```python
+assert "a" == M.any_of("a", "b", "c")
+```
+
+#### `M.unordered(*items)`
+
+Compares a list to the provided items, ignoring the order.
+
+```python
+assert [1, 2, 3] == M.unordered(3, 1, 2)
+```
+
+#### `M.isa(*types)`
+
+Checks if an object is an instance of one of the provided types.
+
+```python
+assert "hello" == M.isa(str)
+assert 42 == M.isa(int, float)
+```
+
+#### `M.approx(expected, rel=None, abs=None, nan_ok=False)`
+
+Performs approximate comparison of numbers. It's a wrapper around `pytest.approx`.
+
+```python
+assert 0.1 + 0.2 == M.approx(0.3)
+```
+
+## Running tests
+
+To run the tests using your default python:
+
+```
+pip install -r test_requirements.txt
+pytest
+```
+
+To fully run `tox` you need all the supported pythons to be installed. These are
+3.7+ and PyPy3. You can run it for particular environment even in absense
+of all of the above:
+
+```
+tox -e py310
+tox -e pypy3
+tox -e lint
+```
+
+## Pytest Plugin
+
+`assert-matcher` provides enhanced assertion representation for pytest, making diffs for nested data structures more readable when using `Matcher` objects.
+
+When a test fails, pytest usually prints a diff of the two objects that were compared. However, these diffs can be hard to read. `assert-matcher` plugin overrides the default diff representation to pinpoint an exact path and difference.
+
+For example, consider the following failing test:
+
+```python
+def test_user(M):
+    user = User("Alice", "alice@example.com", True)
+    assert user == M(name="Bob", is_active=False)
+```
+
+Without the plugin, the diff would look something like this:
+
+```
+E   AssertionError: assert User(name='Alice', email='alice@example.com', is_active=True) == M(name='Bob', is_active=False)
+E    +  where M(name='Bob', is_active=False) = <class 'assert_matcher.matchers.Matcher'>(name='Bob', is_active=False)
+```
+
+With the `assert-matcher` plugin enabled, the diff is much more readable:
+
+```
+E   AssertionError: assert User(name=...tive=True) == M(name='Bo...ive=False)
+E     name: 'Alice' != 'Bob'
+E     is_active: True != False
+```
+
+This is even more useful when you compare nested data structures. For example, consider the following test:
+
+```python
+def test_nested_structure(M):
+    result = {
+        "users": [alice, bob],
+        "meta": ...
+    }
+    expected = {
+        "users": [
+            M(name="Alice", status="active"),
+            M(name="Bob", email=M.re(r"@example\.com$")),
+        ],
+        "meta": M.any
+    }
+    assert result == expected
+```
+
+Without the plugin, the diff is hard to read (imagine these objects having 10+ fields):
+
+```
+E   AssertionError: assert {'meta': {'er... 'inactive'}]} == {'meta': M.di...ample.com$')]}
+E
+E     Omitting 1 identical items, use -vv to show
+E     Differing items:
+E     {'users': [{'email': 'alice@example.com', 'name': 'Alice', 'status': 'active'}, {'email': 'bob@invalid', 'name': 'Bob', 'status': 'inactive'}]} != {'users': [M.dict(name='Alice', status='active'), M.dict(name='Bob', email=r'@example.com$')]}
+E     Use -v to get more diff
+```
+
+With the plugin, the diff is much more concise and points to the exact location of the error:
+
+```
+E   AssertionError: assert {'meta': {...active'}} == {'meta': M...e.com$')]}
+E     users[1].email: 'bob@invalid' != r'@example.com$'
+```

assert_matcher-0.9.dist-info/RECORD

@@ -0,0 +1,11 @@
+assert_matcher/__init__.py,sha256=OtKAcQua1NGDSb_UJWgSKQ6Und0i3CWwIdvGt96b28k,16
+assert_matcher/approx.py,sha256=LrbDnmNy8erhEYEGkZtlBBjEceXlDocH0BHHCq1ClAI,1084
+assert_matcher/compare.py,sha256=-tG7RWwC4wUlgZXqtKNcpkV1kUy1RH8ZczVzvBo2hXs,8029
+assert_matcher/matchers.py,sha256=svL5bIxiM71hHogMzD6sA-32_dojQ17fmyq8WpD7QCw,4318
+assert_matcher/plugin.py,sha256=1W-YbroJpko0stx0eywCWGUld0tbNoqXT9Rj_5r12IE,146
+assert_matcher-0.9.dist-info/licenses/LICENSE,sha256=RDmD_AtTfAXUlLdoR9RTYntoB34bkQ2riQAtvXaFpjw,1335
+assert_matcher-0.9.dist-info/METADATA,sha256=TcGbFHNDbvVW79tuuK23eNNt99Kwzu49ljLShAvSU-s,6782
+assert_matcher-0.9.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+assert_matcher-0.9.dist-info/entry_points.txt,sha256=HlJ0VQCbODwgXH4mAvzAsGLzc0PNXvhJLSCvaR9EdtY,50
+assert_matcher-0.9.dist-info/top_level.txt,sha256=z13M84xUaDjLpcq-slO9ulLr5iXa9g_oNws68BL6l-k,15
+assert_matcher-0.9.dist-info/RECORD,,

assert_matcher-0.9.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

assert_matcher-0.9.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+assert_matcher = assert_matcher.plugin

assert_matcher-0.9.dist-info/licenses/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2022-2026, Alexander Schepanovski.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

assert_matcher-0.9.dist-info/top_level.txt

@@ -0,0 +1 @@
+assert_matcher