assertpy2 2.1.3__tar.gz → 2.2.0__tar.gz

{assertpy2-2.1.3 → assertpy2-2.2.0}/.github/workflows/ci.yml

@@ -16,10 +16,10 @@ jobs:
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
 
       - name: Install uv
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
 
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -38,7 +38,7 @@ jobs:
 
       - name: Upload coverage to Codecov
         if: matrix.python-version == '3.14'
-        uses: codecov/codecov-action@cddd853df119a48c5be31a973f8cd97e12e35e16 # v6.0.1
+        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: coverage.xml
@@ -46,10 +46,10 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
 
       - name: Install uv
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
 
       - name: Set up Python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0

{assertpy2-2.1.3 → assertpy2-2.2.0}/.github/workflows/codeql.yml

@@ -17,7 +17,7 @@ jobs:
     permissions:
       security-events: write
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - uses: github/codeql-action/init@f52b05f4acaaa234e44466e66d29050e135ea9ef # v4.36.0
         with:
           languages: python

{assertpy2-2.1.3 → assertpy2-2.2.0}/.github/workflows/publish.yml

@@ -16,10 +16,10 @@ jobs:
       contents: write
       attestations: write
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
 
       - name: Install uv
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
 
       - name: Set up Python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -30,15 +30,28 @@ jobs:
       - name: Build
         run: uv build
 
-      - name: Attest build provenance
+      - name: Attest wheel
+        id: attest-wheel
         uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
         with:
-          subject-path: dist/*
+          subject-path: dist/*.whl
+
+      - name: Attest sdist
+        id: attest-sdist
+        uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
+        with:
+          subject-path: dist/*.tar.gz
+
+      - name: Prepare provenance bundles
+        run: |
+          mkdir -p provenance
+          cp "${{ steps.attest-wheel.outputs.bundle-path }}" "provenance/$(basename dist/*.whl).sigstore.json"
+          cp "${{ steps.attest-sdist.outputs.bundle-path }}" "provenance/$(basename dist/*.tar.gz).sigstore.json"
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
 
       - name: Upload to GitHub Release
-        run: gh release upload "${{ github.event.release.tag_name }}" dist/*
+        run: gh release upload "${{ github.event.release.tag_name }}" dist/* provenance/*
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{assertpy2-2.1.3 → assertpy2-2.2.0}/.github/workflows/scorecard.yml

@@ -16,7 +16,7 @@ jobs:
       security-events: write
       id-token: write
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
         with:
           persist-credentials: false
       - uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3

{assertpy2-2.1.3 → assertpy2-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.1.3
+Version: 2.2.0
 Summary: Fluent assertion library for Python with full type safety and soft assertions
 Project-URL: Homepage, https://github.com/Solganis/assertpy2
 Project-URL: Repository, https://github.com/Solganis/assertpy2
@@ -194,7 +194,7 @@ assert_that("hello").satisfies(~match.equal_to("world"))
 assert_that(150).satisfies(match.is_negative() | match.greater_than(100))
 ```
 
-Available matchers: `equal_to`, `greater_than`, `greater_than_or_equal_to`, `less_than`, `less_than_or_equal_to`, `between`, `close_to`, `is_none`, `is_not_none`, `is_instance_of`, `has_length`, `is_empty`, `is_not_empty`, `is_positive`, `is_negative`, `contains_string`, `matches_regex`, `is_uuid`, `is_non_empty_string`, `ignore`, `each_item`, `structure`.
+Available matchers: `equal_to`, `greater_than`, `greater_than_or_equal_to`, `less_than`, `less_than_or_equal_to`, `between`, `close_to`, `is_none`, `is_not_none`, `is_instance_of`, `has_length`, `is_empty`, `is_not_empty`, `is_positive`, `is_negative`, `is_zero`, `is_even`, `is_odd`, `is_divisible_by`, `is_callable`, `is_in`, `has_property`, `contains_string`, `matches_regex`, `is_uuid`, `is_non_empty_string`, `ignore`, `each_item`, `structure`.
 
 
 ## Structural matching
@@ -347,14 +347,14 @@ assert_that({"a": 1, "b": 2, "c": 3}).snapshot()
 ```py
 from assertpy2 import add_extension
 
-def is_even(self):
-    if self.val % 2 != 0:
-        return self.error(f'{self.val} is not even!')
+def is_5(self):
+    if self.val != 5:
+        return self.error(f'{self.val} is NOT 5!')
     return self
 
-add_extension(is_even)
+add_extension(is_5)
 
-assert_that(4).is_even()
+assert_that(5).is_5()
 ```
 
 See the [full API reference](docs/api.md) for all assertion methods, examples, and advanced features.

{assertpy2-2.1.3 → assertpy2-2.2.0}/README.md

@@ -163,7 +163,7 @@ assert_that("hello").satisfies(~match.equal_to("world"))
 assert_that(150).satisfies(match.is_negative() | match.greater_than(100))
 ```
 
-Available matchers: `equal_to`, `greater_than`, `greater_than_or_equal_to`, `less_than`, `less_than_or_equal_to`, `between`, `close_to`, `is_none`, `is_not_none`, `is_instance_of`, `has_length`, `is_empty`, `is_not_empty`, `is_positive`, `is_negative`, `contains_string`, `matches_regex`, `is_uuid`, `is_non_empty_string`, `ignore`, `each_item`, `structure`.
+Available matchers: `equal_to`, `greater_than`, `greater_than_or_equal_to`, `less_than`, `less_than_or_equal_to`, `between`, `close_to`, `is_none`, `is_not_none`, `is_instance_of`, `has_length`, `is_empty`, `is_not_empty`, `is_positive`, `is_negative`, `is_zero`, `is_even`, `is_odd`, `is_divisible_by`, `is_callable`, `is_in`, `has_property`, `contains_string`, `matches_regex`, `is_uuid`, `is_non_empty_string`, `ignore`, `each_item`, `structure`.
 
 
 ## Structural matching
@@ -316,14 +316,14 @@ assert_that({"a": 1, "b": 2, "c": 3}).snapshot()
 ```py
 from assertpy2 import add_extension
 
-def is_even(self):
-    if self.val % 2 != 0:
-        return self.error(f'{self.val} is not even!')
+def is_5(self):
+    if self.val != 5:
+        return self.error(f'{self.val} is NOT 5!')
     return self
 
-add_extension(is_even)
+add_extension(is_5)
 
-assert_that(4).is_even()
+assert_that(5).is_5()
 ```
 
 See the [full API reference](docs/api.md) for all assertion methods, examples, and advanced features.

{assertpy2-2.1.3 → assertpy2-2.2.0}/assertpy2/_typing.py

@@ -27,6 +27,8 @@ if TYPE_CHECKING:
         def is_type_of(self, some_type: type) -> Self: ...
         def is_instance_of(self, some_class: type) -> Self: ...
         def is_length(self, length: int) -> Self: ...
+        def is_callable(self) -> Self: ...
+        def is_not_callable(self) -> Self: ...
         def satisfies(self, matcher: Matcher | Callable[..., bool]) -> Self: ...
         # ContainsMixin - universal
         def is_in(self, *items: object) -> Self: ...
@@ -48,6 +50,10 @@ if TYPE_CHECKING:
         def is_digit(self) -> Self: ...
         def is_lower(self) -> Self: ...
         def is_upper(self) -> Self: ...
+        def is_alphanumeric(self) -> Self: ...
+        def is_whitespace(self) -> Self: ...
+        def contains_any_of(self, *items: str) -> Self: ...
+        def contains_none_of(self, *items: str) -> Self: ...
         def is_unicode(self) -> Self: ...
         # ContainsMixin
         def contains(self, *items: object) -> Self: ...
@@ -56,6 +62,8 @@ if TYPE_CHECKING:
         def contains_sequence(self, *items: object) -> Self: ...
         def contains_duplicates(self) -> Self: ...
         def does_not_contain_duplicates(self) -> Self: ...
+        def contains_exactly(self, *items: object) -> Self: ...
+        def contains_in_order(self, *items: object) -> Self: ...
         def is_empty(self) -> Self: ...
         def is_not_empty(self) -> Self: ...
 
@@ -74,6 +82,9 @@ if TYPE_CHECKING:
         def is_less_than_or_equal_to(self, other: object) -> Self: ...
         def is_positive(self) -> Self: ...
         def is_negative(self) -> Self: ...
+        def is_even(self) -> Self: ...
+        def is_odd(self) -> Self: ...
+        def is_divisible_by(self, divisor: int) -> Self: ...
         def is_between(self, low: object, high: object) -> Self: ...
         def is_not_between(self, low: object, high: object) -> Self: ...
         def is_close_to(self, other: object, tolerance: object) -> Self: ...
@@ -89,6 +100,8 @@ if TYPE_CHECKING:
         def contains_sequence(self, *items: object) -> Self: ...
         def contains_duplicates(self) -> Self: ...
         def does_not_contain_duplicates(self) -> Self: ...
+        def contains_exactly(self, *items: object) -> Self: ...
+        def contains_in_order(self, *items: object) -> Self: ...
         def is_empty(self) -> Self: ...
         def is_not_empty(self) -> Self: ...
         # CollectionMixin
@@ -100,6 +113,9 @@ if TYPE_CHECKING:
         def extracting(self, *names: object, **kwargs: object) -> Self: ...
         # BaseMixin
         def each(self, matcher: Matcher | Callable[..., bool]) -> Self: ...
+        def any_satisfy(self, matcher: Matcher | Callable[..., bool]) -> Self: ...
+        def all_satisfy(self, matcher: Matcher | Callable[..., bool]) -> Self: ...
+        def none_satisfy(self, matcher: Matcher | Callable[..., bool]) -> Self: ...
 
     class _DictAssertion(_CoreAssertion, Protocol):
         """Assertions available for ``dict`` values."""
@@ -127,6 +143,8 @@ if TYPE_CHECKING:
 
         def is_before(self, other: object) -> Self: ...
         def is_after(self, other: object) -> Self: ...
+        def is_before_or_equal_to(self, other: object) -> Self: ...
+        def is_after_or_equal_to(self, other: object) -> Self: ...
         def is_equal_to_ignoring_milliseconds(self, other: object) -> Self: ...
         def is_equal_to_ignoring_seconds(self, other: object) -> Self: ...
         def is_equal_to_ignoring_time(self, other: object) -> Self: ...
@@ -148,5 +166,6 @@ if TYPE_CHECKING:
         """Assertions available for callable values."""
 
         def raises(self, ex: type) -> Self: ...
+        def does_not_raise(self, ex: type) -> Self: ...
         def when_called_with(self, *some_args: object, **some_kwargs: object) -> Self: ...
         def eventually(self, *, timeout: float = ..., interval: float = ...) -> AsyncAssertionBuilder: ...

{assertpy2-2.1.3 → assertpy2-2.2.0}/assertpy2/assertpy.py

@@ -73,7 +73,7 @@ from .numeric import NumericMixin
 from .snapshot import SnapshotMixin
 from .string import StringMixin
 
-__version__ = "2.1.3"
+__version__ = "2.1.4"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # monkey patch contextlib with clean py.test tracebacks

{assertpy2-2.1.3 → assertpy2-2.2.0}/assertpy2/base.py

@@ -260,6 +260,144 @@ class BaseMixin:
             )
         return self
 
+    def is_callable(self) -> Self:
+        """Asserts that val is callable.
+
+        Examples:
+            Usage::
+
+                assert_that(lambda: None).is_callable()
+                assert_that(print).is_callable()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** callable
+        """
+        if not callable(self.val):
+            return self.error(f"Expected <{self.val}> to be callable, but was not.")
+        return self
+
+    def is_not_callable(self) -> Self:
+        """Asserts that val is not callable.
+
+        Examples:
+            Usage::
+
+                assert_that(42).is_not_callable()
+                assert_that('foo').is_not_callable()
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val **is** callable
+        """
+        if callable(self.val):
+            return self.error(f"Expected <{self.val}> to not be callable, but was.")
+        return self
+
+    def any_satisfy(self, matcher) -> Self:
+        """Asserts that at least one item in val satisfies the given matcher.
+
+        Args:
+            matcher: a :class:`~assertpy2.matchers.Matcher` instance, or a callable that takes
+                a value and returns a bool
+
+        Examples:
+            Usage with matchers::
+
+                from assertpy2 import match
+
+                assert_that([1, -2, 3]).any_satisfy(match.is_negative())
+
+            Usage with callables::
+
+                assert_that([1, 2, 3]).any_satisfy(lambda x: x > 2)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if no item satisfies the matcher
+        """
+        if not isinstance(self.val, collections.abc.Iterable):
+            raise TypeError("val is not iterable")
+        if isinstance(matcher, Matcher):
+            if not any(matcher.matches(item) for item in self.val):
+                return self.error(f"Expected any item to satisfy {matcher.describe()}, but none did.")
+        elif callable(matcher):
+            if not any(matcher(item) for item in self.val):
+                return self.error(f"Expected any item to satisfy <{matcher}>, but none did.")
+        else:
+            raise TypeError("given arg must be a Matcher or callable")
+        return self
+
+    def all_satisfy(self, matcher) -> Self:
+        """Asserts that all items in val satisfy the given matcher.
+
+        Semantic alias for :meth:`each`.
+
+        Args:
+            matcher: a :class:`~assertpy2.matchers.Matcher` instance, or a callable that takes
+                a value and returns a bool
+
+        Examples:
+            Usage with matchers::
+
+                from assertpy2 import match
+
+                assert_that([1, 2, 3]).all_satisfy(match.is_positive())
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if any item does **not** satisfy the matcher
+        """
+        return self.each(matcher)
+
+    def none_satisfy(self, matcher) -> Self:
+        """Asserts that no item in val satisfies the given matcher.
+
+        Args:
+            matcher: a :class:`~assertpy2.matchers.Matcher` instance, or a callable that takes
+                a value and returns a bool
+
+        Examples:
+            Usage with matchers::
+
+                from assertpy2 import match
+
+                assert_that([1, 2, 3]).none_satisfy(match.is_negative())
+
+            Usage with callables::
+
+                assert_that([1, 2, 3]).none_satisfy(lambda x: x < 0)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if any item satisfies the matcher
+        """
+        if not isinstance(self.val, collections.abc.Iterable):
+            raise TypeError("val is not iterable")
+        if isinstance(matcher, Matcher):
+            for i, item in enumerate(self.val):
+                if matcher.matches(item):
+                    return self.error(
+                        f"Expected no item to satisfy {matcher.describe()}, but item at index {i} <{item}> did."
+                    )
+        elif callable(matcher):
+            for i, item in enumerate(self.val):
+                if matcher(item):
+                    return self.error(f"Expected no item to satisfy <{matcher}>, but item at index {i} <{item}> did.")
+        else:
+            raise TypeError("given arg must be a Matcher or callable")
+        return self
+
     def is_not_equal_to(self, other) -> Self:
         """Asserts that val is not equal to other.
 

{assertpy2-2.1.3 → assertpy2-2.2.0}/assertpy2/contains.py

@@ -349,6 +349,72 @@ class ContainsMixin:
                 return self.error("Expected not empty, but was empty.")
         return self
 
+    def contains_exactly(self, *items) -> Self:
+        """Asserts that val contains exactly the given items in the given order.
+
+        Unlike :meth:`contains_only` (which ignores order) and :meth:`contains_sequence`
+        (which allows extra items), this method requires exact count, items, and order.
+
+        Args:
+            *items: the items expected, in exact order
+
+        Examples:
+            Usage::
+
+                assert_that([1, 2, 3]).contains_exactly(1, 2, 3)
+                assert_that(['a', 'b']).contains_exactly('a', 'b')
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does **not** contain exactly the given items in order
+        """
+        if len(items) == 0:
+            raise ValueError("one or more args must be given")
+        try:
+            val_list = list(self.val)
+        except TypeError:
+            raise TypeError("val is not iterable") from None
+        if val_list != list(items):
+            return self.error(f"Expected <{self.val}> to contain exactly {self._fmt_items(items)}, but did not.")
+        return self
+
+    def contains_in_order(self, *items) -> Self:
+        """Asserts that val contains the given items in the given order (as a subsequence).
+
+        Items must appear in the given order but do not need to be contiguous.
+        Unlike :meth:`contains_sequence` which requires contiguous items.
+
+        Args:
+            *items: the items expected, in order (but not necessarily contiguous)
+
+        Examples:
+            Usage::
+
+                assert_that([1, 5, 2, 8, 3]).contains_in_order(1, 2, 3)
+                assert_that(['a', 'x', 'b', 'y', 'c']).contains_in_order('a', 'b', 'c')
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does **not** contain items in the given order
+        """
+        if len(items) == 0:
+            raise ValueError("one or more args must be given")
+        try:
+            val_list = list(self.val)
+        except TypeError:
+            raise TypeError("val is not iterable") from None
+        item_idx = 0
+        for element in val_list:
+            if item_idx < len(items) and element == items[item_idx]:
+                item_idx += 1
+        if item_idx != len(items):
+            return self.error(f"Expected <{self.val}> to contain {self._fmt_items(items)} in order, but did not.")
+        return self
+
     def is_in(self, *items) -> Self:
         """Asserts that val is equal to one of the given items.
 

{assertpy2-2.1.3 → assertpy2-2.2.0}/assertpy2/date.py

@@ -114,6 +114,74 @@ class DateMixin:
             )
         return self
 
+    def is_before_or_equal_to(self, other) -> Self:
+        """Asserts that val is a date and is before or equal to other date.
+
+        Args:
+            other: the other date, expected to be after or equal to val
+
+        Examples:
+            Usage::
+
+                import datetime
+
+                today = datetime.datetime.now()
+                yesterday = today - datetime.timedelta(days=1)
+
+                assert_that(yesterday).is_before_or_equal_to(today)
+                assert_that(today).is_before_or_equal_to(today)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** before or equal to the given date
+        """
+        if type(self.val) is not datetime.datetime:
+            raise TypeError(f"val must be datetime, but was type <{type(self.val).__name__}>")
+        if type(other) is not datetime.datetime:
+            raise TypeError(f"given arg must be datetime, but was type <{type(other).__name__}>")
+        if self.val > other:
+            return self.error(
+                f"Expected <{self.val.strftime('%Y-%m-%d %H:%M:%S')}> to be before or equal to"
+                f" <{other.strftime('%Y-%m-%d %H:%M:%S')}>, but was not."
+            )
+        return self
+
+    def is_after_or_equal_to(self, other) -> Self:
+        """Asserts that val is a date and is after or equal to other date.
+
+        Args:
+            other: the other date, expected to be before or equal to val
+
+        Examples:
+            Usage::
+
+                import datetime
+
+                today = datetime.datetime.now()
+                yesterday = today - datetime.timedelta(days=1)
+
+                assert_that(today).is_after_or_equal_to(yesterday)
+                assert_that(today).is_after_or_equal_to(today)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val is **not** after or equal to the given date
+        """
+        if type(self.val) is not datetime.datetime:
+            raise TypeError(f"val must be datetime, but was type <{type(self.val).__name__}>")
+        if type(other) is not datetime.datetime:
+            raise TypeError(f"given arg must be datetime, but was type <{type(other).__name__}>")
+        if self.val < other:
+            return self.error(
+                f"Expected <{self.val.strftime('%Y-%m-%d %H:%M:%S')}> to be after or equal to"
+                f" <{other.strftime('%Y-%m-%d %H:%M:%S')}>, but was not."
+            )
+        return self
+
     def is_equal_to_ignoring_milliseconds(self, other) -> Self:
         """Asserts that val is a date and is equal to other date to the second.
 

{assertpy2-2.1.3 → assertpy2-2.2.0}/assertpy2/exception.py

@@ -78,7 +78,7 @@ class ExceptionMixin:
         """Asserts that val, when invoked with the given args and kwargs, raises the expected exception.
 
         Invokes ``val()`` with the given args and kwargs.  You must first set the expected
-        exception with :meth:`~raises`.
+        exception with :meth:`~raises` or :meth:`~does_not_raise`.
 
         Args:
             *some_args: the args to call ``val()``
@@ -97,18 +97,20 @@ class ExceptionMixin:
 
         Raises:
             AssertionError: if val does **not** raise the expected exception
-            TypeError: if expected exception not set via :meth:`raises`
+            TypeError: if expected exception not set via :meth:`raises` or :meth:`does_not_raise`
         """
         if not self.expected:
-            raise TypeError("expected exception not set, raises() must be called first")
+            raise TypeError("expected exception not set, raises() or does_not_raise() must be called first")
+
+        if getattr(self, "_not_expected", False):
+            return self._when_called_with_not_expected(*some_args, **some_kwargs)
+
         try:
             self.val(*some_args, **some_kwargs)
         except BaseException as e:
             if issubclass(type(e), self.expected):
-                # chain on with error message
                 return self.builder(str(e), self.description, self.kind, logger=self.logger)
             else:
-                # got exception, but wrong type, so raise
                 self.error(
                     "Expected <%s> to raise <%s> when called with (%s), but raised <%s>."
                     % (
@@ -120,9 +122,47 @@ class ExceptionMixin:
                 )
                 return _InertBuilder()
 
-        # didn't fail as expected, so raise
         self.error(
             "Expected <%s> to raise <%s> when called with (%s)."
             % (self.val.__name__, self.expected.__name__, self._fmt_args_kwargs(*some_args, **some_kwargs))
         )
         return _InertBuilder()
+
+    def _when_called_with_not_expected(self, *some_args, **some_kwargs) -> Self:
+        try:
+            self.val(*some_args, **some_kwargs)
+        except BaseException as e:
+            if issubclass(type(e), self.expected):
+                self.error(
+                    f"Expected <{self.val.__name__}> to not raise <{self.expected.__name__}>"
+                    f" when called with ({self._fmt_args_kwargs(*some_args, **some_kwargs)}),"
+                    f" but did raise <{type(e).__name__}>."
+                )
+                return _InertBuilder()
+        return self
+
+    def does_not_raise(self, ex) -> Self:
+        """Asserts that val is callable and sets the not-expected exception.
+
+        Just sets the not-expected exception, but never calls val. You must
+        chain to :meth:`~when_called_with` to invoke ``val()``.
+
+        Args:
+            ex: the exception that should **not** be raised
+
+        Examples:
+            Usage::
+
+                assert_that(some_func).does_not_raise(RuntimeError).when_called_with('foo')
+
+        Returns:
+            AssertionBuilder: returns a new instance to chain to the next assertion
+        """
+        if not callable(self.val):
+            raise TypeError("val must be callable")
+        if not issubclass(ex, BaseException):
+            raise TypeError("given arg must be exception")
+
+        new_builder = self.builder(self.val, self.description, self.kind, ex, self.logger)
+        new_builder._not_expected = True
+        return new_builder

{assertpy2-2.1.3 → assertpy2-2.2.0}/assertpy2/extracting.py

@@ -180,7 +180,7 @@ class ExtractingMixin:
                     return getattr(x, name)
                 else:  # val has no attribute <foo>
                     raise ValueError("item attributes %s did no contain attribute <%s>" % (x._fields, name))
-            elif isinstance(x, collections.abc.Iterable):  # FIXME, this does __getitem__, but doesn't check for it...
+            elif isinstance(x, collections.abc.Iterable):
                 self._check_iterable(x, name="item")
                 return x[name]
             elif hasattr(x, name):

{assertpy2-2.1.3 → assertpy2-2.2.0}/assertpy2/file.py

@@ -77,7 +77,7 @@ def contents_of(file, encoding="utf-8"):
     try:
         return contents.decode(encoding, "replace")
     except AttributeError:
-        pass
+        pass  # contents is already a str, no decode needed
     # if all else fails, just return the contents "as is"
     return contents