assert-matcher 0.9.1__tar.gz

assert_matcher-0.9.1/.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+    - name: Lint
+      run: |
+        pip install flake8
+        flake8 assert_matcher
+        flake8 tests
+
+  test:
+    runs-on: ubuntu-22.04
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14", "pypy3.9", "pypy3.10", "pypy3.11"]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r test_requirements.txt
+        pip install -e .  # Need to install for pytest plugin to work
+    - name: Run tests
+      run: pytest -W error

assert_matcher-0.9.1/.gitignore

@@ -0,0 +1,10 @@
+*.pyc
+dist
+*.egg-info
+build
+.tags*
+.tox
+.coverage
+htmlcov
+.cache
+.pytest_cache

assert_matcher-0.9.1/CHANGELOG

@@ -0,0 +1,2 @@
+0.5
+- initial version

assert_matcher-0.9.1/GEMINI.md

@@ -0,0 +1,42 @@
+# Project Overview
+
+This project is a Python library called `assert-matcher`. Its purpose is to simplify asserts containing objects and nested data structures in tests.
+
+It will work with any test framework by overloaing equality, it also provides pytest plugin to show nice diffs with its matcher objects.
+
+The project is structured as a standard Python package with a `setup.py` file and a `assert_matcher` module.
+
+# Building and Running
+
+**Installation:**
+
+```bash
+pip install -r test_requirements.txt
+```
+
+**Running tests:**
+
+To run tests with the default python version:
+
+```bash
+pytest
+```
+
+To run tests for a specific python version with `tox`:
+
+```bash
+tox -e py310
+```
+
+To run linting checks:
+
+```bash
+flake8
+```
+
+# Development Conventions
+
+*   The code is formatted with a maximum line length of 100 characters.
+*   The project uses `flake8` for linting.
+*   Tests are located in the `tests/` directory.
+*   The project uses `tox` to automate testing in different python environments.

assert_matcher-0.9.1/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.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include CHANGELOG
+include README.md

assert_matcher-0.9.1/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: assert-matcher
+Version: 0.9.1
+Summary: Makes comparing nested data structures easy and glancable
+Home-page: http://github.com/Suor/assert-macther
+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 :: BSD License
+Classifier: Operating System :: OS Independent
+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.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

assert_matcher-0.9.1/README.md

@@ -0,0 +1,196 @@
+# 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 M
+```
+
+
+## Installation
+
+```bash
+pip install assert-matcher
+pip install git+https://github.com/Suor/assert-matcher.git@master  # the newest one
+```
+
+
+## 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),
+]
+
+# May test class if that is important
+assert user == M(__class__=User, name="Alice")
+```
+
+#### `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)
+assert {"a": 1, "b": 2} == M.dict({"a": 1})  # same
+```
+
+#### 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)
+assert end_time == M.approx(start_time + timedelta(seconds=1), abs=0.1)
+```
+
+
+## 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.9+ and PyPy3. You can run it for particular environment even in absense
+of all of the above:
+
+```
+tox -e py314
+tox -e pypy311
+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.1/assert_matcher/__init__.py

@@ -0,0 +1,2 @@
+VERSION = '0.9.1'
+from .matchers import Matcher, Matcher as M  # noqa

assert_matcher-0.9.1/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-0.9.1/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-0.9.1/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-0.9.1/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.1/assert_matcher.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: assert-matcher
+Version: 0.9.1
+Summary: Makes comparing nested data structures easy and glancable
+Home-page: http://github.com/Suor/assert-macther
+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 :: BSD License
+Classifier: Operating System :: OS Independent
+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.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

assert_matcher-0.9.1/assert_matcher.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+.gitignore
+CHANGELOG
+GEMINI.md
+LICENSE
+MANIFEST.in
+README.md
+publish.sh
+setup.cfg
+setup.py
+test_requirements.txt
+tox.ini
+.github/workflows/ci.yml
+assert_matcher/__init__.py
+assert_matcher/approx.py
+assert_matcher/compare.py
+assert_matcher/matchers.py
+assert_matcher/plugin.py
+assert_matcher.egg-info/PKG-INFO
+assert_matcher.egg-info/SOURCES.txt
+assert_matcher.egg-info/dependency_links.txt
+assert_matcher.egg-info/entry_points.txt
+assert_matcher.egg-info/top_level.txt
+tests/test_compare.py
+tests/test_matchers.py

assert_matcher-0.9.1/assert_matcher.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

assert_matcher-0.9.1/assert_matcher.egg-info/entry_points.txt

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

assert_matcher-0.9.1/assert_matcher.egg-info/top_level.txt

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

assert_matcher-0.9.1/publish.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/bash
+
+set -ex
+
+NAME=assert_matcher
+VERSION=`awk '/VERSION = /{gsub(/'\''/, "", $3); print $3}' assert_matcher/__init__.py`
+
+echo "Publishing $NAME-$VERSION..."
+python setup.py sdist bdist_wheel
+twine check dist/$NAME-$VERSION*
+twine upload --skip-existing -u__token__ dist/$NAME-$VERSION*

assert_matcher-0.9.1/setup.cfg

@@ -0,0 +1,50 @@
+[metadata]
+name = assert-matcher
+version = attr: assert_matcher.VERSION
+author = Alexander Schepanovski
+author_email = suor.web@gmail.com
+url = http://github.com/Suor/assert-macther
+description = Makes comparing nested data structures easy and glancable
+long_description = file: README.rst
+long_description_content_type = text/markdown
+keywords = tests
+license = BSD-2-Clause
+license_files = LICENSE
+classifiers = 
+	Development Status :: 4 - Beta
+	Framework :: Pytest
+	Intended Audience :: Developers
+	License :: OSI Approved :: BSD License
+	Operating System :: OS Independent
+	Programming Language :: Python
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3 :: Only
+	Programming Language :: Python :: 3.9
+	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.12
+	Programming Language :: Python :: 3.13
+	Programming Language :: Python :: 3.14
+	Programming Language :: Python :: Implementation :: CPython
+	Programming Language :: Python :: Implementation :: PyPy
+	Topic :: Software Development :: Testing
+	Topic :: Utilities
+
+[options]
+packages = find:
+python_requires = >=3.9
+
+[options.entry_points]
+pytest11 = 
+	assert_matcher = assert_matcher.plugin
+
+[bdist_wheel]
+universal = 1
+
+[tool:pytest]
+minversion = 7.1.2
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

assert_matcher-0.9.1/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+
+setup()

assert_matcher-0.9.1/test_requirements.txt

@@ -0,0 +1 @@
+pytest

assert_matcher-0.9.1/tests/test_compare.py

@@ -0,0 +1,99 @@
+from itertools import takewhile
+from unittest.mock import Mock
+from assert_matcher.compare import compare, to_lines
+
+
+_config = Mock()
+_config.get_terminal_writer.return_value._highlight = lambda source, lexer="python": source
+_config.get_verbosity.return_value = 0
+_config.getoption.return_value = 0  # older pytest versions
+
+
+def comp_eq(left, right):
+    lines = to_lines(compare(_config, "==", left, right))
+    # Filter out pytest's verbose hints that vary between local and CI environments
+    # On CI: pytest shows "Full diff:" when running_on_ci() is True
+    # Locally: pytest shows "Use -v to get more diff" when verbose is low
+    return list(takewhile(
+        lambda line: line.strip() not in ("Use -v to get more diff", "Full diff:"),
+        # Also skip whitespace-only strings, these are pytest version dependent
+        (line for line in lines if not line.isspace())
+    ))
+
+
+def test_list(M):
+    assert comp_eq([1, 2], [1, 3]) == ["[1]: 2 != 3"]
+    assert comp_eq([1, 2, 3], [1, 2]) == ["Left contains one more item: 3"]
+    assert comp_eq([1, 2], [1, 2, 3, 4]) == ["Right contains 2 more items, first one: 3"]
+    assert comp_eq([1, 2], [1, 0, 2]) == [
+        "First mismatch:",
+        "[1]: 2 != 0",
+        "Right contains one more item: 2",
+    ]
+    assert comp_eq([1, [2, 3]], [1, [3, 3]]) == ["[1][0]: 2 != 3"]
+
+
+def test_dict(M):
+    assert comp_eq({"a": 1, "b": 2}, M.dict(a=2)) == ["a: 1 != 2"]
+    assert comp_eq({"a": {"b": 1}}, M.dict(a={"b": 2})) == ["a.b: 1 != 2"]
+    assert comp_eq({"a": {}}, M.dict(a={"b": 2, "c": 3})) == [
+        "a:",
+        "  Right contains 2 more items:",
+        "  {'b': 2, 'c': 3}",
+    ]
+
+    assert comp_eq({"a": {"b.c": 1}}, M.dict(a={"b.c": 2})) == ["a.'b.c': 1 != 2"]
+
+
+def test_nested_strings(M):
+    result = {"data": {"text": "This is a long string with some content."}}
+    expected = {"data": {"text": "This is a long string with different content."}}
+    assert comp_eq(result, expected) == [
+        "data.text:",
+        "  'This is a lo...some content.' == 'This is a lo...rent content.'",
+        "  - This is a long string with different content.",
+        "  ?                            ^^^^ ----",
+        "  + This is a long string with some content.",
+        "  ?                            ^^^",
+    ]
+
+
+def test_nested_sets(M):
+    result = {"data": {1, 2, 3}}
+    expected = {"data": {1, 2, 4}}
+    assert comp_eq(result, expected) == [
+        "data:",
+        "  {1, 2, 3} == {1, 2, 4}",
+        "  Extra items in the left set:",
+        "  3",
+        "  Extra items in the right set:",
+        "  4",
+    ]
+
+
+def test_nested_bytes(M):
+    result = {"data": b"hello"}
+    expected = {"data": b"world"}
+    assert comp_eq(result, expected) == [
+        "data:",
+        "  b'hello' == b'world'",
+        "  At index 0 diff: b'h' != b'w'",
+    ]
+
+
+# def test_nested_strings_demo(M):
+#     result = {"data": {"text": "This is a long string with some content."}}
+#     expected = {"data": {"text": "This is a long string with different content."}}
+#     assert result == expected
+
+
+# def test_nested_sets_demo(M):
+#     result = {"data": {1, 2, 3}}
+#     expected = {"data": {1, 2, 4}}
+#     assert result == expected
+
+
+# def test_nested_bytes_demo(M):
+#     result = {"data": b"hello"}
+#     expected = {"data": b"world"}
+#     assert result == expected

assert_matcher-0.9.1/tests/test_matchers.py

@@ -0,0 +1,110 @@
+from datetime import datetime, timedelta
+import re
+from types import SimpleNamespace
+
+import pytest
+
+
+def test_object(M):
+    assert repr(M(foo="foo")) == "M(foo='foo')"
+
+    obj = SimpleNamespace(foo="foo", bar="bar")
+    assert obj == M(foo="foo")
+    assert obj != M(bar="zoo")
+    assert obj != M(missing=42)
+    assert obj != M(foo="foo", more="bar")
+
+
+def test_object_class(M):
+    class A:
+        pass
+
+    assert repr(M(__class__=A, x=1, y=2)) == "M.A(x=1, y=2)"
+    assert A() == M(__class__=A)
+    assert A() != M(__class__=SimpleNamespace)
+
+
+def test_dict(M):
+    assert repr(M.dict(foo="foo", n=123)) == "M.dict(foo='foo', n=123)"
+
+    # pytest needs len() to be there when there is no explanation
+    assert len(M.dict({"a": 1, "b": 2})) == 2
+
+    actual = {"base_url": "url", "verify": "bundle", "timeout": 10}
+    assert actual == M.dict(verify="bundle", timeout=10)
+    assert actual == M.dict(actual, verify="bundle")
+    assert actual != M.dict(verify="bundle.pem")
+    assert actual != M.dict(missing=42)
+
+
+def test_dict_subclass(M):
+    class SubDict(dict):
+        pass
+
+    assert SubDict(a=1) == M.dict()
+    assert M.dict() == SubDict(a=1)
+
+
+def test_re(M):
+    assert repr(M.re(r"^plots\.csv-\w+$")) == r"r'^plots\.csv-\w+$'"
+    assert repr(M.re(r"\w+\.csv", re.I)) == r"M.re(r'\w+\.csv', 2)"
+
+    assert "500 Internal Error" == M.re(r"^500 Internal")
+    assert "200 OK" != M.re(r"^500 Internal")
+    assert "... 500" != M.re(r"^500")
+    assert "... Hostname ..." == M.re(r"host", re.I)
+
+
+def test_any(M):
+    assert repr(M.any) == "M.any"
+    assert "a" == M.any
+    assert {"x": 1, "y": 2} == {"x": 1, "y": M.any}
+
+
+def test_any_of(M):
+    assert repr(M.any_of(3, 4)) == "M.any_of(3, 4)"
+
+    assert 3 == M.any_of(3, 4)
+    assert 'x' != M.any_of(3, 4)
+    assert M.any_of(3, 4) in [0, 4]
+    assert M.any_of(3, 4) not in [0, 2]
+
+
+def test_isa(M):
+    assert repr(M.isa(str)) == "M.isa(str)"
+    assert repr(M.isa(str, bytes)) == "M.isa(str, bytes)"
+
+    assert "5" == M.isa(str) == "5"
+    assert 5 != M.isa(str) != 5
+
+    assert 5 == M.isa(int, str) == "5"
+    assert 5 != M.isa(str, bytes) == b"5"
+
+
+def test_unordered(M):
+    assert repr(M.unordered("foo", "bar")) == "M.unordered('bar', 'foo')"
+
+    assert ["c", "b", "a"] == M.unordered("a", "b", "c")
+    assert ("a", "c", "b") == M.unordered("b", "c", "a")
+    assert ["a", "b"] != M.unordered("a", "c")
+
+
+def test_approx_datetime(M):
+    assert repr(M.approx(datetime(2023, 3, 31))) == "approx(2023-03-31 00:00:00 ± 0:00:01)"
+
+    now = datetime.now()
+    delta10s = timedelta(seconds=10)
+    assert M.approx(now) == datetime.now()
+    assert M.approx(now - delta10s) != now
+    assert M.approx(now - delta10s, abs=delta10s) == now
+    assert M.approx(now - delta10s, abs=10) == now
+
+    with pytest.raises(TypeError, match="rel doesn't make sense"):
+        M.approx(now, 1)
+    with pytest.raises(TypeError, match="rel doesn't make sense"):
+        M.approx(now, rel=1)
+
+
+def test_approx_fallback(M):
+    assert M.approx(3.0 + 1e-6) == 3
+    assert M.approx([1, 2], 0.01) == [1, 2.01]

assert_matcher-0.9.1/tox.ini

@@ -0,0 +1,20 @@
+[tox]
+envlist = py39, py310, py311, py312, py313, py314, pypy39, pypy310, pypy311, lint
+
+[testenv]
+deps = -r test_requirements.txt
+commands = pytest -W error {posargs}
+
+[flake8]
+max-line-length = 100
+exclude = .tox
+
+[testenv:lint]
+basepython = python3.10
+passenv = PYTHONPATH
+deps =
+    flake8
+commands =
+    python --version
+    flake8 assert_matcher
+    flake8 tests