assertpy2 2.2.0__tar.gz → 2.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.2.0
+Version: 2.3.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
@@ -27,6 +27,10 @@ Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
 Requires-Dist: typing-extensions>=4.0
+Provides-Extra: allure
+Requires-Dist: allure-pytest>=2.13; extra == 'allure'
+Provides-Extra: behave
+Requires-Dist: behave>=1.2.6; extra == 'behave'
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -126,7 +130,7 @@ FAILED test_example.py::test_comparison
 | **Async assertions** | No | No | No | **eventually() with polling** |
 | **Soft assertions** | No | No | Yes (not thread-safe) | **Yes (thread-safe, async-safe)** |
 | **Structured errors** | Rewrite only | Mismatch string | String only | **.actual .expected .diff** |
-| **Maintained** | N/A | Minimal | 2020 | **Active (2026)** |
+| **Maintained** | N/A | Minimal | 2020 | **Active** |
 
 </div>
 
@@ -167,6 +171,8 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 - **Extracting**: flatten collections on attributes with `filter` and `sort` support.
 - **File assertions**: `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
 - **Snapshot testing**: store and compare data structures in JSON format, inspired by Jest.
+- **Allure integration**: auto-attach structured diff and actual/expected data to Allure reports.
+- **Behave step matchers**: ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
 - **Extensions**: add custom assertions via `add_extension()`.
 - Strings, numbers, lists, tuples, sets, dicts, dates, booleans, objects, exceptions.
 
@@ -360,6 +366,54 @@ assert_that(5).is_5()
 See the [full API reference](docs/api.md) for all assertion methods, examples, and advanced features.
 
 
+## Allure integration
+
+When `allure-pytest` is installed, the pytest plugin auto-attaches structured failure data to Allure reports as JSON attachments.
+
+```bash
+pip install assertpy2[allure]
+```
+
+Three modes controlled via `pytest.ini` (or `pyproject.toml`):
+
+| Mode | What is attached |
+|---|---|
+| `diff` (default) | Structured Diff JSON (path-level breakdown) |
+| `full` | Structured Diff + actual/expected JSON |
+| `off` | Nothing |
+
+```toml
+# pyproject.toml
+[tool.pytest.ini_options]
+assertpy2_allure = "full"
+```
+
+
+## Behave step matchers
+
+Ready-made parameter types for Behave step definitions:
+
+```bash
+pip install assertpy2[behave]
+```
+
+```py
+# in environment.py or steps/conftest.py
+from assertpy2.behave_matchers import register_assertpy_types
+register_assertpy_types()
+```
+
+Then use in step definitions:
+
+```py
+@given('a user aged {age:PositiveInt}')
+def step_impl(context, age):
+    context.age = age  # already validated as int > 0
+```
+
+Available types: `PositiveInt`, `NonNegativeInt`, `PositiveFloat`, `NonEmptyString`, `BoolLike`.
+
+
 ## Migration from assertpy
 
 assertpy2 is a drop-in replacement for Python 3.10+. Change the import, everything else works:

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

@@ -95,7 +95,7 @@ FAILED test_example.py::test_comparison
 | **Async assertions** | No | No | No | **eventually() with polling** |
 | **Soft assertions** | No | No | Yes (not thread-safe) | **Yes (thread-safe, async-safe)** |
 | **Structured errors** | Rewrite only | Mismatch string | String only | **.actual .expected .diff** |
-| **Maintained** | N/A | Minimal | 2020 | **Active (2026)** |
+| **Maintained** | N/A | Minimal | 2020 | **Active** |
 
 </div>
 
@@ -136,6 +136,8 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 - **Extracting**: flatten collections on attributes with `filter` and `sort` support.
 - **File assertions**: `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
 - **Snapshot testing**: store and compare data structures in JSON format, inspired by Jest.
+- **Allure integration**: auto-attach structured diff and actual/expected data to Allure reports.
+- **Behave step matchers**: ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
 - **Extensions**: add custom assertions via `add_extension()`.
 - Strings, numbers, lists, tuples, sets, dicts, dates, booleans, objects, exceptions.
 
@@ -329,6 +331,54 @@ assert_that(5).is_5()
 See the [full API reference](docs/api.md) for all assertion methods, examples, and advanced features.
 
 
+## Allure integration
+
+When `allure-pytest` is installed, the pytest plugin auto-attaches structured failure data to Allure reports as JSON attachments.
+
+```bash
+pip install assertpy2[allure]
+```
+
+Three modes controlled via `pytest.ini` (or `pyproject.toml`):
+
+| Mode | What is attached |
+|---|---|
+| `diff` (default) | Structured Diff JSON (path-level breakdown) |
+| `full` | Structured Diff + actual/expected JSON |
+| `off` | Nothing |
+
+```toml
+# pyproject.toml
+[tool.pytest.ini_options]
+assertpy2_allure = "full"
+```
+
+
+## Behave step matchers
+
+Ready-made parameter types for Behave step definitions:
+
+```bash
+pip install assertpy2[behave]
+```
+
+```py
+# in environment.py or steps/conftest.py
+from assertpy2.behave_matchers import register_assertpy_types
+register_assertpy_types()
+```
+
+Then use in step definitions:
+
+```py
+@given('a user aged {age:PositiveInt}')
+def step_impl(context, age):
+    context.age = age  # already validated as int > 0
+```
+
+Available types: `PositiveInt`, `NonNegativeInt`, `PositiveFloat`, `NonEmptyString`, `BoolLike`.
+
+
 ## Migration from assertpy
 
 assertpy2 is a drop-in replacement for Python 3.10+. Change the import, everything else works:

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

@@ -160,7 +160,7 @@ def soft_assertions() -> Iterator[None]:
 
     errs = _soft_err.get([])
     if errs and _soft_ctx.get() == 0:
-        out = "soft assertion failures:\n" + "\n".join("%d. %s" % (i + 1, msg) for i, msg in enumerate(errs))
+        out = "soft assertion failures:\n" + "\n".join(f"{i + 1}. {msg}" for i, msg in enumerate(errs))
         _soft_err.set([])
         raise AssertionError(out)
 
@@ -300,7 +300,7 @@ def fail(msg=""):
                 except TypeError as e:
                     assert_that(str(e)).contains('unsupported operand')
     """
-    raise AssertionError("Fail: %s!" % msg if msg else "Fail!")
+    raise AssertionError(f"Fail: {msg}!" if msg else "Fail!")
 
 
 def soft_fail(msg=""):
@@ -332,7 +332,7 @@ def soft_fail(msg=""):
 
     """
     if _soft_ctx.get():
-        _soft_err.get().append("Fail: %s!" % msg if msg else "Fail!")
+        _soft_err.get().append(f"Fail: {msg}!" if msg else "Fail!")
         return
     fail(msg)
 
@@ -427,7 +427,7 @@ class WarningLoggingAdapter(logging.LoggerAdapter):
                 prev = frame
 
         filename, lineno = _unwind(inspect.currentframe())
-        return "[%s:%d]: %s" % (os.path.basename(filename), lineno, msg), kwargs
+        return f"[{os.path.basename(filename)}:{lineno}]: {msg}", kwargs
 
 
 _logger = logging.getLogger("assertpy2")
@@ -512,7 +512,7 @@ class AssertionBuilder(
             AssertionBuilder: returns this instance to chain to the next assertion, but only when
                 ``AssertionError`` is not raised, as is the case when ``kind`` is ``warn`` or ``soft``.
         """
-        out = "%s%s" % ("[%s] " % self.description if len(self.description) > 0 else "", msg)
+        out = f"{f'[{self.description}] ' if len(self.description) > 0 else ''}{msg}"
         if self.kind == "warn":
             self.logger.warning(out)
             return self

{assertpy2-2.2.0 → assertpy2-2.3.0}/assertpy2/async_assertions.py

@@ -73,8 +73,8 @@ class AsyncAssertionBuilder:
                         last_error = exc
                         if loop.time() >= deadline:
                             raise AssertionError(
-                                "Expected condition not met after %.1f seconds. Last failure: %s"
-                                % (self._timeout, last_error)
+                                f"Expected condition not met after {self._timeout:.1f} seconds."
+                                f" Last failure: {last_error}"
                             ) from last_error
                         await asyncio.sleep(self._interval)
 

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

@@ -31,6 +31,7 @@ from __future__ import annotations
 import collections.abc
 from typing import TYPE_CHECKING
 
+from .errors import DiffEntry, DiffResult
 from .matchers import Matcher, StructureMatcher
 
 if TYPE_CHECKING:
@@ -135,9 +136,10 @@ class BaseMixin:
         else:
             if self.val != other:
                 return self.error(
-                    "Expected <%s> to be equal to <%s>, but was not." % (self.val, other),
+                    f"Expected <{self.val}> to be equal to <{other}>, but was not.",
                     actual=self.val,
                     expected=other,
+                    diff=DiffResult(kind="scalar", entries=[DiffEntry(path=".", actual=self.val, expected=other)]),
                 )
         return self
 
@@ -168,10 +170,10 @@ class BaseMixin:
         """
         if isinstance(matcher, Matcher):
             if not matcher.matches(self.val):
-                return self.error("Expected %s, but %s." % (matcher.describe(), matcher.describe_mismatch(self.val)))
+                return self.error(f"Expected {matcher.describe()}, but {matcher.describe_mismatch(self.val)}.")
         elif callable(matcher):
             if not matcher(self.val):
-                return self.error("Expected <%s> to satisfy <%s>, but did not." % (self.val, matcher))
+                return self.error(f"Expected <{self.val}> to satisfy <{matcher}>, but did not.")
         else:
             raise TypeError("given arg must be a Matcher or callable")
         return self
@@ -207,14 +209,14 @@ class BaseMixin:
             for i, item in enumerate(self.val):
                 if not matcher.matches(item):
                     return self.error(
-                        "Expected all items to satisfy %s, but item at index %d <%s> did not: %s."
-                        % (matcher.describe(), i, item, matcher.describe_mismatch(item))
+                        f"Expected all items to satisfy {matcher.describe()}, but item at index {i} <{item}> did not:"
+                        f" {matcher.describe_mismatch(item)}."
                     )
         elif callable(matcher):
             for i, item in enumerate(self.val):
                 if not matcher(item):
                     return self.error(
-                        "Expected all items to satisfy <%s>, but item at index %d <%s> did not." % (matcher, i, item)
+                        f"Expected all items to satisfy <{matcher}>, but item at index {i} <{item}> did not."
                     )
         else:
             raise TypeError("given arg must be a Matcher or callable")
@@ -255,8 +257,8 @@ class BaseMixin:
         matcher = StructureMatcher(spec)
         if not matcher.matches(self.val):
             return self.error(
-                "Expected <%s> to match structure %s, but %s."
-                % (self.val, matcher.describe(), matcher.describe_mismatch(self.val))
+                f"Expected <{self.val}> to match structure {matcher.describe()}, but"
+                f" {matcher.describe_mismatch(self.val)}."
             )
         return self
 
@@ -425,7 +427,7 @@ class BaseMixin:
             AssertionError: if actual **is** equal to expected
         """
         if self.val == other:
-            return self.error("Expected <%s> to be not equal to <%s>, but was." % (self.val, other))
+            return self.error(f"Expected <{self.val}> to be not equal to <{other}>, but was.")
         return self
 
     def is_same_as(self, other) -> Self:
@@ -467,7 +469,7 @@ class BaseMixin:
             AssertionError: if actual is **not** identical to expected
         """
         if self.val is not other:
-            return self.error("Expected <%s> to be identical to <%s>, but was not." % (self.val, other))
+            return self.error(f"Expected <{self.val}> to be identical to <{other}>, but was not.")
         return self
 
     def is_not_same_as(self, other) -> Self:
@@ -498,7 +500,7 @@ class BaseMixin:
             AssertionError: if actual **is** identical to expected
         """
         if self.val is other:
-            return self.error("Expected <%s> to be not identical to <%s>, but was." % (self.val, other))
+            return self.error(f"Expected <{self.val}> to be not identical to <{other}>, but was.")
         return self
 
     def is_true(self) -> Self:
@@ -523,7 +525,7 @@ class BaseMixin:
             AssertionError: if val **is** false
         """
         if not self.val:
-            return self.error("Expected <%s> to be <True>, but was not." % self.val)
+            return self.error(f"Expected <{self.val}> to be <True>, but was not.")
         return self
 
     def is_false(self) -> Self:
@@ -548,7 +550,7 @@ class BaseMixin:
             AssertionError: if val **is** true
         """
         if self.val:
-            return self.error("Expected <%s> to be <False>, but was not." % self.val)
+            return self.error(f"Expected <{self.val}> to be <False>, but was not.")
         return self
 
     def is_none(self) -> Self:
@@ -567,7 +569,7 @@ class BaseMixin:
             AssertionError: if val is **not** none
         """
         if self.val is not None:
-            return self.error("Expected <%s> to be <None>, but was not." % self.val)
+            return self.error(f"Expected <{self.val}> to be <None>, but was not.")
         return self
 
     def is_not_none(self) -> Self:
@@ -623,7 +625,7 @@ class BaseMixin:
             raise TypeError("given arg must be a type")
         if type(self.val) is not some_type:
             t = self._type(self.val)
-            return self.error("Expected <%s:%s> to be of type <%s>, but was not." % (self.val, t, some_type.__name__))
+            return self.error(f"Expected <{self.val}:{t}> to be of type <{some_type.__name__}>, but was not.")
         return self
 
     def is_instance_of(self, some_class) -> Self:
@@ -661,7 +663,7 @@ class BaseMixin:
             if not isinstance(self.val, some_class):
                 t = self._type(self.val)
                 return self.error(
-                    "Expected <%s:%s> to be instance of class <%s>, but was not." % (self.val, t, some_class.__name__)
+                    f"Expected <{self.val}:{t}> to be instance of class <{some_class.__name__}>, but was not."
                 )
         except TypeError:
             raise TypeError("given arg must be a class") from None
@@ -695,5 +697,5 @@ class BaseMixin:
         if length < 0:
             raise ValueError("given arg must be a positive int")
         if len(self.val) != length:
-            return self.error("Expected <%s> to be of length <%d>, but was <%d>." % (self.val, length, len(self.val)))
+            return self.error(f"Expected <{self.val}> to be of length <{length}>, but was <{len(self.val)}>.")
         return self

assertpy2-2.3.0/assertpy2/behave_matchers.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+_BOOL_TRUE = frozenset({"true", "yes", "1", "on"})
+_BOOL_FALSE = frozenset({"false", "no", "0", "off"})
+
+
+def _with_pattern(pattern):
+    def decorator(func):
+        func.pattern = pattern
+        return func
+
+    return decorator
+
+
+@_with_pattern(r"\d+")
+def _positive_int(text):
+    value = int(text)
+    if value <= 0:
+        raise ValueError(f"expected positive integer, got {value}")
+    return value
+
+
+@_with_pattern(r"\d+")
+def _non_negative_int(text):
+    return int(text)
+
+
+@_with_pattern(r"\d+\.?\d*")
+def _positive_float(text):
+    value = float(text)
+    if value <= 0:
+        raise ValueError(f"expected positive float, got {value}")
+    return value
+
+
+@_with_pattern(r".+?")
+def _non_empty_string(text):
+    stripped = text.strip()
+    if not stripped:
+        raise ValueError("expected non-empty string, got blank")
+    return stripped
+
+
+@_with_pattern(r"\w+")
+def _bool_like(text):
+    lower = text.strip().lower()
+    if lower in _BOOL_TRUE:
+        return True
+    if lower in _BOOL_FALSE:
+        return False
+    raise ValueError(f"expected boolean-like value, got {text!r}")
+
+
+ASSERTPY_TYPES = {
+    "PositiveInt": _positive_int,
+    "NonNegativeInt": _non_negative_int,
+    "PositiveFloat": _positive_float,
+    "NonEmptyString": _non_empty_string,
+    "BoolLike": _bool_like,
+}
+
+
+def register_assertpy_types() -> None:
+    """Register assertpy2 parameter types for Behave step definitions.
+
+    Registers the following types for use in step patterns:
+
+    - ``{param:PositiveInt}`` - positive integer (> 0)
+    - ``{param:NonNegativeInt}`` - non-negative integer (>= 0)
+    - ``{param:PositiveFloat}`` - positive float (> 0)
+    - ``{param:NonEmptyString}`` - non-empty, stripped string
+    - ``{param:BoolLike}`` - boolean from true/false/yes/no/1/0/on/off
+
+    Requires ``behave`` to be installed (``pip install assertpy2[behave]``).
+
+    Raises:
+        ImportError: if behave is not installed
+    """
+    try:
+        from behave import register_type
+    except ImportError:
+        raise ImportError(
+            "behave is required for register_assertpy_types(). Install it with: pip install assertpy2[behave]"
+        ) from None
+    register_type(**ASSERTPY_TYPES)

{assertpy2-2.2.0 → assertpy2-2.3.0}/assertpy2/collection.py

@@ -119,7 +119,7 @@ class CollectionMixin:
             # flatten superset dicts
             superdict = {}
             for idx, j in enumerate(supersets):
-                self._check_dict_like(j, check_values=False, name="arg #%d" % (idx + 1))
+                self._check_dict_like(j, check_values=False, name=f"arg #{idx + 1}")
                 for k in j:
                     superdict.update({k: j[k]})
 
@@ -130,13 +130,8 @@ class CollectionMixin:
                     missing.append({i: self.val[i]})  # bad val
             if missing:
                 return self.error(
-                    "Expected <%s> to be subset of %s, but %s %s missing."
-                    % (
-                        self.val,
-                        self._fmt_items(superdict),
-                        self._fmt_items(missing),
-                        "was" if len(missing) == 1 else "were",
-                    )
+                    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:
             # flatten supersets
@@ -153,13 +148,8 @@ class CollectionMixin:
                     missing.append(i)
             if missing:
                 return self.error(
-                    "Expected <%s> to be subset of %s, but %s %s missing."
-                    % (
-                        self.val,
-                        self._fmt_items(superset),
-                        self._fmt_items(missing),
-                        "was" if len(missing) == 1 else "were",
-                    )
+                    f"Expected <{self.val}> to be subset of {self._fmt_items(superset)}, "
+                    f"but {self._fmt_items(missing)} {'was' if len(missing) == 1 else 'were'} missing."
                 )
 
         return self
@@ -203,14 +193,14 @@ class CollectionMixin:
                 if reverse:
                     if key(x) > key(prev):
                         return self.error(
-                            "Expected <%s> to be sorted reverse, but subset %s at index %s is not."
-                            % (self.val, self._fmt_items([prev, x]), i - 1)
+                            f"Expected <{self.val}> to be sorted reverse, "
+                            f"but subset {self._fmt_items([prev, x])} at index {i - 1} is not."
                         )
                 else:
                     if key(x) < key(prev):
                         return self.error(
-                            "Expected <%s> to be sorted, but subset %s at index %s is not."
-                            % (self.val, self._fmt_items([prev, x]), i - 1)
+                            f"Expected <{self.val}> to be sorted, "
+                            f"but subset {self._fmt_items([prev, x])} at index {i - 1} is not."
                         )
             prev = x
 

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

@@ -80,13 +80,13 @@ class ContainsMixin:
             if isinstance(items[0], Matcher):
                 if not any(items[0].matches(v) for v in self.val):
                     return self.error(
-                        "Expected <%s> to contain item matching %s, but did not." % (self.val, items[0].describe())
+                        f"Expected <{self.val}> to contain item matching {items[0].describe()}, but did not."
                     )
             elif items[0] not in self.val:
                 if self._check_dict_like(self.val, return_as_bool=True):
-                    return self.error("Expected <%s> to contain key <%s>, but did not." % (self.val, items[0]))
+                    return self.error(f"Expected <{self.val}> to contain key <{items[0]}>, but did not.")
                 else:
-                    return self.error("Expected <%s> to contain item <%s>, but did not." % (self.val, items[0]))
+                    return self.error(f"Expected <{self.val}> to contain item <{items[0]}>, but did not.")
         else:
             missing = []
             for i in items:
@@ -99,18 +99,13 @@ class ContainsMixin:
                 missing_desc = [m.describe() if isinstance(m, Matcher) else m for m in missing]
                 if self._check_dict_like(self.val, return_as_bool=True):
                     return self.error(
-                        "Expected <%s> to contain keys %s, but did not contain key%s %s."
-                        % (
-                            self.val,
-                            self._fmt_items(items),
-                            "" if len(missing) == 0 else "s",
-                            self._fmt_items(missing_desc),
-                        )
+                        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)}."
                     )
                 else:
                     return self.error(
-                        "Expected <%s> to contain items %s, but did not contain %s."
-                        % (self.val, self._fmt_items(items), self._fmt_items(missing_desc))
+                        f"Expected <{self.val}> to contain items {self._fmt_items(items)},"
+                        f" but did not contain {self._fmt_items(missing_desc)}."
                     )
         return self
 
@@ -146,7 +141,7 @@ class ContainsMixin:
             raise ValueError("one or more args must be given")
         elif len(items) == 1:
             if items[0] in self.val:
-                return self.error("Expected <%s> to not contain item <%s>, but did." % (self.val, items[0]))
+                return self.error(f"Expected <{self.val}> to not contain item <{items[0]}>, but did.")
         else:
             found = []
             for i in items:
@@ -154,8 +149,8 @@ class ContainsMixin:
                     found.append(i)
             if found:
                 return self.error(
-                    "Expected <%s> to not contain items %s, but did contain %s."
-                    % (self.val, self._fmt_items(items), self._fmt_items(found))
+                    f"Expected <{self.val}> to not contain items {self._fmt_items(items)},"
+                    f" but did contain {self._fmt_items(found)}."
                 )
         return self
 
@@ -191,8 +186,8 @@ class ContainsMixin:
                     extra.append(i)
             if extra:
                 return self.error(
-                    "Expected <%s> to contain only %s, but did contain %s."
-                    % (self.val, self._fmt_items(items), self._fmt_items(extra))
+                    f"Expected <{self.val}> to contain only {self._fmt_items(items)},"
+                    f" but did contain {self._fmt_items(extra)}."
                 )
 
             missing = []
@@ -201,8 +196,8 @@ class ContainsMixin:
                     missing.append(i)
             if missing:
                 return self.error(
-                    "Expected <%s> to contain only %s, but did not contain %s."
-                    % (self.val, self._fmt_items(items), self._fmt_items(missing))
+                    f"Expected <{self.val}> to contain only {self._fmt_items(items)},"
+                    f" but did not contain {self._fmt_items(missing)}."
                 )
         return self
 
@@ -238,7 +233,7 @@ class ContainsMixin:
                 idx = self.val.find(item, pos)
                 if idx == -1:
                     return self.error(
-                        "Expected <%s> to contain sequence %s, but did not." % (self.val, self._fmt_items(items))
+                        f"Expected <{self.val}> to contain sequence {self._fmt_items(items)}, but did not."
                     )
                 pos = idx + len(item)
             return self
@@ -251,7 +246,7 @@ class ContainsMixin:
                     return self
         except TypeError:
             raise TypeError("val is not iterable") from None
-        return self.error("Expected <%s> to contain sequence %s, but did not." % (self.val, self._fmt_items(items)))
+        return self.error(f"Expected <{self.val}> to contain sequence {self._fmt_items(items)}, but did not.")
 
     def contains_duplicates(self) -> Self:
         """Asserts that val is iterable and *does* contain duplicates.
@@ -274,7 +269,7 @@ class ContainsMixin:
                 return self
         except TypeError:
             raise TypeError("val is not iterable") from None
-        return self.error("Expected <%s> to contain duplicates, but did not." % self.val)
+        return self.error(f"Expected <{self.val}> to contain duplicates, but did not.")
 
     def does_not_contain_duplicates(self) -> Self:
         """Asserts that val is iterable and *does not* contain any duplicates.
@@ -297,7 +292,7 @@ class ContainsMixin:
                 return self
         except TypeError:
             raise TypeError("val is not iterable") from None
-        return self.error("Expected <%s> to not contain duplicates, but did." % self.val)
+        return self.error(f"Expected <{self.val}> to not contain duplicates, but did.")
 
     def is_empty(self) -> Self:
         """Asserts that val is empty.
@@ -319,9 +314,9 @@ class ContainsMixin:
         """
         if len(self.val) != 0:
             if isinstance(self.val, str):
-                return self.error("Expected <%s> to be empty string, but was not." % self.val)
+                return self.error(f"Expected <{self.val}> to be empty string, but was not.")
             else:
-                return self.error("Expected <%s> to be empty, but was not." % self.val)
+                return self.error(f"Expected <{self.val}> to be empty, but was not.")
         return self
 
     def is_not_empty(self) -> Self:
@@ -439,7 +434,7 @@ class ContainsMixin:
             for i in items:
                 if self.val == i:
                     return self
-        return self.error("Expected <%s> to be in %s, but was not." % (self.val, self._fmt_items(items)))
+        return self.error(f"Expected <{self.val}> to be in {self._fmt_items(items)}, but was not.")
 
     def is_not_in(self, *items) -> Self:
         """Asserts that val is not equal to one of the given items.
@@ -464,5 +459,5 @@ class ContainsMixin:
         else:
             for i in items:
                 if self.val == i:
-                    return self.error("Expected <%s> to not be in %s, but was." % (self.val, self._fmt_items(items)))
+                    return self.error(f"Expected <{self.val}> to not be in {self._fmt_items(items)}, but was.")
         return self