assertpy2 2.5.1__tar.gz → 2.7.0__tar.gz

assertpy2-2.7.0/.gitattributes

@@ -0,0 +1,2 @@
+* text=auto eol=lf
+*.{png,ico,jpg,gif} binary

assertpy2-2.7.0/.github/dependabot.yml

@@ -0,0 +1,20 @@
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: /
+    schedule:
+      interval: weekly
+    cooldown:
+      default-days: 7
+      semver-major-days: 7
+    commit-message:
+      prefix: "chore(deps)"
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "ci(deps)"

{assertpy2-2.5.1 → assertpy2-2.7.0}/.gitignore

@@ -10,6 +10,7 @@ __pycache__
 cover
 .coverage
 htmlcov
+.hypothesis
 __snapshots
 mycustompath
 

{assertpy2-2.5.1 → assertpy2-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.5.1
+Version: 2.7.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

assertpy2-2.7.0/SECURITY.md

@@ -0,0 +1,24 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported |
+|---------|-----------|
+| 2.x     | Yes       |
+| < 2.0   | No        |
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability, please report it responsibly:
+
+1. **Email**: [solganis.dev@gmail.com](mailto:solganis.dev@gmail.com)
+2. **Subject**: `[assertpy2] Security: <brief description>`
+3. Include steps to reproduce, affected versions, and potential impact
+
+Please do **not** open a public GitHub issue for security vulnerabilities.
+
+## Response Timeline
+
+- Acknowledgement: within 48 hours
+- Initial assessment: within 7 days
+- Fix or mitigation: depends on severity, typically within 30 days

{assertpy2-2.5.1 → assertpy2-2.7.0}/assertpy2/_mixin_base.py

@@ -16,6 +16,8 @@ class _MixinBase:
         expected: type[BaseException] | None
         logger: logging.LoggerAdapter
         _not_expected: bool
+        _expected_warning: type[Warning] | None
+        _return_value: object
 
         def error(
             self,
@@ -31,13 +33,23 @@ class _MixinBase:
             val: object,
             description: str = ...,
             kind: str | None = ...,
-            expected: BaseException | None = ...,
+            expected: type[BaseException] | None = ...,
             logger: logging.LoggerAdapter | None = ...,
         ) -> Self: ...
 
+        # WarningMixin (terminals dispatched from ExceptionMixin.when_called_with)
+
+        def _when_called_with_warning(
+            self, expected: type[Warning], *some_args: object, **some_kwargs: object
+        ) -> Self: ...
+
+        def _when_called_with_not_warning(
+            self, expected: type[Warning], *some_args: object, **some_kwargs: object
+        ) -> Self: ...
+
         # HelpersMixin
 
-        def _fmt_items(self, i: object) -> str: ...
+        def _fmt_items(self, items: object) -> str: ...
 
         def _fmt_args_kwargs(self, *some_args: object, **some_kwargs: object) -> str: ...
 

{assertpy2-2.5.1 → assertpy2-2.7.0}/assertpy2/_typing.py

@@ -35,7 +35,7 @@ if TYPE_CHECKING:
         def is_in(self, *items: object) -> Self: ...
         def is_not_in(self, *items: object) -> Self: ...
         # SnapshotMixin
-        def snapshot(self, id: str | None = ..., path: str = ...) -> Self: ...
+        def snapshot(self, id: str | None = ..., path: str = ...) -> Self: ...  # noqa: A002  # mirrors public snapshot() parameter
         # NegatedBuilder
         @property
         def not_(self) -> NegatedBuilder: ...
@@ -215,10 +215,24 @@ if TYPE_CHECKING:
         def is_hex_equal_to(self, expected_hex: str) -> Self: ...
         def decoded_as(self, encoding: str = ...) -> _StringAssertion: ...
 
+    class _InvokedAssertion(_StringAssertion, Protocol):
+        """Assertions available after ``when_called_with()`` captured an exception/warning message.
+
+        The captured message is a ``str`` (hence the string assertions); :meth:`returned` pivots to
+        the value the callable returned.  Its static type is unknown, so ``returned()`` exposes the
+        type-agnostic core assertions (``is_equal_to``, ``is_instance_of``, ``satisfies``, ...) -
+        type-safe by construction, never advertising methods that may not apply.
+        """
+
+        def returned(self) -> _CoreAssertion: ...
+
     class _CallableAssertion(_CoreAssertion, Protocol):
         """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 warns(self, warning: type[Warning] = ...) -> Self: ...
+        def does_not_warn(self, warning: type[Warning] = ...) -> Self: ...
+        # captured value (exception or warning message) is a str; returned() pivots to the call result
+        def when_called_with(self, *some_args: object, **some_kwargs: object) -> _InvokedAssertion: ...
         def eventually(self, *, timeout: float = ..., interval: float = ...) -> AsyncAssertionBuilder: ...

{assertpy2-2.5.1 → assertpy2-2.7.0}/assertpy2/assertpy.py

@@ -37,7 +37,7 @@ from .date import DateMixin
 from .dict import DictMixin
 from .dynamic import DynamicMixin
 from .errors import AssertionFailure
-from .exception import ExceptionMixin
+from .exception import _UNSET, ExceptionMixin
 from .extracting import ExtractingMixin
 from .file import FileMixin
 from .helpers import HelpersMixin
@@ -45,8 +45,9 @@ from .json_mixin import JsonMixin
 from .numeric import NumericMixin
 from .snapshot import SnapshotMixin
 from .string import StringMixin
+from .warning import WarningMixin
 
-__version__ = "2.5.1"
+__version__ = "2.7.0"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch
@@ -75,6 +76,7 @@ ASSERTPY_FILES = [
         "pytest_plugin.py",
         "snapshot.py",
         "string.py",
+        "warning.py",
     ]
 ]
 
@@ -555,6 +557,7 @@ class AssertionBuilder(
     FileMixin,
     ExtractingMixin,
     ExceptionMixin,
+    WarningMixin,
     DynamicMixin,
     DictMixin,
     DateMixin,
@@ -585,6 +588,8 @@ class AssertionBuilder(
         self.expected = expected
         self.logger = logger if logger else _default_logger
         self._not_expected = False
+        self._expected_warning = None
+        self._return_value = _UNSET
 
     @property
     def not_(self) -> NegatedBuilder:

{assertpy2-2.5.1 → assertpy2-2.7.0}/assertpy2/base.py

@@ -175,17 +175,17 @@ class BaseMixin(_MixinBase):
                 actual=actual,
                 expected=expected,
             )
-        for i, (a, b) in enumerate(zip(actual, expected, strict=True)):
-            a_dict = self._to_comparable_dict(a)
-            b_dict = self._to_comparable_dict(b)
-            if a_dict is not None and b_dict is not None:
-                if self._dict_not_equal(a_dict, b_dict, ignore=ignore, include=include):
-                    self._dict_err(a_dict, b_dict, ignore=ignore, include=include)
-            elif a != b:
+        for index, (actual_item, expected_item) in enumerate(zip(actual, expected, strict=True)):
+            actual_dict = self._to_comparable_dict(actual_item)
+            expected_dict = self._to_comparable_dict(expected_item)
+            if actual_dict is not None and expected_dict is not None:
+                if self._dict_not_equal(actual_dict, expected_dict, ignore=ignore, include=include):
+                    self._dict_err(actual_dict, expected_dict, ignore=ignore, include=include)
+            elif actual_item != expected_item:
                 return self.error(
-                    f"Expected item at index <{i}> to be equal to <{b}>, but was <{a}>.",
-                    actual=a,
-                    expected=b,
+                    f"Expected item at index <{index}> to be equal to <{expected_item}>, but was <{actual_item}>.",
+                    actual=actual_item,
+                    expected=expected_item,
                 )
 
     @staticmethod
@@ -202,11 +202,11 @@ class BaseMixin(_MixinBase):
             )
         _seen = _seen | {pair_key[0], pair_key[1]}
 
-        def _field_entries(a_val: object, e_val: object, path: str) -> list[DiffEntry]:
-            sub = BaseMixin._sub_diff_entries(a_val, e_val, path, _seen=_seen)
-            if sub is not None:
-                return sub
-            return [DiffEntry(path=path, actual=a_val, expected=e_val)]
+        def _field_entries(actual_value: object, expected_value: object, path: str) -> list[DiffEntry]:
+            sub_entries = BaseMixin._sub_diff_entries(actual_value, expected_value, path, _seen=_seen)
+            if sub_entries is not None:
+                return sub_entries
+            return [DiffEntry(path=path, actual=actual_value, expected=expected_value)]
 
         if (
             hasattr(actual, "_fields")
@@ -216,13 +216,13 @@ class BaseMixin(_MixinBase):
         ):
             entries: list[DiffEntry] = []
             for field in actual._fields:  # ty: ignore[not-iterable]  # guarded by hasattr check above
-                a_val = getattr(actual, field)
-                e_val = getattr(expected, field, _SENTINEL)
+                actual_value = getattr(actual, field)
+                expected_value = getattr(expected, field, _SENTINEL)
                 path = f"{_prefix}.{field}"
-                if e_val is _SENTINEL:
-                    entries.append(DiffEntry(path=path, actual=a_val, expected=None))
-                elif a_val != e_val:
-                    entries.extend(_field_entries(a_val, e_val, path))
+                if expected_value is _SENTINEL:
+                    entries.append(DiffEntry(path=path, actual=actual_value, expected=None))
+                elif actual_value != expected_value:
+                    entries.extend(_field_entries(actual_value, expected_value, path))
             for field in expected._fields:  # ty: ignore[not-iterable]  # guarded by hasattr check above
                 if not hasattr(actual, field):
                     entries.append(DiffEntry(path=f"{_prefix}.{field}", actual=None, expected=getattr(expected, field)))
@@ -234,8 +234,8 @@ class BaseMixin(_MixinBase):
             and not isinstance(expected, type)
         ):
             entries = []
-            actual_names = {f.name for f in dataclasses.fields(actual)}
-            expected_names = {f.name for f in dataclasses.fields(expected)}
+            actual_names = {field.name for field in dataclasses.fields(actual)}
+            expected_names = {field.name for field in dataclasses.fields(expected)}
             for field in sorted(actual_names | expected_names):
                 path = f"{_prefix}.{field}"
                 if field not in expected_names:
@@ -243,27 +243,27 @@ class BaseMixin(_MixinBase):
                 elif field not in actual_names:
                     entries.append(DiffEntry(path=path, actual=None, expected=getattr(expected, field)))
                 else:
-                    a_val = getattr(actual, field)
-                    e_val = getattr(expected, field)
-                    if a_val != e_val:
-                        entries.extend(_field_entries(a_val, e_val, path))
+                    actual_value = getattr(actual, field)
+                    expected_value = getattr(expected, field)
+                    if actual_value != expected_value:
+                        entries.extend(_field_entries(actual_value, expected_value, path))
             return DiffResult(kind="dataclass", entries=entries)
         if _is_model_dump_object(actual) and _is_model_dump_object(expected):
             actual_dict = actual.model_dump()  # ty: ignore[unresolved-attribute]  # guarded by _is_model_dump_object check above
             expected_dict = expected.model_dump()  # ty: ignore[unresolved-attribute]  # guarded by _is_model_dump_object check above
             entries = []
-            for k in sorted(set(actual_dict) | set(expected_dict)):
-                path = f"{_prefix}.{k}" if _prefix else f".{k}"
-                if k not in expected_dict:
-                    entries.append(DiffEntry(path=path, actual=actual_dict[k], expected=None))
-                elif k not in actual_dict:
-                    entries.append(DiffEntry(path=path, actual=None, expected=expected_dict[k]))
-                elif actual_dict[k] != expected_dict[k]:
-                    sub = BaseMixin._sub_diff_entries(actual_dict[k], expected_dict[k], path, _seen=_seen)
-                    if sub is not None:
-                        entries.extend(sub)
+            for key in sorted(set(actual_dict) | set(expected_dict)):
+                path = f"{_prefix}.{key}" if _prefix else f".{key}"
+                if key not in expected_dict:
+                    entries.append(DiffEntry(path=path, actual=actual_dict[key], expected=None))
+                elif key not in actual_dict:
+                    entries.append(DiffEntry(path=path, actual=None, expected=expected_dict[key]))
+                elif actual_dict[key] != expected_dict[key]:
+                    sub_entries = BaseMixin._sub_diff_entries(actual_dict[key], expected_dict[key], path, _seen=_seen)
+                    if sub_entries is not None:
+                        entries.extend(sub_entries)
                     else:
-                        entries.append(DiffEntry(path=path, actual=actual_dict[k], expected=expected_dict[k]))
+                        entries.append(DiffEntry(path=path, actual=actual_dict[key], expected=expected_dict[key]))
             return DiffResult(kind="model", entries=entries)
         if isinstance(actual, (list, tuple)) and isinstance(expected, (list, tuple)):
             entries = []
@@ -275,9 +275,9 @@ class BaseMixin(_MixinBase):
                 elif i >= len(expected):
                     entries.append(DiffEntry(path=path, actual=actual[i], expected=None))
                 elif actual[i] != expected[i]:
-                    sub = BaseMixin._sub_diff_entries(actual[i], expected[i], path, _seen=_seen)
-                    if sub:
-                        entries.extend(sub)
+                    sub_entries = BaseMixin._sub_diff_entries(actual[i], expected[i], path, _seen=_seen)
+                    if sub_entries:
+                        entries.extend(sub_entries)
                     else:
                         entries.append(DiffEntry(path=path, actual=actual[i], expected=expected[i]))
             return DiffResult(kind="sequence", entries=entries)
@@ -317,18 +317,18 @@ class BaseMixin(_MixinBase):
         if isinstance(actual, dict) and isinstance(expected, dict):
             child_seen = _seen | {id(actual), id(expected)}
             entries: list[DiffEntry] = []
-            for k in sorted(set(actual) | set(expected), key=repr):
-                path = f"{prefix}.{k}"
-                if k not in expected:
-                    entries.append(DiffEntry(path=path, actual=actual[k], expected=None))  # ty: ignore[invalid-argument-type]
-                elif k not in actual:
-                    entries.append(DiffEntry(path=path, actual=None, expected=expected[k]))  # ty: ignore[invalid-argument-type]
-                elif actual[k] != expected[k]:  # ty: ignore[invalid-argument-type]
-                    sub = BaseMixin._sub_diff_entries(actual[k], expected[k], path, _seen=child_seen)  # ty: ignore[invalid-argument-type]
-                    if sub is not None:
-                        entries.extend(sub)
+            for key in sorted(set(actual) | set(expected), key=repr):
+                path = f"{prefix}.{key}"
+                if key not in expected:
+                    entries.append(DiffEntry(path=path, actual=actual[key], expected=None))  # ty: ignore[invalid-argument-type]
+                elif key not in actual:
+                    entries.append(DiffEntry(path=path, actual=None, expected=expected[key]))  # ty: ignore[invalid-argument-type]
+                elif actual[key] != expected[key]:  # ty: ignore[invalid-argument-type]
+                    sub_entries = BaseMixin._sub_diff_entries(actual[key], expected[key], path, _seen=child_seen)  # ty: ignore[invalid-argument-type]
+                    if sub_entries is not None:
+                        entries.extend(sub_entries)
                     else:
-                        entries.append(DiffEntry(path=path, actual=actual[k], expected=expected[k]))  # ty: ignore[invalid-argument-type]
+                        entries.append(DiffEntry(path=path, actual=actual[key], expected=expected[key]))  # ty: ignore[invalid-argument-type]
             return entries or None
         if (
             dataclasses.is_dataclass(actual)
@@ -338,17 +338,21 @@ class BaseMixin(_MixinBase):
         ):
             child_seen = _seen | {id(actual), id(expected)}
             entries = []
-            for f in dataclasses.fields(actual):
-                a_val = getattr(actual, f.name)
-                e_val = getattr(expected, f.name, _SENTINEL)
-                if e_val is _SENTINEL:
-                    entries.append(DiffEntry(path=f"{prefix}.{f.name}", actual=a_val, expected=None))
-                elif a_val != e_val:
-                    sub = BaseMixin._sub_diff_entries(a_val, e_val, f"{prefix}.{f.name}", _seen=child_seen)
-                    if sub is not None:
-                        entries.extend(sub)
+            for field in dataclasses.fields(actual):
+                actual_value = getattr(actual, field.name)
+                expected_value = getattr(expected, field.name, _SENTINEL)
+                if expected_value is _SENTINEL:
+                    entries.append(DiffEntry(path=f"{prefix}.{field.name}", actual=actual_value, expected=None))
+                elif actual_value != expected_value:
+                    sub_entries = BaseMixin._sub_diff_entries(
+                        actual_value, expected_value, f"{prefix}.{field.name}", _seen=child_seen
+                    )
+                    if sub_entries is not None:
+                        entries.extend(sub_entries)
                     else:
-                        entries.append(DiffEntry(path=f"{prefix}.{f.name}", actual=a_val, expected=e_val))
+                        entries.append(
+                            DiffEntry(path=f"{prefix}.{field.name}", actual=actual_value, expected=expected_value)
+                        )
             return entries or None
         if (
             hasattr(actual, "_fields")
@@ -359,16 +363,20 @@ class BaseMixin(_MixinBase):
             child_seen = _seen | {id(actual), id(expected)}
             entries = []
             for field in actual._fields:  # ty: ignore[not-iterable]  # guarded by hasattr check above
-                a_val = getattr(actual, field)
-                e_val = getattr(expected, field, _SENTINEL)
-                if e_val is _SENTINEL:
-                    entries.append(DiffEntry(path=f"{prefix}.{field}", actual=a_val, expected=None))
-                elif a_val != e_val:
-                    sub = BaseMixin._sub_diff_entries(a_val, e_val, f"{prefix}.{field}", _seen=child_seen)
-                    if sub is not None:
-                        entries.extend(sub)
+                actual_value = getattr(actual, field)
+                expected_value = getattr(expected, field, _SENTINEL)
+                if expected_value is _SENTINEL:
+                    entries.append(DiffEntry(path=f"{prefix}.{field}", actual=actual_value, expected=None))
+                elif actual_value != expected_value:
+                    sub_entries = BaseMixin._sub_diff_entries(
+                        actual_value, expected_value, f"{prefix}.{field}", _seen=child_seen
+                    )
+                    if sub_entries is not None:
+                        entries.extend(sub_entries)
                     else:
-                        entries.append(DiffEntry(path=f"{prefix}.{field}", actual=a_val, expected=e_val))
+                        entries.append(
+                            DiffEntry(path=f"{prefix}.{field}", actual=actual_value, expected=expected_value)
+                        )
             for field in expected._fields:  # ty: ignore[not-iterable]  # guarded by hasattr check above
                 if not hasattr(actual, field):
                     entries.append(DiffEntry(path=f"{prefix}.{field}", actual=None, expected=getattr(expected, field)))
@@ -378,18 +386,20 @@ class BaseMixin(_MixinBase):
             actual_dict = actual.model_dump()  # ty: ignore[unresolved-attribute]  # guarded by _is_model_dump_object check above
             expected_dict = expected.model_dump()  # ty: ignore[unresolved-attribute]  # guarded by _is_model_dump_object check above
             entries = []
-            for k in sorted(set(actual_dict) | set(expected_dict)):
-                path = f"{prefix}.{k}"
-                if k not in expected_dict:
-                    entries.append(DiffEntry(path=path, actual=actual_dict[k], expected=None))
-                elif k not in actual_dict:
-                    entries.append(DiffEntry(path=path, actual=None, expected=expected_dict[k]))
-                elif actual_dict[k] != expected_dict[k]:
-                    sub = BaseMixin._sub_diff_entries(actual_dict[k], expected_dict[k], path, _seen=child_seen)
-                    if sub is not None:
-                        entries.extend(sub)
+            for key in sorted(set(actual_dict) | set(expected_dict)):
+                path = f"{prefix}.{key}"
+                if key not in expected_dict:
+                    entries.append(DiffEntry(path=path, actual=actual_dict[key], expected=None))
+                elif key not in actual_dict:
+                    entries.append(DiffEntry(path=path, actual=None, expected=expected_dict[key]))
+                elif actual_dict[key] != expected_dict[key]:
+                    sub_entries = BaseMixin._sub_diff_entries(
+                        actual_dict[key], expected_dict[key], path, _seen=child_seen
+                    )
+                    if sub_entries is not None:
+                        entries.extend(sub_entries)
                     else:
-                        entries.append(DiffEntry(path=path, actual=actual_dict[k], expected=expected_dict[k]))
+                        entries.append(DiffEntry(path=path, actual=actual_dict[key], expected=expected_dict[key]))
             return entries or None
         return None
 
@@ -875,8 +885,8 @@ class BaseMixin(_MixinBase):
         if type(some_type) is not type and not issubclass(type(some_type), type):
             raise TypeError("given arg must be a type")
         if type(self.val) is not some_type:
-            t = self._type(self.val)
-            return self.error(f"Expected <{self.val}:{t}> to be of type <{some_type.__name__}>, but was not.")
+            type_name = self._type(self.val)
+            return self.error(f"Expected <{self.val}:{type_name}> to be of type <{some_type.__name__}>, but was not.")
         return self
 
     def is_instance_of(self, some_class) -> Self:
@@ -912,9 +922,9 @@ class BaseMixin(_MixinBase):
         """
         try:
             if not isinstance(self.val, some_class):
-                t = self._type(self.val)
+                type_name = self._type(self.val)
                 return self.error(
-                    f"Expected <{self.val}:{t}> to be instance of class <{some_class.__name__}>, but was not."
+                    f"Expected <{self.val}:{type_name}> to be instance of class <{some_class.__name__}>, but was not."
                 )
         except TypeError:
             raise TypeError("given arg must be a class") from None

{assertpy2-2.5.1 → assertpy2-2.7.0}/assertpy2/collection.py

@@ -93,36 +93,36 @@ class CollectionMixin(_MixinBase):
         missing = []
         if hasattr(self.val, "keys") and callable(self.val.keys) and hasattr(self.val, "__getitem__"):
             superdict = {}
-            for idx, j in enumerate(supersets):
-                self._check_dict_like(j, check_values=False, name=f"arg #{idx + 1}")
-                for k in j:
-                    superdict.update({k: j[k]})
-
-            for i in self.val:
-                if i not in superdict:
-                    missing.append({i: self.val[i]})  # bad key
-                elif self.val[i] != superdict[i]:
-                    missing.append({i: self.val[i]})  # bad val
+            for superset_index, superset in enumerate(supersets):
+                self._check_dict_like(superset, check_values=False, name=f"arg #{superset_index + 1}")
+                for key in superset:
+                    superdict.update({key: superset[key]})
+
+            for key in self.val:
+                if key not in superdict:
+                    missing.append({key: self.val[key]})  # bad key
+                elif self.val[key] != superdict[key]:
+                    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"but {self._fmt_items(missing)} {'was' if len(missing) == 1 else 'were'} missing."
                 )
         else:
-            superset = set()
-            for j in supersets:
+            superset_values = set()
+            for superset in supersets:
                 try:
-                    for k in j:
-                        superset.add(k)
+                    for key in superset:
+                        superset_values.add(key)
                 except TypeError:
-                    superset.add(j)
+                    superset_values.add(superset)
 
-            for i in self.val:
-                if i not in superset:
-                    missing.append(i)
+            for item in self.val:
+                if item not in superset_values:
+                    missing.append(item)
             if missing:
                 return self.error(
-                    f"Expected <{self.val}> to be subset of {self._fmt_items(superset)}, "
+                    f"Expected <{self.val}> to be subset of {self._fmt_items(superset_values)}, "
                     f"but {self._fmt_items(missing)} {'was' if len(missing) == 1 else 'were'} missing."
                 )
 
@@ -161,22 +161,22 @@ class CollectionMixin(_MixinBase):
         if not isinstance(self.val, collections.abc.Iterable):
             raise TypeError("val is not iterable")
 
-        prev = None
-        for i, x in enumerate(self.val):
-            if i > 0:
+        previous = None
+        for index, current in enumerate(self.val):
+            if index > 0:
                 if reverse:
-                    if key(x) > key(prev):
+                    if key(current) > key(previous):
                         return self.error(
                             f"Expected <{self.val}> to be sorted reverse, "
-                            f"but subset {self._fmt_items([prev, x])} at index {i - 1} is not."
+                            f"but subset {self._fmt_items([previous, current])} at index {index - 1} is not."
                         )
                 else:
-                    if key(x) < key(prev):
+                    if key(current) < key(previous):
                         return self.error(
                             f"Expected <{self.val}> to be sorted, "
-                            f"but subset {self._fmt_items([prev, x])} at index {i - 1} is not."
+                            f"but subset {self._fmt_items([previous, current])} at index {index - 1} is not."
                         )
-            prev = x
+            previous = current
 
         return self
 
@@ -237,7 +237,7 @@ class CollectionMixin(_MixinBase):
         """
         if not isinstance(self.val, collections.abc.Iterable):
             raise TypeError("val is not iterable")
-        return self.builder([x for item in self.val for x in func(item)], self.description, self.kind)
+        return self.builder([inner for item in self.val for inner in func(item)], self.description, self.kind)
 
     def first(self) -> Self:
         """Returns a new builder with the first element of val.