chore: eliminate ~1900 test warnings by upgrading deps and fixing deprecated usage

- Bump pytest-asyncio >=0.25.0 and pytest-mock >=3.14.0 to fix ~1800
  asyncio DeprecationWarnings on Python 3.14
- Remove deprecated `path` parameter from pytest_ignore_collect (PytestRemovedIn9Warning)
- Add filterwarnings for PytestBenchmarkWarning (expected with xdist)
- Migrate test_weighted_transitions.py from deprecated `current_state` to `configuration`
- Convert release notes 2.3/2.4/2.5 doctests using `current_state` to plain python blocks

Author: fgmacedo

AGENTS.md

@@ -127,6 +127,10 @@ timeout 120 uv run pytest -n 4
 
 Testes normally run under 60s (~40s on average), so take a closer look if they take longer, it can be a regression.
 
+When analyzing warnings or extensive output, run the tests **once** saving the output to a file
+(`> /tmp/pytest-output.txt 2>&1`), then analyze the file — instead of running the suite
+repeatedly with different greps.
+
 Coverage is enabled by default (`--cov` is in `pyproject.toml`'s `addopts`). To generate a
 coverage report to a file, pass `--cov-report` **in addition to** `--cov`:
 

conftest.py

@@ -29,11 +29,11 @@ def __init__(self):
     doctest_namespace["asyncio"] = ContribAsyncio()
 
 
-def pytest_ignore_collect(collection_path, path, config):
+def pytest_ignore_collect(collection_path, config):
     if sys.version_info >= (3, 10):  # noqa: UP036
         return None
 
-    if "django_project" in str(path):
+    if "django_project" in str(collection_path):
         return True
 
 

docs/releases/2.3.0.md

@@ -26,24 +26,22 @@ async code with a state machine.
 ```
 
 
-```py
->>> class AsyncStateMachine(StateMachine):
-...     initial = State('Initial', initial=True)
-...     final = State('Final', final=True)
-...
-...     advance = initial.to(final)
-...
-...     async def on_advance(self):
-...         return 42
+```python
+class AsyncStateMachine(StateMachine):
+    initial = State('Initial', initial=True)
+    final = State('Final', final=True)
 
+    advance = initial.to(final)
 
+    async def on_advance(self):
+        return 42
 
->>> async def run_sm():
-...     sm = AsyncStateMachine()
-...     res = await sm.advance()
-...     return (42, sm.current_state.name)
 
->>> asyncio.run(run_sm())
-(42, 'Final')
+async def run_sm():
+    sm = AsyncStateMachine()
+    res = await sm.advance()
+    return (42, sm.current_state.name)
 
+asyncio.run(run_sm())
+# (42, 'Final')
 ```

docs/releases/2.4.0.md

@@ -16,31 +16,29 @@ This release introduces support for conditionals with Boolean algebra. You can n
 
 Example (with a spoiler of the next highlight):
 
-```py
->>> from statemachine import StateMachine, State, Event
+```python
+from statemachine import StateMachine, State, Event
 
->>> class AnyConditionSM(StateMachine):
-...     start = State(initial=True)
-...     end = State(final=True)
-...
-...     submit = Event(
-...         start.to(end, cond="used_money or used_credit"),
-...         name="finish order",
-...     )
-...
-...     used_money: bool = False
-...     used_credit: bool = False
+class AnyConditionSM(StateMachine):
+    start = State(initial=True)
+    end = State(final=True)
+
+    submit = Event(
+        start.to(end, cond="used_money or used_credit"),
+        name="finish order",
+    )
 
->>> sm = AnyConditionSM()
->>> sm.submit()
-Traceback (most recent call last):
-TransitionNotAllowed: Can't finish order when in Start.
+    used_money: bool = False
+    used_credit: bool = False
 
->>> sm.used_credit = True
->>> sm.submit()
->>> sm.current_state.id
-'end'
+sm = AnyConditionSM()
+sm.submit()
+# TransitionNotAllowed: Can't finish order when in Start.
 
+sm.used_credit = True
+sm.submit()
+sm.current_state.id
+# 'end'
 ```
 
 ```{seealso}

docs/releases/2.5.0.md

@@ -64,46 +64,27 @@ You can think of the event as an implementation of the **command** design patter
 On this example, we iterate until the state machine reaches a final state,
 listing the current state allowed events and executing the simulated user choice:
 
-```
->>> import random
->>> random.seed("15")
+```python
+import random
+random.seed("15")
 
->>> sm = AccountStateMachine()
+sm = AccountStateMachine()
 
->>> while not sm.current_state.final:
-...     allowed_events = sm.allowed_events
-...     print("Choose an action: ")
-...     for idx, event in enumerate(allowed_events):
-...         print(f"{idx} - {event.name}")
-...
-...     user_input = random.randint(0, len(allowed_events)-1)
-...     print(f"User input: {user_input}")
-...
-...     event = allowed_events[user_input]
-...     print(f"Running the option {user_input} - {event.name}")
-...     event()
-Choose an action:
-0 - Suspend
-1 - Overdraft
-2 - Close account
-User input: 0
-Running the option 0 - Suspend
-Choose an action:
-0 - Activate
-1 - Close account
-User input: 0
-Running the option 0 - Activate
-Choose an action:
-0 - Suspend
-1 - Overdraft
-2 - Close account
-User input: 2
-Running the option 2 - Close account
-Account has been closed.
+while not sm.current_state.final:
+    allowed_events = sm.allowed_events
+    print("Choose an action: ")
+    for idx, event in enumerate(allowed_events):
+        print(f"{idx} - {event.name}")
+
+    user_input = random.randint(0, len(allowed_events)-1)
+    print(f"User input: {user_input}")
 
->>> print(f"SM is in {sm.current_state.name} state.")
-SM is in Closed state.
+    event = allowed_events[user_input]
+    print(f"Running the option {user_input} - {event.name}")
+    event()
 
+print(f"SM is in {sm.current_state.name} state.")
+# SM is in Closed state.
 ```
 
 ### Conditions expressions in 2.5.0
@@ -120,30 +101,28 @@ The following comparison operators are supported:
 
 Example:
 
-```py
->>> from statemachine import StateMachine, State, Event
+```python
+from statemachine import StateMachine, State, Event
 
->>> class AnyConditionSM(StateMachine):
-...     start = State(initial=True)
-...     end = State(final=True)
-...
-...     submit = Event(
-...         start.to(end, cond="order_value > 100"),
-...         name="finish order",
-...     )
-...
-...     order_value: float = 0
+class AnyConditionSM(StateMachine):
+    start = State(initial=True)
+    end = State(final=True)
+
+    submit = Event(
+        start.to(end, cond="order_value > 100"),
+        name="finish order",
+    )
 
->>> sm = AnyConditionSM()
->>> sm.submit()
-Traceback (most recent call last):
-TransitionNotAllowed: Can't finish order when in Start.
+    order_value: float = 0
 
->>> sm.order_value = 135.0
->>> sm.submit()
->>> sm.current_state.id
-'end'
+sm = AnyConditionSM()
+sm.submit()
+# TransitionNotAllowed: Can't finish order when in Start.
 
+sm.order_value = 135.0
+sm.submit()
+sm.current_state.id
+# 'end'
 ```
 
 ```{seealso}

pyproject.toml

@@ -39,9 +39,9 @@ dev = [
     "pytest-cov >=6.0.0; python_version >='3.9'",
     "pytest-cov; python_version <'3.9'",
     "pytest-sugar >=1.0.0",
-    "pytest-mock >=3.10.0",
+    "pytest-mock >=3.14.0",
     "pytest-benchmark >=4.0.0",
-    "pytest-asyncio",
+    "pytest-asyncio >=0.25.0",
     "pydot",
     "django >=5.2.11; python_version >='3.10'",
     "pytest-django >=4.8.0; python_version >'3.8'",
@@ -93,6 +93,9 @@ log_cli_level = "DEBUG"
 log_cli_format = "%(relativeCreated)6.0fms %(threadName)-18s %(name)-35s %(message)s"
 log_cli_date_format = "%H:%M:%S"
 asyncio_default_fixture_loop_scope = "module"
+filterwarnings = [
+    "ignore::pytest_benchmark.logger.PytestBenchmarkWarning",
+]
 
 [tool.coverage.run]
 branch = true

tests/test_weighted_transitions.py

@@ -22,20 +22,20 @@ class TestWeightedTransitionsBasic:
     def test_deterministic_with_seed(self, WeightedIdleSC):
         sm = WeightedIdleSC()
         sm.send("idle")
-        first_state = sm.current_state
+        first_config = sm.configuration
 
         sm.send("finish")
         sm.send("idle")
-        second_state = sm.current_state
+        second_config = sm.configuration
 
         # With seed=42, results are deterministic
         # Create a fresh instance to verify same seed produces same sequence
         sm2 = WeightedIdleSC()
         sm2.send("idle")
-        assert sm2.current_state == first_state
+        assert sm2.configuration == first_config
         sm2.send("finish")
         sm2.send("idle")
-        assert sm2.current_state == second_state
+        assert sm2.configuration == second_config
 
     def test_statistical_distribution(self, WeightedIdleSC):
         """Over many iterations, the distribution should approximate the weights."""
@@ -45,7 +45,7 @@ def test_statistical_distribution(self, WeightedIdleSC):
 
         for _ in range(iterations):
             sm.send("idle")
-            counts[sm.current_state.id] += 1
+            counts[next(iter(sm.configuration)).id] += 1
             sm.send("finish")
 
         # With 70/20/10 weights, check roughly correct distribution (within 5%)
@@ -63,7 +63,7 @@ class SingleWeighted(StateChart):
 
         sm = SingleWeighted()
         sm.send("go")
-        assert sm.current_state == SingleWeighted.s2
+        assert sm.configuration == {SingleWeighted.s2}
 
     def test_equal_weights(self):
         class EqualWeights(StateChart):
@@ -80,7 +80,7 @@ class EqualWeights(StateChart):
 
         for _ in range(iterations):
             sm.send("go")
-            counts[sm.current_state.id] += 1
+            counts[next(iter(sm.configuration)).id] += 1
             sm.send("back")
 
         # Should be roughly 50/50 within 5%
@@ -102,7 +102,7 @@ class FloatWeights(StateChart):
 
         for _ in range(iterations):
             sm.send("go")
-            counts[sm.current_state.id] += 1
+            counts[next(iter(sm.configuration)).id] += 1
             sm.send("back")
 
         assert abs(counts["s2"] / iterations - 0.70) < 0.05
@@ -119,7 +119,7 @@ class MixedWeights(StateChart):
 
         sm = MixedWeights()
         sm.send("go")
-        assert sm.current_state in (MixedWeights.s2, MixedWeights.s3)
+        assert sm.configuration & {MixedWeights.s2, MixedWeights.s3}
 
 
 class TestWeightedTransitionsWithGuards:
@@ -147,7 +147,7 @@ def is_allowed(self):
         counts = Counter()
         for _ in range(1000):
             sm.send("go")
-            counts[sm.current_state.id] += 1
+            counts[next(iter(sm.configuration)).id] += 1
             sm.send("back")
 
         assert counts["s2"] > 0
@@ -175,7 +175,7 @@ def is_blocked(self):
 
         # When not blocked, s2 can fire
         sm.send("go")
-        first_state = sm.current_state
+        first_state = next(iter(sm.configuration))
         sm.send("back")
 
         # When blocked, s2 cond fails even if weight selects it
@@ -184,7 +184,7 @@ def is_blocked(self):
         for _ in range(100):
             try:
                 sm.send("go")
-                results[sm.current_state.id] += 1
+                results[next(iter(sm.configuration)).id] += 1
                 sm.send("back")
             except Exception:
                 results["failed"] += 1
@@ -427,12 +427,12 @@ class MultiGroup(StateChart):
         sm = MultiGroup()
 
         sm.send("go_a")
-        state_a = sm.current_state
+        state_a = next(iter(sm.configuration))
         assert state_a in (MultiGroup.s2, MultiGroup.s3)
         sm.send("back")
 
         sm.send("go_b")
-        state_b = sm.current_state
+        state_b = next(iter(sm.configuration))
         assert state_b in (MultiGroup.s4, MultiGroup.s5)