assert-matcher 0.9.1__tar.gz → 0.9.2__tar.gz

assert_matcher-0.9.2/CHANGELOG

@@ -0,0 +1,18 @@
+0.9.2
+- support Python 3.15
+- support pytest 9.1
+- fixed package metadata: license classifier, project url, long description
+
+0.9.1
+- added convenience import: from assert_matcher import M
+- dropped Python 3.7 and 3.8 support
+
+0.9
+- first release as assert-matcher, formerly pytest-matcher
+- matchers: M(), M.dict(), M.re(), M.any, M.any_of(), M.unordered(), M.isa(), M.approx()
+- M.approx() supports datetimes
+- path-pinpointing diff output for nested structures
+- fixed nested comparison in newer pytest versions
+
+0.5
+- initial version

assert_matcher-0.9.2/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include CHANGELOG
+include README.md
+prune .github
+exclude .gitignore publish.sh CLAUDE.md

assert_matcher-0.9.2/PKG-INFO

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: assert-matcher
+Version: 0.9.2
+Summary: Makes comparing nested data structures easy and glancable
+Home-page: https://github.com/Suor/pytest-matcher
+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 :: 3.15
+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 [![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-0.9.2}/assert_matcher/__init__.py

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

{assert_matcher-0.9.1 → assert_matcher-0.9.2}/assert_matcher/compare.py

@@ -1,15 +1,20 @@
 import pprint
 from collections import defaultdict
-from collections.abc import Mapping, Set
+from collections.abc import Mapping, Sequence, Set
 from functools import partial
 from itertools import count
 
 from _pytest._io.saferepr import safeformat, saferepr
-from _pytest.assertion.util import issequence, assertrepr_compare
+# Unlike util.assertrepr_compare() this keeps its signature across pytest versions
+from _pytest.assertion import pytest_assertrepr_compare as assertrepr_compare
 
 from .matchers import Matcher, MatcherDict
 
 
+def issequence(x):
+    return isinstance(x, Sequence) and not isinstance(x, str)
+
+
 def pytest_assertrepr_compare(config, op: str, left, right):
     import shutil
     import _pytest._code

assert_matcher-0.9.2/assert_matcher.egg-info/PKG-INFO

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: assert-matcher
+Version: 0.9.2
+Summary: Makes comparing nested data structures easy and glancable
+Home-page: https://github.com/Suor/pytest-matcher
+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 :: 3.15
+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 [![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-0.9.2}/assert_matcher.egg-info/SOURCES.txt

@@ -1,15 +1,9 @@
-.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-0.9.1 → assert_matcher-0.9.2}/setup.cfg

@@ -3,9 +3,9 @@ name = assert-matcher
 version = attr: assert_matcher.VERSION
 author = Alexander Schepanovski
 author_email = suor.web@gmail.com
-url = http://github.com/Suor/assert-macther
+url = https://github.com/Suor/pytest-matcher
 description = Makes comparing nested data structures easy and glancable
-long_description = file: README.rst
+long_description = file: README.md
 long_description_content_type = text/markdown
 keywords = tests
 license = BSD-2-Clause
@@ -25,6 +25,7 @@ classifiers =
 	Programming Language :: Python :: 3.12
 	Programming Language :: Python :: 3.13
 	Programming Language :: Python :: 3.14
+	Programming Language :: Python :: 3.15
 	Programming Language :: Python :: Implementation :: CPython
 	Programming Language :: Python :: Implementation :: PyPy
 	Topic :: Software Development :: Testing

{assert_matcher-0.9.1 → assert_matcher-0.9.2}/tests/test_compare.py

@@ -7,6 +7,7 @@ _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
+_config.getini.return_value = "ndiff"  # assertion_text_diff_style, pytest 9.1+
 
 
 def comp_eq(left, right):

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

@@ -1,43 +0,0 @@
-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

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

assert_matcher-0.9.1/CHANGELOG

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

assert_matcher-0.9.1/GEMINI.md

@@ -1,42 +0,0 @@
-# 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/MANIFEST.in

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

assert_matcher-0.9.1/PKG-INFO

@@ -1,31 +0,0 @@
-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/PKG-INFO

@@ -1,31 +0,0 @@
-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/publish.sh

@@ -1,11 +0,0 @@
-#!/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/test_requirements.txt

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

assert_matcher-0.9.1/tox.ini

@@ -1,20 +0,0 @@
-[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