assertpy2 2.3.5__tar.gz → 2.3.7__tar.gz

assertpy2-2.3.7/CONTRIBUTING.md

@@ -0,0 +1,50 @@
+# Contributing
+
+Contributions of docs, tests, or code are welcome.
+
+## Workflow
+
+1. Fork the repo
+2. Clone your fork (`git clone <your_fork_url>`)
+3. Create a branch (`git checkout -b my_branch`)
+4. Install dependencies: `uv sync`
+5. Make your changes
+6. Run the [verification pipeline](#verification-pipeline) and fix any issues
+7. Commit using [Conventional Commits](#commit-style)
+8. Push your branch (`git push origin my_branch`)
+9. Open a [Pull Request](http://github.com/Solganis/assertpy2/pulls)
+
+Read more about how pulls work on GitHub's [About pull requests](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests) page.
+
+## Requirements
+
+- Python 3.10+
+- [uv](https://docs.astral.sh/uv/) as the package manager
+
+## Verification pipeline
+
+Run all checks before submitting a PR. Every step must pass.
+
+```bash
+# lint
+uv run ruff check assertpy2/ tests/
+
+# format
+uv run ruff format --check assertpy2/ tests/
+
+# type check
+uv run ty check
+
+# tests with coverage (must be 100%)
+uv run pytest tests/ -v --cov=assertpy2 --cov-report=term-missing
+```
+
+CI requires 100% code coverage.
+
+## Commit style
+
+Use [Conventional Commits](https://www.conventionalcommits.org/): `feat:`, `fix:`, `refactor:`, `test:`, `docs:`, `chore:`, etc.
+
+## Tests
+
+Write tests for every new feature or bug fix. Use `assertpy2` assertions in tests.

{assertpy2-2.3.5 → assertpy2-2.3.7}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.3.5
+Version: 2.3.7
 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
 Project-URL: Issues, https://github.com/Solganis/assertpy2/issues
 Author-email: Justin Shacklette <justin@saturnboy.com>
-Maintainer: Solganis
+Maintainer-email: Solganis <solganis.dev@gmail.com>
 License-Expression: BSD-3-Clause
 License-File: LICENSE
 Keywords: assert,assert_that,assertion,assertthat,pytest,test,testing,unittest
@@ -31,6 +31,9 @@ Provides-Extra: allure
 Requires-Dist: allure-pytest>=2.13; extra == 'allure'
 Provides-Extra: behave
 Requires-Dist: behave>=1.2.6; extra == 'behave'
+Provides-Extra: json
+Requires-Dist: jsonpath-ng>=1.8; extra == 'json'
+Requires-Dist: jsonschema>=4.0; extra == 'json'
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -43,7 +46,7 @@ Description-Content-Type: text/markdown
 
 <p align="center">
   <b>Fluent assertion library for Python with composable matchers, structural matching, and full type safety.</b><br>
-  Maintained fork of <a href="https://github.com/assertpy/assertpy">assertpy</a>.
+  A modern, batteries-included fork of <a href="https://github.com/assertpy/assertpy">assertpy</a>.
 </p>
 
 <p align="center">
@@ -162,11 +165,14 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 
 - [**Composable matchers**](docs/api.md#composable-matchers): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~`. Also work with plain `assert ==`.
 - [**Structural matching**](docs/api.md#structural-matching): `matches_structure()` for declarative dict/API response validation.
+- [**Universal negation**](docs/api.md#universal-negation): `.not_` inverts any assertion without dedicated `is_not_*` methods.
+- [**Collection pipeline**](docs/api.md#collection-pipeline): `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()` for transforming collections before assertions.
 - [**Async assertions**](docs/api.md#async-assertions): `eventually()` with polling/retry for async and eventual consistency testing.
 - [**Structured errors**](docs/api.md#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
 - **Typed overloads**: `assert_that()` returns type-specific Protocols, IDE shows only relevant methods per type.
 - **Type safety**: `Self` return types, `py.typed` ([PEP 561](https://peps.python.org/pep-0561/)).
-- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
+- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`. Group errors with `sa.group()`, or use `assert_all()` for inline checks.
+- [**JSON assertions**](docs/api.md#json-path--schema-validation): JSONPath navigation (`at_json_path`, `has_json_path`) and JSON Schema validation (`matches_json_schema`).
 - [**Fluent chaining**](docs/api.md#chaining): write assertions as readable one-liners that chain naturally.
 - [**Dynamic assertions**](docs/api.md#objects): `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
 - [**Dict comparison**](docs/api.md#dicts): `is_equal_to()` with `ignore` and `include` for selective key matching.
@@ -318,6 +324,68 @@ DiffResult(kind='dict', entries=[DiffEntry(path='b', actual=2, expected=99)])
 
 ## More features
 
+### Universal negation
+
+Invert any assertion with `.not_`:
+
+```py
+assert_that(5).not_.is_none()
+assert_that("abc123").not_.is_alpha()
+assert_that([3, 1, 2]).not_.is_sorted()
+assert_that(value).described_as("check").not_.is_none().is_positive()
+```
+
+Works with soft assertions and warn mode.
+
+### Collection pipeline
+
+Transform collections before asserting:
+
+```py
+orders = [Order("DONE", 100), Order("FAILED", 50), Order("DONE", 200)]
+
+assert_that(orders).filtered_on(lambda o: o.status == "FAILED").is_length(1)
+assert_that(orders).mapped(lambda o: o.total).contains(100, 200)
+assert_that(orders).first().has_status("DONE")
+assert_that(orders).element(1).has_status("FAILED")
+assert_that([42]).single().is_equal_to(42)
+
+# chaining pipeline steps
+assert_that(items).filtered_on(match.is_positive()).mapped(str).contains("1")
+```
+
+Available methods: `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()`.
+
+### Grouped soft assertions
+
+```py
+with soft_assertions() as sa:
+    with sa.group("Headers"):
+        assert_that(headers["Content-Type"]).is_equal_to("application/json")
+    with sa.group("Body"):
+        assert_that(body["status"]).is_equal_to("ok")
+        assert_that(body["items"]).is_not_empty()
+
+# or inline with assert_all
+assert_all(
+    lambda: assert_that(x).is_positive(),
+    lambda: assert_that(y).is_not_none(),
+)
+```
+
+### JSON path and schema validation
+
+Requires `pip install assertpy2[json]`.
+
+```py
+data = {"users": [{"name": "Alice"}, {"name": "Bob"}], "meta": {"total": 2}}
+
+assert_that(data).at_json_path("$.users[0].name").is_equal_to("Alice")
+assert_that(data).has_json_path("$.meta.total")
+assert_that(data).does_not_have_json_path("$.error")
+assert_that(data).matches_json_schema({"type": "object", "required": ["users"]})
+```
+
 ### Dict comparison with ignore/include
 
 ```py
@@ -492,19 +560,3 @@ See the [comparison table](#comparison) above for feature differences with other
 Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
 
 
-## License
-
-All files are licensed under the BSD 3-Clause License as follows:
-
-> Copyright (c) 2015-2019, Activision Publishing, Inc.
-> All rights reserved.
->
-> Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
->
-> 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
->
-> 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
->
-> 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
->
-> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

{assertpy2-2.3.5 → assertpy2-2.3.7}/README.md

@@ -8,7 +8,7 @@
 
 <p align="center">
   <b>Fluent assertion library for Python with composable matchers, structural matching, and full type safety.</b><br>
-  Maintained fork of <a href="https://github.com/assertpy/assertpy">assertpy</a>.
+  A modern, batteries-included fork of <a href="https://github.com/assertpy/assertpy">assertpy</a>.
 </p>
 
 <p align="center">
@@ -127,11 +127,14 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 
 - [**Composable matchers**](docs/api.md#composable-matchers): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~`. Also work with plain `assert ==`.
 - [**Structural matching**](docs/api.md#structural-matching): `matches_structure()` for declarative dict/API response validation.
+- [**Universal negation**](docs/api.md#universal-negation): `.not_` inverts any assertion without dedicated `is_not_*` methods.
+- [**Collection pipeline**](docs/api.md#collection-pipeline): `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()` for transforming collections before assertions.
 - [**Async assertions**](docs/api.md#async-assertions): `eventually()` with polling/retry for async and eventual consistency testing.
 - [**Structured errors**](docs/api.md#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
 - **Typed overloads**: `assert_that()` returns type-specific Protocols, IDE shows only relevant methods per type.
 - **Type safety**: `Self` return types, `py.typed` ([PEP 561](https://peps.python.org/pep-0561/)).
-- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
+- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`. Group errors with `sa.group()`, or use `assert_all()` for inline checks.
+- [**JSON assertions**](docs/api.md#json-path--schema-validation): JSONPath navigation (`at_json_path`, `has_json_path`) and JSON Schema validation (`matches_json_schema`).
 - [**Fluent chaining**](docs/api.md#chaining): write assertions as readable one-liners that chain naturally.
 - [**Dynamic assertions**](docs/api.md#objects): `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
 - [**Dict comparison**](docs/api.md#dicts): `is_equal_to()` with `ignore` and `include` for selective key matching.
@@ -283,6 +286,68 @@ DiffResult(kind='dict', entries=[DiffEntry(path='b', actual=2, expected=99)])
 
 ## More features
 
+### Universal negation
+
+Invert any assertion with `.not_`:
+
+```py
+assert_that(5).not_.is_none()
+assert_that("abc123").not_.is_alpha()
+assert_that([3, 1, 2]).not_.is_sorted()
+assert_that(value).described_as("check").not_.is_none().is_positive()
+```
+
+Works with soft assertions and warn mode.
+
+### Collection pipeline
+
+Transform collections before asserting:
+
+```py
+orders = [Order("DONE", 100), Order("FAILED", 50), Order("DONE", 200)]
+
+assert_that(orders).filtered_on(lambda o: o.status == "FAILED").is_length(1)
+assert_that(orders).mapped(lambda o: o.total).contains(100, 200)
+assert_that(orders).first().has_status("DONE")
+assert_that(orders).element(1).has_status("FAILED")
+assert_that([42]).single().is_equal_to(42)
+
+# chaining pipeline steps
+assert_that(items).filtered_on(match.is_positive()).mapped(str).contains("1")
+```
+
+Available methods: `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()`.
+
+### Grouped soft assertions
+
+```py
+with soft_assertions() as sa:
+    with sa.group("Headers"):
+        assert_that(headers["Content-Type"]).is_equal_to("application/json")
+    with sa.group("Body"):
+        assert_that(body["status"]).is_equal_to("ok")
+        assert_that(body["items"]).is_not_empty()
+
+# or inline with assert_all
+assert_all(
+    lambda: assert_that(x).is_positive(),
+    lambda: assert_that(y).is_not_none(),
+)
+```
+
+### JSON path and schema validation
+
+Requires `pip install assertpy2[json]`.
+
+```py
+data = {"users": [{"name": "Alice"}, {"name": "Bob"}], "meta": {"total": 2}}
+
+assert_that(data).at_json_path("$.users[0].name").is_equal_to("Alice")
+assert_that(data).has_json_path("$.meta.total")
+assert_that(data).does_not_have_json_path("$.error")
+assert_that(data).matches_json_schema({"type": "object", "required": ["users"]})
+```
+
 ### Dict comparison with ignore/include
 
 ```py
@@ -457,19 +522,3 @@ See the [comparison table](#comparison) above for feature differences with other
 Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
 
 
-## License
-
-All files are licensed under the BSD 3-Clause License as follows:
-
-> Copyright (c) 2015-2019, Activision Publishing, Inc.
-> All rights reserved.
->
-> Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
->
-> 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
->
-> 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
->
-> 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
->
-> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

{assertpy2-2.3.5 → assertpy2-2.3.7}/assertpy2/__init__.py

@@ -1,7 +1,10 @@
 from .assertpy import (
+    NegatedBuilder,
+    SoftAssertionCollector,
     WarningLoggingAdapter,
     __version__,
     add_extension,
+    assert_all,
     assert_that,
     assert_warn,
     fail,
@@ -20,9 +23,12 @@ __all__ = [
     "DiffEntry",
     "DiffResult",
     "Matcher",
+    "NegatedBuilder",
+    "SoftAssertionCollector",
     "WarningLoggingAdapter",
     "__version__",
     "add_extension",
+    "assert_all",
     "assert_that",
     "assert_warn",
     "clear_custom_matchers",

{assertpy2-2.3.5 → assertpy2-2.3.7}/assertpy2/_typing.py

@@ -4,10 +4,12 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from collections.abc import Callable
-    from typing import Protocol
+    from pathlib import Path
+    from typing import Any, Protocol
 
     from typing_extensions import Self
 
+    from .assertpy import NegatedBuilder
     from .async_assertions import AsyncAssertionBuilder
     from .matchers import Matcher
 
@@ -35,6 +37,9 @@ if TYPE_CHECKING:
         def is_not_in(self, *items: object) -> Self: ...
         # SnapshotMixin
         def snapshot(self, id: str | None = ..., path: str = ...) -> Self: ...
+        # NegatedBuilder
+        @property
+        def not_(self) -> NegatedBuilder: ...
 
     class _StringAssertion(_CoreAssertion, Protocol):
         """Assertions available for ``str`` values."""
@@ -129,6 +134,20 @@ if TYPE_CHECKING:
         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: ...
+        # CollectionMixin - pipeline
+        def filtered_on(self, predicate: Callable[..., bool]) -> Self: ...
+        def mapped(self, func: Callable[..., object]) -> Self: ...
+        def flat_mapped(self, func: Callable[..., object]) -> Self: ...
+        def first(self) -> Self: ...
+        def last(self) -> Self: ...
+        def element(self, index: int) -> Self: ...
+        def single(self) -> Self: ...
+        # JsonMixin
+        def at_json_path(self, path: str) -> Self: ...
+        def has_json_path(self, path: str) -> Self: ...
+        def does_not_have_json_path(self, path: str) -> Self: ...
+        def matches_json_schema(self, schema: dict[str, Any]) -> Self: ...
+        def matches_json_schema_from_file(self, path: str | Path) -> Self: ...
 
     class _DictAssertion(_CoreAssertion, Protocol):
         """Assertions available for ``dict`` values."""
@@ -150,6 +169,12 @@ if TYPE_CHECKING:
         def each(self, matcher: Matcher | Callable[..., bool]) -> Self: ...
         # ExtractingMixin
         def extracting(self, *names: object, **kwargs: object) -> Self: ...
+        # JsonMixin
+        def at_json_path(self, path: str) -> Self: ...
+        def has_json_path(self, path: str) -> Self: ...
+        def does_not_have_json_path(self, path: str) -> Self: ...
+        def matches_json_schema(self, schema: dict[str, Any]) -> Self: ...
+        def matches_json_schema_from_file(self, path: str | Path) -> Self: ...
 
     class _DateAssertion(_CoreAssertion, Protocol):
         """Assertions available for ``datetime.date`` and ``datetime.datetime`` values."""

{assertpy2-2.3.5 → assertpy2-2.3.7}/assertpy2/assertpy.py

@@ -1,31 +1,3 @@
-# Copyright (c) 2015-2019, Activision Publishing, Inc.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without modification,
-# are permitted provided that the following conditions are met:
-#
-# 1. Redistributions of source code must retain the above copyright notice, this
-# list of conditions and the following disclaimer.
-#
-# 2. Redistributions in binary form must reproduce the above copyright notice,
-# this list of conditions and the following disclaimer in the documentation
-# and/or other materials provided with the distribution.
-#
-# 3. Neither the name of the copyright holder nor the names of its contributors
-# may be used to endorse or promote products derived from this software without
-# specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
 """Assertion library for python unit testing with a fluent API"""
 
 from __future__ import annotations
@@ -37,13 +9,12 @@ import logging
 import os
 import sys
 import types
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from typing import TYPE_CHECKING, overload
 
 if TYPE_CHECKING:
     import datetime
     import pathlib
-    from collections.abc import Callable
 
     from typing_extensions import Self
 
@@ -69,11 +40,12 @@ from .exception import ExceptionMixin
 from .extracting import ExtractingMixin
 from .file import FileMixin
 from .helpers import HelpersMixin
+from .json_mixin import JsonMixin
 from .numeric import NumericMixin
 from .snapshot import SnapshotMixin
 from .string import StringMixin
 
-__version__ = "2.3.5"
+__version__ = "2.3.7"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch
@@ -95,6 +67,7 @@ ASSERTPY_FILES = [
         "extracting.py",
         "file.py",
         "helpers.py",
+        "json_mixin.py",
         "matchers.py",
         "numeric.py",
         "pytest_plugin.py",
@@ -105,11 +78,52 @@ ASSERTPY_FILES = [
 
 # soft assertions (contextvars for thread/async safety)
 _soft_ctx: contextvars.ContextVar[int] = contextvars.ContextVar("assertpy2_soft_ctx", default=0)
-_soft_err: contextvars.ContextVar[list[str]] = contextvars.ContextVar("assertpy2_soft_err")
+_soft_err: contextvars.ContextVar[list[tuple[str | None, str]]] = contextvars.ContextVar("assertpy2_soft_err")
+_soft_group: contextvars.ContextVar[str | None] = contextvars.ContextVar("assertpy2_soft_group", default=None)
+
+
+class SoftAssertionCollector:
+    """Collector returned by :func:`soft_assertions` for grouping errors hierarchically."""
+
+    @contextlib.contextmanager
+    def group(self, label: str) -> Iterator[None]:
+        """Group subsequent assertion failures under *label*.
+
+        Examples:
+            Usage::
+
+                with soft_assertions() as sa:
+                    with sa.group("Headers"):
+                        assert_that(headers).contains_key("Content-Type")
+                    with sa.group("Body"):
+                        assert_that(body["status"]).is_equal_to("ok")
+        """
+        token = _soft_group.set(label)
+        try:
+            yield
+        finally:
+            _soft_group.reset(token)
+
+
+def _format_soft_errors(errs: list[tuple[str | None, str]]) -> str:
+    has_groups = any(group is not None for group, _ in errs)
+    if not has_groups:
+        return "soft assertion failures:\n" + "\n".join(f"{i + 1}. {msg}" for i, (_, msg) in enumerate(errs))
+
+    lines = ["soft assertion failures:"]
+    current_group: str | None = object()  # ty: ignore[invalid-assignment]  # sentinel
+    for counter, (group, msg) in enumerate(errs, 1):
+        if group != current_group:
+            current_group = group
+            if group is not None:
+                lines.append(f"  [{group}]")
+        indent = "    " if group is not None else "  "
+        lines.append(f"{indent}{counter}. {msg}")
+    return "\n".join(lines)
 
 
 @contextlib.contextmanager
-def soft_assertions() -> Iterator[None]:
+def soft_assertions() -> Iterator[SoftAssertionCollector]:
     """Create a soft assertion context.
 
     Normally, any assertion failure will halt test execution immediately by raising an error.
@@ -141,6 +155,14 @@ def soft_assertions() -> Iterator[None]:
             4. Expected <foo> to contain only digits, but did not.
             5. Expected <123> to contain only alphabetic chars, but did not.
 
+        Group errors by section::
+
+            with soft_assertions() as sa:
+                with sa.group("Headers"):
+                    assert_that(headers["Content-Type"]).is_equal_to("application/json")
+                with sa.group("Body"):
+                    assert_that(body["status"]).is_equal_to("ok")
+
     Note:
         The soft assertion context only collects *assertion* failures, other errors such as
         ``TypeError`` or ``ValueError`` are always raised immediately.  Triggering an explicit test
@@ -154,17 +176,40 @@ def soft_assertions() -> Iterator[None]:
     _soft_ctx.set(ctx + 1)
 
     try:
-        yield
+        yield SoftAssertionCollector()
     finally:
         _soft_ctx.set(_soft_ctx.get() - 1)
 
     errs = _soft_err.get([])
     if errs and _soft_ctx.get() == 0:
-        out = "soft assertion failures:\n" + "\n".join(f"{i + 1}. {msg}" for i, msg in enumerate(errs))
+        out = _format_soft_errors(errs)
         _soft_err.set([])
         raise AssertionError(out)
 
 
+def assert_all(*callables: Callable[[], object]) -> None:
+    """Run all callables inside a soft assertion context.
+
+    A convenience wrapper around :func:`soft_assertions` for inline use.
+
+    Examples:
+        Usage::
+
+            from assertpy2 import assert_all, assert_that
+
+            assert_all(
+                lambda: assert_that(x).is_positive(),
+                lambda: assert_that(y).is_not_none(),
+            )
+
+    Raises:
+        AssertionError: if any of the callables produce assertion failures
+    """
+    with soft_assertions():
+        for fn in callables:
+            fn()
+
+
 # factory methods
 
 
@@ -332,7 +377,7 @@ def soft_fail(msg=""):
 
     """
     if _soft_ctx.get():
-        _soft_err.get().append(f"Fail: {msg}!" if msg else "Fail!")
+        _soft_err.get().append((_soft_group.get(), f"Fail: {msg}!" if msg else "Fail!"))
         return
     fail(msg)
 
@@ -436,10 +481,70 @@ _logger.addHandler(_handler)
 _default_logger = WarningLoggingAdapter(_logger, None)
 
 
+class NegatedBuilder:
+    """Proxy that inverts the next assertion. Created by ``assert_that(val).not_``."""
+
+    def __init__(self, builder: AssertionBuilder) -> None:
+        self._builder = builder
+
+    def __getattr__(self, name: str) -> object:
+        attr = getattr(self._builder, name)
+        if not callable(attr):
+            return attr
+
+        def _negated(*args: object, **kwargs: object) -> AssertionBuilder:
+            if self._builder.kind == "soft":
+                return self._negated_soft(name, attr, *args, **kwargs)
+            if self._builder.kind == "warn":
+                return self._negated_warn(name, attr, *args, **kwargs)
+            return self._negated_strict(name, attr, *args, **kwargs)
+
+        return _negated
+
+    def _make_msg(self, name: str) -> str:
+        desc = f"[{self._builder.description}] " if self._builder.description else ""
+        return f"{desc}Expected <{self._builder.val}> to NOT satisfy: {name}()"
+
+    def _negated_strict(
+        self, name: str, attr: Callable[..., object], *args: object, **kwargs: object
+    ) -> AssertionBuilder:
+        try:
+            attr(*args, **kwargs)
+        except (AssertionError, AssertionFailure):
+            return self._builder
+        raise AssertionError(self._make_msg(name))
+
+    def _negated_soft(
+        self, name: str, attr: Callable[..., object], *args: object, **kwargs: object
+    ) -> AssertionBuilder:
+        err_list = _soft_err.get()
+        before = len(err_list)
+        attr(*args, **kwargs)
+        if len(err_list) > before:
+            del err_list[before:]
+            return self._builder
+        err_list.append((_soft_group.get(), self._make_msg(name)))
+        return self._builder
+
+    def _negated_warn(
+        self, name: str, attr: Callable[..., object], *args: object, **kwargs: object
+    ) -> AssertionBuilder:
+        self._builder.kind = None
+        try:
+            attr(*args, **kwargs)
+        except (AssertionError, AssertionFailure):
+            return self._builder
+        finally:
+            self._builder.kind = "warn"
+        self._builder.logger.warning(self._make_msg(name))
+        return self._builder
+
+
 class AssertionBuilder(
     StringMixin,
     SnapshotMixin,
     NumericMixin,
+    JsonMixin,
     HelpersMixin,
     FileMixin,
     ExtractingMixin,
@@ -474,6 +579,11 @@ class AssertionBuilder(
         self.logger = logger if logger else _default_logger
         self._not_expected = False
 
+    @property
+    def not_(self) -> NegatedBuilder:
+        """Invert the next assertion in the chain."""
+        return NegatedBuilder(self)
+
     def builder(self, val, description="", kind=None, expected=None, logger=None):
         """Helper to build a new :class:`AssertionBuilder` instance. Use this only if not chaining to ``self``.
 
@@ -515,7 +625,7 @@ class AssertionBuilder(
             self.logger.warning(out)
             return self
         elif self.kind == "soft":
-            _soft_err.get().append(out)
+            _soft_err.get().append((_soft_group.get(), out))
             return self
         else:
             if expected is not None or diff is not None: