Format test files with ruff

Apply ruff formatting to all test files as Stage 0 of the test linting
enablement plan. This separates formatting changes from type annotation
work for cleaner diffs and easier review.

Changes:
- 19 files reformatted (mainly removing unnecessary line breaks)
- 167 files already formatted (no changes)
- All tests still pass

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: dbrattli

tests/test_observable/test_batch_4_7_fluent.py

@@ -58,9 +58,7 @@ def test_last_or_default_with_default(self) -> None:
         """Verify last_or_default returns default when empty."""
         source: Observable[int] = rx.empty()
 
-        fluent_result: Observable[int | None] = source.last_or_default(
-            default_value=42
-        )
+        fluent_result: Observable[int | None] = source.last_or_default(default_value=42)
         pipe_result: Observable[int | None] = source.pipe(
             ops.last_or_default(default_value=42)
         )
@@ -199,7 +197,9 @@ def test_skip_last_with_time_equivalence(self) -> None:
 
         # With immediate scheduler and duration=0, should take all
         fluent_result: Observable[int] = source.skip_last_with_time(0, scheduler)
-        pipe_result: Observable[int] = source.pipe(ops.skip_last_with_time(0, scheduler))
+        pipe_result: Observable[int] = source.pipe(
+            ops.skip_last_with_time(0, scheduler)
+        )
 
         fluent_values: list[int] = []
         pipe_values: list[int] = []
@@ -220,7 +220,9 @@ def test_take_last_with_time_equivalence(self) -> None:
 
         # With immediate scheduler and large duration, should take all
         fluent_result: Observable[int] = source.take_last_with_time(1000, scheduler)
-        pipe_result: Observable[int] = source.pipe(ops.take_last_with_time(1000, scheduler))
+        pipe_result: Observable[int] = source.pipe(
+            ops.take_last_with_time(1000, scheduler)
+        )
 
         fluent_values: list[int] = []
         pipe_values: list[int] = []
@@ -241,7 +243,9 @@ def test_skip_until_with_time_equivalence(self) -> None:
 
         # With immediate scheduler and start_time in the past, should take all
         fluent_result: Observable[int] = source.skip_until_with_time(0, scheduler)
-        pipe_result: Observable[int] = source.pipe(ops.skip_until_with_time(0, scheduler))
+        pipe_result: Observable[int] = source.pipe(
+            ops.skip_until_with_time(0, scheduler)
+        )
 
         fluent_values: list[int] = []
         pipe_values: list[int] = []
@@ -262,7 +266,9 @@ def test_take_until_with_time_equivalence(self) -> None:
 
         # With immediate scheduler, use end_time=0 to avoid WouldBlockException
         fluent_result: Observable[int] = source.take_until_with_time(0, scheduler)
-        pipe_result: Observable[int] = source.pipe(ops.take_until_with_time(0, scheduler))
+        pipe_result: Observable[int] = source.pipe(
+            ops.take_until_with_time(0, scheduler)
+        )
 
         fluent_values: list[int] = []
         pipe_values: list[int] = []

tests/test_observable/test_buffer.py

@@ -268,7 +268,6 @@ def closing_mapper():
 
     def test_toggle_closing_with_empty_observable(self):
         with marbles_testing(timespan=1.0) as (start, cold, hot, exp):
-
             lookup = {"a": [2, 3], "b": [5], "c": [7], "d": [8, 9]}
 
             openings = hot("---a-------b------c---d-------|")
@@ -291,7 +290,6 @@ def closing_mapper(key):
 
     def test_toggle_closing_with_only_first_item(self):
         with marbles_testing(timespan=1.0) as (start, cold, hot, exp):
-
             lookup = {"a": [2, 3], "b": [5], "c": [7], "d": [8, 9]}
 
             openings = hot("---a-------b------c---d-------|")
@@ -319,7 +317,6 @@ class TestException(Exception):
         ex = TestException("test exception")
 
         with marbles_testing(timespan=1.0) as (start, cold, hot, exp):
-
             lookup = {"a": [2, 3], "b": [5], "c": [7], "d": [8, 9]}
 
             openings = hot("---a-------b------c---d-------|")
@@ -347,7 +344,6 @@ class TestException(Exception):
         ex = TestException("test exception")
 
         with marbles_testing(timespan=1.0) as (start, cold, hot, exp):
-
             lookup = {"a": [2, 3], "b": [5], "c": [7], "d": [8, 9]}
 
             openings = hot("---a-------b-----#", error=ex)
@@ -375,7 +371,6 @@ class TestException(Exception):
         ex = TestException("test exception")
 
         with marbles_testing(timespan=1.0) as (start, cold, hot, exp):
-
             lookup = {"a": [2, 3], "b": [5], "c": [7], "d": [8, 9]}
 
             openings = hot("---a-------b------c---d-------|")

tests/test_observable/test_combination_fluent.py

@@ -141,9 +141,7 @@ def test_zip_with_iterable_equivalence(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3)
         iterable: list[str] = ["a", "b", "c"]
 
-        fluent_result: Observable[tuple[int, str]] = source.zip_with_iterable(
-            iterable
-        )
+        fluent_result: Observable[tuple[int, str]] = source.zip_with_iterable(iterable)
         pipe_result: Observable[tuple[int, str]] = source.pipe(
             ops.zip_with_iterable(iterable)
         )
@@ -206,7 +204,9 @@ def test_group_join_equivalence(self) -> None:
         fluent_count: list[int] = []
         pipe_count: list[int] = []
 
-        def subscribe_to_group(x: tuple[int, Observable[int]], count_list: list[int]) -> None:
+        def subscribe_to_group(
+            x: tuple[int, Observable[int]], count_list: list[int]
+        ) -> None:
             _value, group = x
             group_values: list[int] = []
             group.subscribe(on_next=group_values.append)

tests/test_observable/test_conditional_fluent.py

@@ -46,9 +46,7 @@ def test_find_equivalence(self) -> None:
         """Verify find fluent and functional styles are equivalent."""
         source: Observable[int] = rx.of(1, 2, 3, 4, 5)
 
-        fluent_result: Observable[int | None] = source.find(
-            lambda x, i, obs: x > 3
-        )
+        fluent_result: Observable[int | None] = source.find(lambda x, i, obs: x > 3)
         pipe_result: Observable[int | None] = source.pipe(
             ops.find(lambda x, i, obs: x > 3)
         )
@@ -99,9 +97,7 @@ def test_find_index_not_found(self) -> None:
         """Test find_index when element is not found."""
         source: Observable[int] = rx.of(1, 2, 3)
 
-        result: Observable[int | None] = source.find_index(
-            lambda x, i, obs: x > 10
-        )
+        result: Observable[int | None] = source.find_index(lambda x, i, obs: x > 10)
 
         values: list[int | None] = []
         result.subscribe(on_next=values.append)

tests/test_observable/test_connectableobservable.py

@@ -18,7 +18,6 @@
 
 class MySubject(Observable, ObserverBase):
     def __init__(self):
-
         super(MySubject, self).__init__()
 
         self.dispose_on_map = {}

tests/test_observable/test_filtering_fluent.py

@@ -410,11 +410,10 @@ def test_complex_chain(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
         result: Observable[int] = (
-            source
-            .filter(lambda x: x % 2 == 0)  # [2, 4, 6, 8, 10]
-            .map(lambda x: x * 2)           # [4, 8, 12, 16, 20]
-            .skip(1)                        # [8, 12, 16, 20]
-            .take(3)                        # [8, 12, 16]
+            source.filter(lambda x: x % 2 == 0)  # [2, 4, 6, 8, 10]
+            .map(lambda x: x * 2)  # [4, 8, 12, 16, 20]
+            .skip(1)  # [8, 12, 16, 20]
+            .take(3)  # [8, 12, 16]
         )
 
         values: list[int] = []
@@ -427,11 +426,10 @@ def test_complex_phase3_chain(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
         result: Observable[bool] = (
-            source
-            .skip_last(2)                         # [1, 2, 3, 4, 5, 6, 7, 8]
-            .take_last(6)                         # [3, 4, 5, 6, 7, 8]
-            .filter(lambda x: x % 2 == 0)        # [4, 6, 8]
-            .all(lambda x: x > 3)                # Check if all > 3
+            source.skip_last(2)  # [1, 2, 3, 4, 5, 6, 7, 8]
+            .take_last(6)  # [3, 4, 5, 6, 7, 8]
+            .filter(lambda x: x % 2 == 0)  # [4, 6, 8]
+            .all(lambda x: x > 3)  # Check if all > 3
         )
 
         values: list[bool] = []

tests/test_observable/test_groupby.py

@@ -372,7 +372,6 @@ def action1(scheduler, state):
 
         def action2(scheduler, state):
             def next(group):
-
                 result = scheduler.create_observer()
                 c["inners"][group.key] = group
                 c["results"][group.key] = result

tests/test_observable/test_join.py

@@ -924,7 +924,6 @@ def create():
         assert subscribe_schedulers["duration_y"] is scheduler
 
     def test_join_op_forward_scheduler_None(self):
-
         subscribe_schedulers = {
             "x": "unknown",
             "y": "unknown",

tests/test_observable/test_mathematical_fluent.py

@@ -116,9 +116,7 @@ class Person(NamedTuple):
         )
 
         fluent_result: Observable[list[Person]] = source.min_by(lambda x: x.age)
-        pipe_result: Observable[list[Person]] = source.pipe(
-            ops.min_by(lambda x: x.age)
-        )
+        pipe_result: Observable[list[Person]] = source.pipe(ops.min_by(lambda x: x.age))
 
         fluent_values: list[list[Person]] = []
         pipe_values: list[list[Person]] = []
@@ -147,9 +145,7 @@ class Person(NamedTuple):
         )
 
         fluent_result: Observable[list[Person]] = source.max_by(lambda x: x.age)
-        pipe_result: Observable[list[Person]] = source.pipe(
-            ops.max_by(lambda x: x.age)
-        )
+        pipe_result: Observable[list[Person]] = source.pipe(ops.max_by(lambda x: x.age))
 
         fluent_values: list[list[Person]] = []
         pipe_values: list[list[Person]] = []
@@ -171,13 +167,12 @@ def test_filter_with_average(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
         result: Observable[float] = (
-            source
-            .filter(lambda x: x % 2 == 0)       # [2, 4, 6, 8, 10]
-            .take_while(lambda x: x < 9)        # [2, 4, 6, 8]
-            .map(lambda x: x * 2)                # [4, 8, 12, 16]
-            .distinct_until_changed()            # [4, 8, 12, 16]
-            .start_with(0)                       # [0, 4, 8, 12, 16]
-            .average()                           # [8.0]
+            source.filter(lambda x: x % 2 == 0)  # [2, 4, 6, 8, 10]
+            .take_while(lambda x: x < 9)  # [2, 4, 6, 8]
+            .map(lambda x: x * 2)  # [4, 8, 12, 16]
+            .distinct_until_changed()  # [4, 8, 12, 16]
+            .start_with(0)  # [0, 4, 8, 12, 16]
+            .average()  # [8.0]
         )
 
         values: list[float] = []

tests/test_observable/test_method_chaining.py

@@ -33,11 +33,10 @@ def test_complex_chain(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
         result: Observable[int] = (
-            source
-            .filter(lambda x: x % 2 == 0)  # [2, 4, 6, 8, 10]
-            .map(lambda x: x * 2)           # [4, 8, 12, 16, 20]
-            .skip(1)                        # [8, 12, 16, 20]
-            .take(3)                        # [8, 12, 16]
+            source.filter(lambda x: x % 2 == 0)  # [2, 4, 6, 8, 10]
+            .map(lambda x: x * 2)  # [4, 8, 12, 16, 20]
+            .skip(1)  # [8, 12, 16, 20]
+            .take(3)  # [8, 12, 16]
         )
 
         values: list[int] = []
@@ -50,8 +49,7 @@ def test_chain_with_reduce(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5)
 
         result: Observable[int] = (
-            source
-            .filter(lambda x: x > 2)
+            source.filter(lambda x: x > 2)
             .map(lambda x: x * 2)
             .reduce(lambda acc, x: acc + x, 0)
         )
@@ -66,13 +64,9 @@ def test_mixed_fluent_and_pipe(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5)
 
         # Start with fluent, then use pipe
-        result: Observable[int] = (
-            source
-            .map(lambda x: x * 2)
-            .pipe(
-                ops.filter(lambda x: x > 5),
-                ops.take(2),
-            )
+        result: Observable[int] = source.map(lambda x: x * 2).pipe(
+            ops.filter(lambda x: x > 5),
+            ops.take(2),
         )
 
         values: list[int] = []
@@ -89,13 +83,12 @@ def test_transformation_filtering_mathematical(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
         result: Observable[float] = (
-            source
-            .filter(lambda x: x % 2 == 0)       # FilteringMixin: [2, 4, 6, 8, 10]
-            .take_while(lambda x: x < 9)        # FilteringMixin: [2, 4, 6, 8]
-            .map(lambda x: x * 2)                # TransformationMixin: [4, 8, 12, 16]
-            .distinct_until_changed()            # FilteringMixin: [4, 8, 12, 16]
-            .start_with(0)                       # CombinationMixin: [0, 4, 8, 12, 16]
-            .average()                           # MathematicalMixin: [8.0]
+            source.filter(lambda x: x % 2 == 0)  # FilteringMixin: [2, 4, 6, 8, 10]
+            .take_while(lambda x: x < 9)  # FilteringMixin: [2, 4, 6, 8]
+            .map(lambda x: x * 2)  # TransformationMixin: [4, 8, 12, 16]
+            .distinct_until_changed()  # FilteringMixin: [4, 8, 12, 16]
+            .start_with(0)  # CombinationMixin: [0, 4, 8, 12, 16]
+            .average()  # MathematicalMixin: [8.0]
         )
 
         values: list[float] = []
@@ -108,11 +101,10 @@ def test_filtering_testing_chain(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
         result: Observable[bool] = (
-            source
-            .skip_last(2)                         # FilteringMixin: [1, 2, 3, 4, 5, 6, 7, 8]
-            .take_last(6)                         # FilteringMixin: [3, 4, 5, 6, 7, 8]
-            .filter(lambda x: x % 2 == 0)        # FilteringMixin: [4, 6, 8]
-            .all(lambda x: x > 3)                # TestingMixin: Check if all > 3
+            source.skip_last(2)  # FilteringMixin: [1, 2, 3, 4, 5, 6, 7, 8]
+            .take_last(6)  # FilteringMixin: [3, 4, 5, 6, 7, 8]
+            .filter(lambda x: x % 2 == 0)  # FilteringMixin: [4, 6, 8]
+            .all(lambda x: x > 3)  # TestingMixin: Check if all > 3
         )
 
         values: list[bool] = []
@@ -131,12 +123,11 @@ def cleanup_action() -> None:
             action_called = True
 
         result: Observable[list[int]] = (
-            source
-            .do_action(side_effects.append)      # UtilityMixin
-            .filter(lambda x: x > 2)             # FilteringMixin
-            .map(lambda x: x * 2)                # TransformationMixin
-            .to_list()                           # UtilityMixin
-            .finally_action(cleanup_action)      # UtilityMixin
+            source.do_action(side_effects.append)  # UtilityMixin
+            .filter(lambda x: x > 2)  # FilteringMixin
+            .map(lambda x: x * 2)  # TransformationMixin
+            .to_list()  # UtilityMixin
+            .finally_action(cleanup_action)  # UtilityMixin
         )
 
         values: list[list[int]] = []
@@ -152,10 +143,9 @@ def test_combination_error_handling(self) -> None:
         fallback: Observable[int] = rx.of(1, 2, 3)
 
         result: Observable[int] = (
-            source
-            .catch(fallback)                     # ErrorHandlingMixin
-            .start_with(0)                       # CombinationMixin
-            .take(3)                             # FilteringMixin
+            source.catch(fallback)  # ErrorHandlingMixin
+            .start_with(0)  # CombinationMixin
+            .take(3)  # FilteringMixin
         )
 
         values: list[int] = []
@@ -170,11 +160,11 @@ def test_windowing_transformation_testing(self) -> None:
         # Test partition followed by operations on one partition
         evens, _odds = source.partition(lambda x: x % 2 == 0)
 
-        result: Observable[bool] = (
-            evens
-            .map(lambda x: x * 2)                # TransformationMixin: [4, 8, 12]
-            .all(lambda x: x % 4 == 0)           # TestingMixin: Check divisible by 4
-        )
+        result: Observable[bool] = evens.map(
+            lambda x: x * 2
+        ).all(  # TransformationMixin: [4, 8, 12]
+            lambda x: x % 4 == 0
+        )  # TestingMixin: Check divisible by 4
 
         values: list[bool] = []
         result.subscribe(on_next=values.append)
@@ -190,8 +180,7 @@ def test_pipe_then_fluent(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5)
 
         result: Observable[int] = (
-            source
-            .pipe(
+            source.pipe(
                 ops.filter(lambda x: x > 2),
                 ops.map(lambda x: x * 2),
             )
@@ -209,8 +198,7 @@ def test_fluent_then_pipe_then_fluent(self) -> None:
         source: Observable[int] = rx.of(1, 2, 3, 4, 5, 6, 7, 8)
 
         result: Observable[int] = (
-            source
-            .filter(lambda x: x > 2)
+            source.filter(lambda x: x > 2)
             .pipe(
                 ops.map(lambda x: x * 2),
                 ops.take(3),