assertpy2 2.8.1__tar.gz → 2.9.0__tar.gz

{assertpy2-2.8.1 → assertpy2-2.9.0}/.github/workflows/ci.yml

@@ -68,7 +68,7 @@ jobs:
           python-version: "3.14"
 
       - name: Install dependencies
-        run: uv sync --extra json
+        run: uv sync --extra json --group typecheck
 
       - name: Ruff check
         run: uv run ruff check .
@@ -76,5 +76,11 @@ jobs:
       - name: Ruff format check
         run: uv run ruff format --check .
 
-      - name: Type check
-        run: uv run ty check assertpy2/
+      - name: Type check (ty)
+        run: uv run ty check assertpy2/ tests/test_typing.py
+
+      - name: Type check (mypy --strict, public typing surface)
+        run: uv run mypy --strict --follow-imports=silent tests/test_typing.py
+
+      - name: Type check (pyright, public typing surface)
+        run: uv run pyright tests/test_typing.py

assertpy2-2.9.0/.github/workflows/mutation.yml

@@ -0,0 +1,63 @@
+name: Mutation
+
+on:
+  schedule:
+    - cron: "0 4 * * 1" # weekly, Monday 04:00 UTC
+  workflow_dispatch: {}
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: true
+
+jobs:
+  mutation:
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    strategy:
+      fail-fast: false
+      matrix:
+        module: [base, numeric, string, contains, collection, dict, date, matchers, helpers]
+    steps:
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        with:
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.14"
+
+      - name: Install dependencies
+        run: uv sync --extra json --group mutation
+
+      - name: Run mutation testing
+        env:
+          MODULE: ${{ matrix.module }}
+        run: |
+          cat > cosmic-ray.toml <<EOF
+          [cosmic-ray]
+          module-path = "assertpy2/${MODULE}.py"
+          timeout = 30.0
+          excluded-modules = []
+          test-command = ".venv/bin/python -m pytest tests/ -x -q -p no:cacheprovider"
+
+          [cosmic-ray.distributor]
+          name = "local"
+          EOF
+          uv run cosmic-ray baseline cosmic-ray.toml
+          uv run cosmic-ray init cosmic-ray.toml session.sqlite
+          uv run cosmic-ray exec cosmic-ray.toml session.sqlite
+          {
+            echo "### Mutation: ${MODULE}.py"
+            echo ""
+            echo "Surviving mutants: $(uv run cr-rate session.sqlite)%"
+          } >> "$GITHUB_STEP_SUMMARY"
+          echo "::group::Surviving mutants (${MODULE}.py)"
+          uv run cr-report session.sqlite
+          echo "::endgroup::"

{assertpy2-2.8.1 → assertpy2-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.8.1
+Version: 2.9.0
 Summary: Fluent assertion library for Python with composable matchers, structural matching, and full type safety
 Project-URL: Homepage, https://github.com/Solganis/assertpy2
 Project-URL: Repository, https://github.com/Solganis/assertpy2
@@ -119,7 +119,7 @@ assertpy2 reports the [exact path to every difference](https://solganis.github.i
 assert_that(response).is_equal_to(expected)
 ```
 
-<img src="docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: status and user.role shown with their paths, removals in red and additions in green">
+<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: status and user.role shown with their paths, removals in red and additions in green">
 
 Recursive diffs work for dicts, dataclasses, namedtuples, attrs, and Pydantic models.
 For responses with dynamic fields (IDs, timestamps), validate a subset with

{assertpy2-2.8.1 → assertpy2-2.9.0}/README.md

@@ -81,7 +81,7 @@ assertpy2 reports the [exact path to every difference](https://solganis.github.i
 assert_that(response).is_equal_to(expected)
 ```
 
-<img src="docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: status and user.role shown with their paths, removals in red and additions in green">
+<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: status and user.role shown with their paths, removals in red and additions in green">
 
 Recursive diffs work for dicts, dataclasses, namedtuples, attrs, and Pydantic models.
 For responses with dynamic fields (IDs, timestamps), validate a subset with

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/_mixin_base.py

@@ -58,15 +58,22 @@ class _MixinBase:
 
         def _validate_close_to_args(self, val: object, other: object, tolerance: object) -> None: ...
 
-        def _check_dict_like(
+        def _is_dict_like(
+            self,
+            d: object,
+            check_keys: bool = ...,
+            check_values: bool = ...,
+            check_getitem: bool = ...,
+        ) -> bool: ...
+
+        def _require_dict_like(
             self,
             d: object,
             check_keys: bool = ...,
             check_values: bool = ...,
             check_getitem: bool = ...,
             name: str = ...,
-            return_as_bool: bool = ...,
-        ) -> bool | None: ...
+        ) -> None: ...
 
         def _check_iterable(self, val: object, check_getitem: bool = ..., name: str = ...) -> None: ...
 

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/_typing.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Hashable
     from pathlib import Path
     from typing import Any, Protocol
 
@@ -12,12 +12,17 @@ if TYPE_CHECKING:
     from .async_assertions import AsyncAssertionBuilder
     from .matchers import Matcher
 
+    # ``ignore``/``include`` accept a single key, a nested-path tuple, or a list/set/frozenset of them.
+    _KeySpecs = Hashable | list[Hashable] | set[Hashable] | frozenset[Hashable]
+
     class _CoreAssertion(Protocol):
         """Base protocol with assertions available for all types."""
 
         # BaseMixin
         def described_as(self, description: str) -> Self: ...
-        def is_equal_to(self, other: object, **kwargs: object) -> Self: ...
+        def is_equal_to(
+            self, other: object, *, ignore: _KeySpecs | None = ..., include: _KeySpecs | None = ...
+        ) -> Self: ...
         def is_not_equal_to(self, other: object) -> Self: ...
         def is_same_as(self, other: object) -> Self: ...
         def is_not_same_as(self, other: object) -> Self: ...

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/assertpy.py

@@ -48,37 +48,15 @@ from .snapshot import SnapshotMixin
 from .string import StringMixin
 from .warning import WarningMixin
 
-__version__ = "2.8.1"
+__version__ = "2.9.0"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch
 
-# assertpy files
+# assertpy2 source files, used to strip internal frames when locating the caller for warn-mode messages.
+# Derived from the package directory so new modules are covered automatically (no hand-maintained list).
 ASSERTPY_FILES: Final = [
-    os.path.join("assertpy2", file)
-    for file in [
-        "assertpy.py",
-        "async_assertions.py",
-        "base.py",
-        "bytes_mixin.py",
-        "collection.py",
-        "contains.py",
-        "date.py",
-        "dict.py",
-        "dynamic.py",
-        "errors.py",
-        "exception.py",
-        "extracting.py",
-        "file.py",
-        "helpers.py",
-        "json_mixin.py",
-        "matchers.py",
-        "numeric.py",
-        "pytest_plugin.py",
-        "snapshot.py",
-        "string.py",
-        "warning.py",
-    ]
+    os.path.join("assertpy2", name) for name in os.listdir(os.path.dirname(__file__)) if name.endswith(".py")
 ]
 
 # soft assertions (contextvars for thread/async safety)
@@ -619,7 +597,7 @@ class AssertionBuilder(
     def error(self, msg, *, actual=None, expected=None, diff=None) -> Self:
         """Helper to raise an ``AssertionError`` with the given message.
 
-        If an error description is set by :meth:`~assertpy.base.BaseMixin.described_as`, then that
+        If an error description is set by :meth:`~assertpy2.base.BaseMixin.described_as`, then that
         description is prepended to the error message.
 
         When structured data (``actual``, ``expected``, or ``diff``) is provided, raises

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/async_assertions.py

@@ -61,10 +61,9 @@ class AsyncAssertionBuilder:
                 last_error: AssertionError | None = None
                 while True:
                     try:
-                        if inspect.iscoroutinefunction(self._func):
-                            val = await self._func()
-                        else:
-                            val = self._func()
+                        val = self._func()
+                        if inspect.isawaitable(val):
+                            val = await val
                         builder = self._builder_func(val, self._description)
                         method = getattr(builder, name)
                         method(*args, **kwargs)

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/base.py

@@ -53,8 +53,8 @@ class BaseMixin(_MixinBase):
             **kwargs: see below
 
         Keyword Args:
-            ignore: the key/field (or list of keys/fields) to ignore
-            include: the key/field (or list of keys/fields) to include
+            ignore: the key/field (or list/set/frozenset of keys/fields) to ignore
+            include: the key/field (or list/set/frozenset of keys/fields) to include
 
         Examples:
             Usage::
@@ -114,21 +114,21 @@ class BaseMixin(_MixinBase):
 
         Raises:
             AssertionError: if actual is **not** equal to expected
+            TypeError: if ``ignore``/``include`` is a one-shot or otherwise unsupported iterable, or is
+                used on a value that is neither dict-like nor has introspectable fields
 
         Tip:
             Using :meth:`is_equal_to` with a ``float`` val is just asking for trouble. Instead, you'll
-            always want to use *fuzzy* numeric assertions like :meth:`~assertpy.numeric.NumericMixin.is_close_to`
-            or :meth:`~assertpy.numeric.NumericMixin.is_between`.
+            always want to use *fuzzy* numeric assertions like :meth:`~assertpy2.numeric.NumericMixin.is_close_to`
+            or :meth:`~assertpy2.numeric.NumericMixin.is_between`.
 
         See Also:
-            :meth:`~assertpy.string.StringMixin.is_equal_to_ignoring_case` - for case-insensitive string equality
+            :meth:`~assertpy2.string.StringMixin.is_equal_to_ignoring_case` - for case-insensitive string equality
         """
         ignore = kwargs.get("ignore")
         include = kwargs.get("include")
 
-        if self._check_dict_like(self.val, check_values=False, return_as_bool=True) and self._check_dict_like(
-            other, check_values=False, return_as_bool=True
-        ):
+        if self._is_dict_like(self.val, check_values=False) and self._is_dict_like(other, check_values=False):
             if self._dict_not_equal(self.val, other, ignore=ignore, include=include):
                 self._dict_err(self.val, other, ignore=ignore, include=include)
         elif ignore or include:

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/collection.py

@@ -18,6 +18,12 @@ __tracebackhide__ = True
 class CollectionMixin(_MixinBase):
     """Collection assertions mixin."""
 
+    def _as_list(self) -> list[Any]:
+        """Returns val as a list, raising TypeError if val is not iterable."""
+        if not isinstance(self.val, collections.abc.Iterable):
+            raise TypeError("val is not iterable")
+        return list(self.val)
+
     def is_iterable(self) -> Self:
         """Asserts that val is iterable.
 
@@ -96,7 +102,7 @@ class CollectionMixin(_MixinBase):
         if is_mapping_like(self.val):
             superdict = {}
             for superset_index, superset in enumerate(supersets):
-                self._check_dict_like(superset, check_values=False, name=f"arg #{superset_index + 1}")
+                self._require_dict_like(superset, check_values=False, name=f"arg #{superset_index + 1}")
                 for key in superset:
                     superdict.update({key: superset[key]})
 
@@ -107,7 +113,7 @@ class CollectionMixin(_MixinBase):
                     missing.append({key: self.val[key]})  # bad val
             if missing:
                 return self.error(
-                    f"Expected <{self.val}> to be subset of {self._fmt_items(superdict)}, "
+                    f"Expected <{self.val}> to be subset of <{superdict}>, "
                     f"but {self._fmt_items(missing)} {'was' if len(missing) == 1 else 'were'} missing."
                 )
         else:
@@ -253,9 +259,7 @@ class CollectionMixin(_MixinBase):
         Raises:
             ValueError: if val is empty
         """
-        if not isinstance(self.val, collections.abc.Iterable):
-            raise TypeError("val is not iterable")
-        items = list(self.val)
+        items = self._as_list()
         if not items:
             raise ValueError("Expected non-empty iterable, but was empty.")
         return self.builder(items[0], self.description, self.kind)
@@ -274,9 +278,7 @@ class CollectionMixin(_MixinBase):
         Raises:
             ValueError: if val is empty
         """
-        if not isinstance(self.val, collections.abc.Iterable):
-            raise TypeError("val is not iterable")
-        items = list(self.val)
+        items = self._as_list()
         if not items:
             raise ValueError("Expected non-empty iterable, but was empty.")
         return self.builder(items[-1], self.description, self.kind)
@@ -298,9 +300,7 @@ class CollectionMixin(_MixinBase):
         Raises:
             IndexError: if index is out of range
         """
-        if not isinstance(self.val, collections.abc.Iterable):
-            raise TypeError("val is not iterable")
-        items = list(self.val)
+        items = self._as_list()
         if index < 0 or index >= len(items):
             raise IndexError(f"Expected index {index} to be in range [0, {len(items)}), but was out of range.")
         return self.builder(items[index], self.description, self.kind)
@@ -319,9 +319,7 @@ class CollectionMixin(_MixinBase):
         Raises:
             ValueError: if val is empty or has more than one element
         """
-        if not isinstance(self.val, collections.abc.Iterable):
-            raise TypeError("val is not iterable")
-        items = list(self.val)
+        items = self._as_list()
         if not items:
             raise ValueError("Expected iterable with single element, but was empty.")
         if len(items) > 1:

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/contains.py

@@ -42,25 +42,31 @@ class ContainsMixin(_MixinBase):
             AssertionError: if val does **not** contain the item or items
 
         Tip:
-            Use the :meth:`~assertpy.dict.DictMixin.contains_key` alias when working with
+            Use the :meth:`~assertpy2.dict.DictMixin.contains_key` alias when working with
             *dict-like* objects to be self-documenting.
 
         See Also:
-            :meth:`~assertpy.string.StringMixin.contains_ignoring_case` - for case-insensitive string contains
+            :meth:`~assertpy2.string.StringMixin.contains_ignoring_case` - for case-insensitive string contains
         """
         if len(items) == 0:
             raise ValueError("one or more args must be given")
         elif len(items) == 1:
-            if isinstance(items[0], Matcher):
-                if not any(items[0].matches(value) for value in self.val):
+            item = items[0]
+            if isinstance(item, Matcher):
+                if not any(item.matches(value) for value in self.val):
+                    diff = DiffResult(
+                        kind="contains", entries=[DiffEntry(path="missing", actual=None, expected=item.describe())]
+                    )
                     return self.error(
-                        f"Expected <{self.val}> to contain item matching {items[0].describe()}, but did not."
+                        f"Expected <{self.val}> to contain item matching {item.describe()}, but did not.",
+                        diff=diff,
                     )
-            elif items[0] not in self.val:
-                if self._check_dict_like(self.val, return_as_bool=True):
-                    return self.error(f"Expected <{self.val}> to contain key <{items[0]}>, but did not.")
+            elif item not in self.val:
+                diff = DiffResult(kind="contains", entries=[DiffEntry(path="missing", actual=None, expected=item)])
+                if self._is_dict_like(self.val):
+                    return self.error(f"Expected <{self.val}> to contain key <{item}>, but did not.", diff=diff)
                 else:
-                    return self.error(f"Expected <{self.val}> to contain item <{items[0]}>, but did not.")
+                    return self.error(f"Expected <{self.val}> to contain item <{item}>, but did not.", diff=diff)
         else:
             missing = []
             for item in items:
@@ -80,10 +86,10 @@ class ContainsMixin(_MixinBase):
                         DiffEntry(path="missing", actual=None, expected=missing_item) for missing_item in missing_desc
                     ],
                 )
-                if self._check_dict_like(self.val, return_as_bool=True):
+                if self._is_dict_like(self.val):
                     return self.error(
                         f"Expected <{self.val}> to contain keys {self._fmt_items(items)}, but did not contain"
-                        f" key{'' if len(missing) == 0 else 's'} {self._fmt_items(missing_desc)}.",
+                        f" key{'' if len(missing) == 1 else 's'} {self._fmt_items(missing_desc)}.",
                         diff=diff,
                     )
                 else:
@@ -119,7 +125,7 @@ class ContainsMixin(_MixinBase):
             AssertionError: if val **does** contain the item or items
 
         Tip:
-            Use the :meth:`~assertpy.dict.DictMixin.does_not_contain_key` alias when working with
+            Use the :meth:`~assertpy2.dict.DictMixin.does_not_contain_key` alias when working with
             *dict-like* objects to be self-documenting.
         """
         if len(items) == 0:

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/date.py

@@ -11,6 +11,12 @@ if TYPE_CHECKING:
 __tracebackhide__ = True
 
 
+def _require_datetime(value: object, label: str) -> None:
+    """Raise ``TypeError`` unless *value* is exactly a :class:`datetime.datetime`."""
+    if not isinstance(value, datetime.datetime):
+        raise TypeError(f"{label} must be datetime, but was type <{type(value).__name__}>")
+
+
 class DateMixin(_MixinBase):
     """Date and time assertions mixin."""
 
@@ -37,13 +43,11 @@ class DateMixin(_MixinBase):
             AssertionError: if val is **not** before the given date
 
         See Also:
-            :meth:`~assertpy.string.NumericMixin.is_less_than` - numeric assertion, but also works with datetime BR
-            :meth:`~assertpy.string.NumericMixin.is_less_than_or_equal_to` - also works with datetime
+            :meth:`~assertpy2.numeric.NumericMixin.is_less_than` - numeric assertion, but also works with datetime
+            :meth:`~assertpy2.numeric.NumericMixin.is_less_than_or_equal_to` - also works with datetime
         """
-        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__}>")
+        _require_datetime(self.val, "val")
+        _require_datetime(other, "given arg")
         if self.val >= other:
             return self.error(
                 f"Expected <{self.val.strftime('%Y-%m-%d %H:%M:%S')}> to be before"
@@ -74,13 +78,11 @@ class DateMixin(_MixinBase):
             AssertionError: if val is **not** after the given date
 
         See Also:
-            :meth:`~assertpy.string.NumericMixin.is_greater_than` - numeric assertion, but also works with datetime BR
-            :meth:`~assertpy.string.NumericMixin.is_greater_than_or_equal_to` - also works with datetime
+            :meth:`~assertpy2.numeric.NumericMixin.is_greater_than` - numeric assertion, but also works with datetime
+            :meth:`~assertpy2.numeric.NumericMixin.is_greater_than_or_equal_to` - also works with datetime
         """
-        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__}>")
+        _require_datetime(self.val, "val")
+        _require_datetime(other, "given arg")
         if self.val <= other:
             return self.error(
                 f"Expected <{self.val.strftime('%Y-%m-%d %H:%M:%S')}> to be after"
@@ -111,10 +113,8 @@ class DateMixin(_MixinBase):
         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__}>")
+        _require_datetime(self.val, "val")
+        _require_datetime(other, "given arg")
         if self.val > other:
             return self.error(
                 f"Expected <{self.val.strftime('%Y-%m-%d %H:%M:%S')}> to be before or equal to"
@@ -145,10 +145,8 @@ class DateMixin(_MixinBase):
         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__}>")
+        _require_datetime(self.val, "val")
+        _require_datetime(other, "given arg")
         if self.val < other:
             return self.error(
                 f"Expected <{self.val.strftime('%Y-%m-%d %H:%M:%S')}> to be after or equal to"
@@ -178,10 +176,8 @@ class DateMixin(_MixinBase):
         Raises:
             AssertionError: if val is **not** equal to the given date to the second
         """
-        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__}>")
+        _require_datetime(self.val, "val")
+        _require_datetime(other, "given arg")
         if (
             self.val.date() != other.date()
             or self.val.hour != other.hour
@@ -216,10 +212,8 @@ class DateMixin(_MixinBase):
         Raises:
             AssertionError: if val is **not** equal to the given date to the minute
         """
-        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__}>")
+        _require_datetime(self.val, "val")
+        _require_datetime(other, "given arg")
         if self.val.date() != other.date() or self.val.hour != other.hour or self.val.minute != other.minute:
             return self.error(
                 f"Expected <{self.val.strftime('%Y-%m-%d %H:%M')}> to be equal to"
@@ -249,10 +243,8 @@ class DateMixin(_MixinBase):
         Raises:
             AssertionError: if val is **not** equal to the given date ignoring time
         """
-        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__}>")
+        _require_datetime(self.val, "val")
+        _require_datetime(other, "given arg")
         if self.val.date() != other.date():
             return self.error(
                 f"Expected <{self.val.strftime('%Y-%m-%d')}> to be equal to"

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/dict.py

@@ -16,7 +16,7 @@ class DictMixin(_MixinBase):
     def contains_key(self, *keys) -> Self:
         """Asserts the val is a dict and contains the given key or keys.
 
-        Alias for :meth:`~assertpy.contains.ContainsMixin.contains`.
+        Alias for :meth:`~assertpy2.contains.ContainsMixin.contains`.
 
         Checks if the dict contains the given key or keys using ``in`` operator.
 
@@ -35,13 +35,13 @@ class DictMixin(_MixinBase):
         Raises:
             AssertionError: if val does **not** contain the key or keys
         """
-        self._check_dict_like(self.val, check_values=False, check_getitem=False)
+        self._require_dict_like(self.val, check_values=False, check_getitem=False)
         return self.contains(*keys)
 
     def does_not_contain_key(self, *keys) -> Self:
         """Asserts the val is a dict and does not contain the given key or keys.
 
-        Alias for :meth:`~assertpy.contains.ContainsMixin.does_not_contain`.
+        Alias for :meth:`~assertpy2.contains.ContainsMixin.does_not_contain`.
 
         Checks if the dict excludes the given key or keys using ``in`` operator.
 
@@ -60,7 +60,7 @@ class DictMixin(_MixinBase):
         Raises:
             AssertionError: if val **does** contain the key or keys
         """
-        self._check_dict_like(self.val, check_values=False, check_getitem=False)
+        self._require_dict_like(self.val, check_values=False, check_getitem=False)
         return self.does_not_contain(*keys)
 
     def contains_value(self, *values) -> Self:
@@ -83,7 +83,7 @@ class DictMixin(_MixinBase):
         Raises:
             AssertionError: if val does **not** contain the value or values
         """
-        self._check_dict_like(self.val, check_getitem=False)
+        self._require_dict_like(self.val, check_getitem=False)
         if len(values) == 0:
             raise ValueError("one or more value args must be given")
         missing = [value for value in values if value not in self.val.values()]
@@ -114,7 +114,7 @@ class DictMixin(_MixinBase):
         Raises:
             AssertionError: if val **does** contain the value or values
         """
-        self._check_dict_like(self.val, check_getitem=False)
+        self._require_dict_like(self.val, check_getitem=False)
         if len(values) == 0:
             raise ValueError("one or more value args must be given")
         else:
@@ -158,7 +158,7 @@ class DictMixin(_MixinBase):
         Raises:
             AssertionError: if val does **not** contain the entry or entries
         """
-        self._check_dict_like(self.val, check_values=False)
+        self._require_dict_like(self.val, check_values=False)
         entries = list(args) + [{key: value} for key, value in kwargs.items()]
         if len(entries) == 0:
             raise ValueError("one or more entry args must be given")
@@ -206,7 +206,7 @@ class DictMixin(_MixinBase):
         Raises:
             AssertionError: if val **does** contain the entry or entries
         """
-        self._check_dict_like(self.val, check_values=False)
+        self._require_dict_like(self.val, check_values=False)
         entries = list(args) + [{key: value} for key, value in kwargs.items()]
         if len(entries) == 0:
             raise ValueError("one or more entry args must be given")

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/dynamic.py

@@ -12,7 +12,7 @@ class DynamicMixin(_MixinBase):
     """Dynamic assertions mixin.
 
     When testing attributes of an object (or the contents of a dict), the
-    :meth:`~assertpy.base.BaseMixin.is_equal_to` assertion can be a bit verbose::
+    :meth:`~assertpy2.base.BaseMixin.is_equal_to` assertion can be a bit verbose::
 
         fred = Person('Fred', 'Smith')
 

{assertpy2-2.8.1 → assertpy2-2.9.0}/assertpy2/exception.py

@@ -28,7 +28,7 @@ class ExceptionMixin(_MixinBase):
     def raises(self, ex) -> Self:
         """Asserts that val is callable and set the expected exception.
 
-        Just sets the expected exception, but never calls val, and therefore never failes. You must
+        Just sets the expected exception, but never calls val, and therefore never fails. You must
         chain to :meth:`~when_called_with` to invoke ``val()``.
 
         Args: