Apply pinned formatting

Author: pzelasko

lhotse/cut/set.py

@@ -4177,7 +4177,9 @@ def _mix_one(self, cut: Cut, rng: random.Random) -> Cut:
         # Actual mixing
         to_mix = self._next_mix_in_cut(rng)
         to_mix = self._maybe_truncate_cut(to_mix, target_mixed_duration, rng)
-        mixed = cut.mix(other=to_mix, snr=cut_snr, preserve_id=self.preserve_id, tag=self.tag)
+        mixed = cut.mix(
+            other=to_mix, snr=cut_snr, preserve_id=self.preserve_id, tag=self.tag
+        )
         # Did the user specify a duration?
         # If yes, we will ensure that shorter cuts have more noise mixed in
         # to "pad" them with at the end.

lhotse/lazy.py

@@ -611,7 +611,11 @@ def state_dict(self) -> dict:
         # ``shuffle`` and ``seed`` are surfaced in the dict for inspection
         # and forward-compat — they are not consumed on load (the iterator
         # is reconstructed with the same constructor args).
-        return {**self._iter_state.state_dict(), "shuffle": self.shuffle, "seed": self.seed}
+        return {
+            **self._iter_state.state_dict(),
+            "shuffle": self.shuffle,
+            "seed": self.seed,
+        }
 
     def load_state_dict(self, sd: dict) -> None:
         if self.shuffle and "range" not in sd:

lhotse/shar/readers/indexed.py

@@ -128,7 +128,8 @@ def __init__(
         self._lazy = lazy
         self.epoch = 0
         self._iter_state = PartitionedIndexedIterator(
-            shuffle=self.shuffle, seed=resolve_seed(self.seed) if isinstance(self.seed, int) else 0
+            shuffle=self.shuffle,
+            seed=resolve_seed(self.seed) if isinstance(self.seed, int) else 0,
         )
 
         # Build indexed readers for cuts JSONL shards and compute lengths.

test/ais/test_batch_loader_moss_in.py

@@ -20,7 +20,6 @@
 
 from aistore.sdk.batch.types import MossIn, MossReq
 
-
 # ---------------------------------------------------------------------------
 # Field presence: the fast path passes specific kwargs to MossIn — assert
 # they're all real fields on the current SDK so a rename surfaces here.
@@ -44,9 +43,7 @@ def test_mossin_obj_name_is_required():
     """``obj_name`` is the only required field today; if more get added,
     the fast path's kwargs-sparse build silently produces an invalid request."""
     required = [
-        name
-        for name, info in MossIn.model_fields.items()
-        if info.is_required()
+        name for name, info in MossIn.model_fields.items() if info.is_required()
     ]
     assert set(required) <= {"obj_name"}, (
         f"MossIn introduced new required fields {set(required) - {'obj_name'}} "
@@ -65,18 +62,39 @@ def test_mossin_obj_name_is_required():
 
 _FAST_KWARG_COMBOS = [
     # (description, kwargs)
-    ("url-only (e.g. recording.source.type='url')",
-     {"obj_name": "audio.wav", "bck": "bkt", "provider": "ais"}),
-    ("url with archpath (tar member)",
-     {"obj_name": "shard.tar", "bck": "bkt", "provider": "ais", "archpath": "rec1.wav"}),
-    ("shar_ptr (byte-range)",
-     {"obj_name": "shard.tar", "bck": "bkt", "provider": "ais", "start": 4096, "length": 65536}),
-    ("aws provider variant",
-     {"obj_name": "shard.tar", "bck": "bkt", "provider": "aws"}),
+    (
+        "url-only (e.g. recording.source.type='url')",
+        {"obj_name": "audio.wav", "bck": "bkt", "provider": "ais"},
+    ),
+    (
+        "url with archpath (tar member)",
+        {
+            "obj_name": "shard.tar",
+            "bck": "bkt",
+            "provider": "ais",
+            "archpath": "rec1.wav",
+        },
+    ),
+    (
+        "shar_ptr (byte-range)",
+        {
+            "obj_name": "shard.tar",
+            "bck": "bkt",
+            "provider": "ais",
+            "start": 4096,
+            "length": 65536,
+        },
+    ),
+    (
+        "aws provider variant",
+        {"obj_name": "shard.tar", "bck": "bkt", "provider": "aws"},
+    ),
 ]
 
 
-@pytest.mark.parametrize("desc,kwargs", _FAST_KWARG_COMBOS, ids=[c[0] for c in _FAST_KWARG_COMBOS])
+@pytest.mark.parametrize(
+    "desc,kwargs", _FAST_KWARG_COMBOS, ids=[c[0] for c in _FAST_KWARG_COMBOS]
+)
 def test_model_construct_matches_validating_constructor(desc: str, kwargs: dict):
     """``MossIn.model_construct(**kwargs)`` must serialize identically to
     ``MossIn(**kwargs)`` — same field values, same defaults for omitted
@@ -119,6 +137,7 @@ def test_mossreq_has_moss_in_list_field():
     annotation = MossReq.model_fields["moss_in"].annotation
     # typing.List[MossIn] subscripts; check origin is list-like.
     import typing as _t
+
     assert _t.get_origin(annotation) is list, (
         f"MossReq.moss_in type changed from List[MossIn] to {annotation} "
         f"on aistore {aistore.__version__}. Fast path's append() may break."
@@ -141,6 +160,7 @@ def test_batch_requests_list_is_public_accessor():
     # Most robust check is source inspection (kept lenient — only flag a hard
     # rename of 'moss_in', anything else gets caught by the round-trip tests).
     import inspect
+
     src = inspect.getsource(descriptor.fget)
     assert "moss_in" in src, (
         f"Batch.requests_list source no longer references moss_in on "

test/dataset/sampling/test_sampler_restoring.py

@@ -356,7 +356,9 @@ def test_load_state_dict_rejects_cross_rank_state():
     src = SimpleCutSampler(CUTS, max_duration=10.0, world_size=4, rank=0)
     dst = SimpleCutSampler(CUTS, max_duration=10.0, world_size=4, rank=2)
     state = src.state_dict()
-    with pytest.raises(RuntimeError, match="state was saved on rank=0 but is being loaded on rank=2"):
+    with pytest.raises(
+        RuntimeError, match="state was saved on rank=0 but is being loaded on rank=2"
+    ):
         dst.load_state_dict(state)
 
 

test/dataset/test_checkpoint_restore.py

@@ -564,7 +564,9 @@ def test_mixed_raises(self, cuts):
         from lhotse.lazy import LazyIteratorMultiplexer
 
         streaming_leaf = self._make_streaming_leaf()(list(cuts)[:50])
-        indexed_leaf = _IndexedCutsWithoutGraphOrigin(list(cuts)[50:])  # has_constant_time_access=True per definition above
+        indexed_leaf = _IndexedCutsWithoutGraphOrigin(
+            list(cuts)[50:]
+        )  # has_constant_time_access=True per definition above
         mux = LazyIteratorMultiplexer(streaming_leaf, indexed_leaf, seed=0)
         cs = CutSet(mux)
 

test/shar/test_indexed_partition.py

@@ -32,7 +32,6 @@
 from lhotse.shar.writers import SharWriter
 from lhotse.testing.dummies import DummyManifest
 
-
 _PARTITION_ENV_KEYS = ("RANK", "WORLD_SIZE", LHOTSE_USE_WORKER_PARTITION)
 
 
@@ -91,9 +90,9 @@ def test_indexed_shar_partition_disjoint_and_complete(indexed_shar_dir, world_si
         with _env_partition(rank=rank, world_size=world_size):
             ids = {c.id for c in LazyIndexedSharIterator(in_dir=indexed_shar_dir)}
         for prev in per_rank:
-            assert prev.isdisjoint(ids), (
-                f"rank {rank} slice overlaps prior rank: {sorted(prev & ids)}"
-            )
+            assert prev.isdisjoint(
+                ids
+            ), f"rank {rank} slice overlaps prior rank: {sorted(prev & ids)}"
         per_rank.append(ids)
 
     union: set = set()
@@ -172,11 +171,16 @@ def test_indexed_shar_partition_works_with_shuffle(indexed_shar_dir, shuffle):
     union: set = set()
     for rank in range(world_size):
         with _env_partition(rank=rank, world_size=world_size):
-            ids = {c.id for c in LazyIndexedSharIterator(
-                in_dir=indexed_shar_dir, shuffle=shuffle, seed=42,
-            )}
-        assert union.isdisjoint(ids), (
-            f"rank {rank} overlaps: {sorted(union & ids)} (shuffle={shuffle})"
-        )
+            ids = {
+                c.id
+                for c in LazyIndexedSharIterator(
+                    in_dir=indexed_shar_dir,
+                    shuffle=shuffle,
+                    seed=42,
+                )
+            }
+        assert union.isdisjoint(
+            ids
+        ), f"rank {rank} overlaps: {sorted(union & ids)} (shuffle={shuffle})"
         union |= ids
     assert union == expected

test/test_indexing.py

@@ -216,15 +216,15 @@ def worker():
 
     assert not errors, f"workers raised: {errors[:3]}"
     assert lengths, "no worker reported a length — barrier wait failed?"
-    assert all(L == n_records for L in lengths), (
-        f"workers saw inconsistent lengths {Counter(lengths)}; expected all == {n_records}"
-    )
+    assert all(
+        L == n_records for L in lengths
+    ), f"workers saw inconsistent lengths {Counter(lengths)}; expected all == {n_records}"
 
     # Final .idx must be non-empty + size-aligned to uint64.
     idx_size = index_file_path(p).stat().st_size
-    assert idx_size > 0 and idx_size % 8 == 0, (
-        f"final .idx is {idx_size} bytes — not a clean uint64 array"
-    )
+    assert (
+        idx_size > 0 and idx_size % 8 == 0
+    ), f"final .idx is {idx_size} bytes — not a clean uint64 array"
 
 
 # ---------------------------------------------------------------------------
@@ -428,7 +428,9 @@ def test_lazy_shuffled_range_partition_shard_lengths(n, num_shards):
     total = 0
     for shard_id in range(num_shards):
         shard = LazyShuffledRange(n, seed=42, shard_id=shard_id, num_shards=num_shards)
-        expected_len = max(0, (n - shard_id + num_shards - 1) // num_shards) if n > shard_id else 0
+        expected_len = (
+            max(0, (n - shard_id + num_shards - 1) // num_shards) if n > shard_id else 0
+        )
         assert len(shard) == expected_len
         total += len(shard)
     assert total == n
@@ -1199,7 +1201,9 @@ def fake_open_best(path, mode="r"):
             return original_open_best(target, mode)
         return original_open_best(path, mode)
 
-    monkeypatch.setattr(indexing_mod, "_open_for_indexed_read", fake_open_for_indexed_read)
+    monkeypatch.setattr(
+        indexing_mod, "_open_for_indexed_read", fake_open_for_indexed_read
+    )
     monkeypatch.setattr(indexing_mod, "open_best", fake_open_best)
 
 
@@ -1298,9 +1302,7 @@ def test_indexed_tar_reader_remote_data_with_remote_index_path(
     assert str(data_path) == samples[1][0]
 
 
-def test_read_index_remote_path_is_cached_locally(
-    tmp_path, jsonl_file, monkeypatch
-):
+def test_read_index_remote_path_is_cached_locally(tmp_path, jsonl_file, monkeypatch):
     """Remote index files are downloaded once, cached on disk, and reused
     from the cache on subsequent calls (no second remote fetch)."""
     import lhotse.indexing as indexing_mod