hydraflow 0.2.16__tar.gz → 0.2.17__tar.gz

{hydraflow-0.2.16 → hydraflow-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hydraflow
-Version: 0.2.16
+Version: 0.2.17
 Summary: Hydraflow integrates Hydra and MLflow to manage and track machine learning experiments.
 Project-URL: Documentation, https://github.com/daizutabi/hydraflow
 Project-URL: Source, https://github.com/daizutabi/hydraflow

{hydraflow-0.2.16 → hydraflow-0.2.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hydraflow"
-version = "0.2.16"
+version = "0.2.17"
 description = "Hydraflow integrates Hydra and MLflow to manage and track machine learning experiments."
 readme = "README.md"
 license = "MIT"
@@ -66,6 +66,7 @@ target-version = "py310"
 
 [tool.ruff.lint]
 select = ["ALL"]
+unfixable = ["F401"]
 ignore = [
   "ANN003",
   "ANN401",

hydraflow-0.2.17/src/hydraflow/param.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def match(param: str, value: Any) -> bool:
+    """Check if the string matches the specified value.
+
+    Args:
+        param (str): The parameter to check.
+        value (Any): The value to check.
+
+    Returns:
+        True if the parameter matches the specified value,
+        False otherwise.
+    """
+    if value in [None, True, False]:
+        return param == str(value)
+
+    if isinstance(value, list) and (m := _match_list(param, value)) is not None:
+        return m
+
+    if isinstance(value, tuple) and (m := _match_tuple(param, value)) is not None:
+        return m
+
+    if isinstance(value, int | float | str):
+        return type(value)(param) == value
+
+    return param == str(value)
+
+
+def _match_list(param: str, value: list) -> bool | None:
+    if not value:
+        return None
+
+    if any(param.startswith(x) for x in ["[", "(", "{"]):
+        return None
+
+    if isinstance(value[0], bool):
+        return None
+
+    if not isinstance(value[0], int | float | str):
+        return None
+
+    return type(value[0])(param) in value
+
+
+def _match_tuple(param: str, value: tuple) -> bool | None:
+    if len(value) != 2:  # noqa: PLR2004
+        return None
+
+    if any(param.startswith(x) for x in ["[", "(", "{"]):
+        return None
+
+    if isinstance(value[0], bool):
+        return None
+
+    if not isinstance(value[0], int | float | str):
+        return None
+
+    if type(value[0]) is not type(value[1]):
+        return None
+
+    return value[0] <= type(value[0])(param) < value[1]  # type: ignore

{hydraflow-0.2.16 → hydraflow-0.2.17}/src/hydraflow/run_collection.py

@@ -23,6 +23,7 @@ from dataclasses import dataclass, field
 from itertools import chain
 from typing import TYPE_CHECKING, Any, Concatenate, ParamSpec, TypeVar, overload
 
+import hydraflow.param
 from hydraflow.config import iter_params
 from hydraflow.info import RunCollectionInfo
 
@@ -86,6 +87,9 @@ class RunCollection:
     def __contains__(self, run: Run) -> bool:
         return run in self._runs
 
+    def __bool__(self) -> bool:
+        return bool(self._runs)
+
     @classmethod
     def from_list(cls, runs: list[Run]) -> RunCollection:
         """Create a `RunCollection` instance from a list of MLflow `Run` instances."""
@@ -569,37 +573,15 @@ class RunCollection:
 
 
 def _param_matches(run: Run, key: str, value: Any) -> bool:
-    """
-    Check if the run's parameter matches the specified key-value pair.
-
-    Check if the run's parameters contain the specified
-    key-value pair. It handles different types of values, including lists
-    and tuples.
-
-    Args:
-        run (Run): The run object to check.
-        key (str): The parameter key to check.
-        value (Any): The parameter value to check.
-
-    Returns:
-        True if the run's parameter matches the specified key-value pair,
-        False otherwise.
-    """
-    param = run.data.params.get(key, value)
-
-    if param is None:
-        return False
+    params = run.data.params
+    if key not in params:
+        return True
 
+    param = params[key]
     if param == "None":
-        return value is None
-
-    if isinstance(value, list) and value:
-        return type(value[0])(param) in value
-
-    if isinstance(value, tuple) and len(value) == 2:  # noqa: PLR2004
-        return value[0] <= type(value[0])(param) < value[1]
+        return value is None or value == "None"
 
-    return type(value)(param) == value
+    return hydraflow.param.match(param, value)
 
 
 def filter_runs(

{hydraflow-0.2.16 → hydraflow-0.2.17}/tests/scripts/app.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 import time
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 import hydra
@@ -18,6 +18,7 @@ log = logging.getLogger(__name__)
 class MySQLConfig:
     host: str = "localhost"
     port: int = 3306
+    values: list[int] = field(default_factory=lambda: [1, 2, 3])
 
 
 cs = ConfigStore.instance()

{hydraflow-0.2.16 → hydraflow-0.2.17}/tests/test_app.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING
 
 import mlflow
 import pytest
+from omegaconf import OmegaConf
 
 if TYPE_CHECKING:
     from omegaconf import DictConfig
@@ -77,10 +78,10 @@ def test_app_info_run_id(rc: RunCollection):
 
 def test_app_info_params(rc: RunCollection):
     params = rc.info.params
-    assert params[0] == {"port": "1", "host": "x"}
-    assert params[1] == {"port": "2", "host": "x"}
-    assert params[2] == {"port": "1", "host": "y"}
-    assert params[3] == {"port": "2", "host": "y"}
+    assert params[0] == {"port": "1", "host": "x", "values": "[1, 2, 3]"}
+    assert params[1] == {"port": "2", "host": "x", "values": "[1, 2, 3]"}
+    assert params[2] == {"port": "1", "host": "y", "values": "[1, 2, 3]"}
+    assert params[3] == {"port": "2", "host": "y", "values": "[1, 2, 3]"}
 
 
 def test_app_info_metrics(rc: RunCollection):
@@ -138,7 +139,20 @@ def test_app_map_config(rc: RunCollection):
 def test_app_group_by(rc: RunCollection):
     grouped = rc.group_by("host")
     assert len(grouped) == 2
-    assert grouped[("x",)].info.params[0] == {"port": "1", "host": "x"}
-    assert grouped[("x",)].info.params[1] == {"port": "2", "host": "x"}
-    assert grouped[("y",)].info.params[0] == {"port": "1", "host": "y"}
-    assert grouped[("y",)].info.params[1] == {"port": "2", "host": "y"}
+    x = {"port": "1", "host": "x", "values": "[1, 2, 3]"}
+    assert grouped[("x",)].info.params[0] == x
+    x = {"port": "2", "host": "x", "values": "[1, 2, 3]"}
+    assert grouped[("x",)].info.params[1] == x
+    x = {"port": "1", "host": "y", "values": "[1, 2, 3]"}
+    assert grouped[("y",)].info.params[0] == x
+    x = {"port": "2", "host": "y", "values": "[1, 2, 3]"}
+    assert grouped[("y",)].info.params[1] == x
+
+
+def test_app_filter_list(rc: RunCollection):
+    filtered = rc.filter(values=[1, 2, 3])
+    assert len(filtered) == 4
+    filtered = rc.filter(values=OmegaConf.create([1, 2, 3]))
+    assert len(filtered) == 4
+    filtered = rc.filter(values=[1])
+    assert not filtered

{hydraflow-0.2.16 → hydraflow-0.2.17}/tests/test_config.py

@@ -1,7 +1,8 @@
+import json
 from dataclasses import dataclass, field
 
 import pytest
-from omegaconf import OmegaConf
+from omegaconf import ListConfig, OmegaConf
 
 
 def test_is_param_with_simple_values():
@@ -176,3 +177,23 @@ def test_iter_params_with_mixed_types_in_list():
     assert next(it) == ("items.0", "a")
     assert next(it) == ("items.1", 1)
     assert next(it) == ("items.2.key", "value")
+
+
+@pytest.mark.parametrize("type_", [int, float])
+@pytest.mark.parametrize("s", ["[1, 2, 3]", "[1.0, 2.0, 3.0]"])
+def test_list_config(type_, s):
+    a = [type_(x) for x in [1, 2, 3]]
+    b = OmegaConf.create(a)
+    assert isinstance(b, ListConfig)
+    t = OmegaConf.create(json.loads(s))
+    assert b == t
+    assert a == t
+
+
+@pytest.mark.parametrize("s", ['["a", "b", "c"]'])
+def test_list_config_str(s):
+    a = ["a", "b", "c"]
+    b = OmegaConf.create(a)
+    assert isinstance(b, ListConfig)
+    t = OmegaConf.create(json.loads(s))
+    assert b == t

hydraflow-0.2.17/tests/test_param.py

@@ -0,0 +1,78 @@
+import mlflow
+import pytest
+
+
+@pytest.fixture
+def param(monkeypatch, tmp_path):
+    def param(value):
+        monkeypatch.chdir(tmp_path)
+        mlflow.set_experiment("test_param")
+
+        with mlflow.start_run():
+            mlflow.log_param("p", value, synchronous=True)
+
+        runs = mlflow.search_runs(output_format="list")
+        p = runs[0].data.params["p"]
+        assert isinstance(p, str)
+        return p
+
+    return param
+
+
+@pytest.mark.parametrize(
+    ("x", "y"),
+    [
+        (1, "1"),
+        (1.0, "1.0"),
+        ("1", "1"),
+        ("a", "a"),
+        ("'a'", "'a'"),
+        ('"a"', '"a"'),
+        (True, "True"),
+        (False, "False"),
+        (None, "None"),
+        ([], "[]"),
+        ((), "()"),
+        ({}, "{}"),
+        ([1, 2, 3], "[1, 2, 3]"),
+        (["1", "2", "3"], "['1', '2', '3']"),
+        (("1", "2", "3"), "('1', '2', '3')"),
+        ({"a": 1, "b": "c"}, "{'a': 1, 'b': 'c'}"),
+    ],
+)
+def test_param(param, x, y):
+    from hydraflow.param import match
+
+    p = param(x)
+    assert p == y
+    assert str(x) == y
+    assert match(p, x)
+
+
+def test_match_list():
+    from hydraflow.param import _match_list
+
+    assert _match_list("1", [1, 2, 3]) is True
+    assert _match_list("[1]", [1, 2, 3]) is None
+    assert _match_list("(1,)", [1, 2, 3]) is None
+    assert _match_list("{1: 3}", [1, 2, 3]) is None
+    assert _match_list("2", [1, 2, 3]) is True
+    assert _match_list("4", [1, 2, 3]) is False
+    assert _match_list("4", [True]) is None
+    assert _match_list("4", [None]) is None
+    assert _match_list("4", ["4"]) is True
+    assert _match_list("4", ["a"]) is False
+
+
+def test_match_tuple():
+    from hydraflow.param import _match_tuple
+
+    assert _match_tuple("1", (1, 3)) is True
+    assert _match_tuple("2", (1, 3)) is True
+    assert _match_tuple("4", (1, 3)) is False
+    assert _match_tuple("[1]", (1, 3)) is None
+    assert _match_tuple("(1,)", (1, 3)) is None
+    assert _match_tuple("{1: 3}", (1, 3)) is None
+    assert _match_tuple("1", (True, False)) is None
+    assert _match_tuple("1", (None, None)) is None
+    assert _match_tuple("1", (1, 3.2)) is None

{hydraflow-0.2.16 → hydraflow-0.2.17}/tests/test_run_collection.py

@@ -10,7 +10,7 @@ from hydraflow.run_collection import RunCollection
 
 
 @pytest.fixture
-def runs(monkeypatch, tmp_path):
+def rc(monkeypatch, tmp_path):
     from hydraflow.mlflow import search_runs
 
     monkeypatch.chdir(tmp_path)
@@ -28,9 +28,19 @@ def runs(monkeypatch, tmp_path):
     return x
 
 
+def test_run_collection_bool_false():
+    assert not RunCollection([])
+    assert bool(RunCollection.from_list([])) is False
+
+
+def test_run_collection_bool_true(rc: RunCollection):
+    assert rc
+    assert bool(rc) is True
+
+
 @pytest.fixture
-def run_list(runs: RunCollection):
-    return runs._runs
+def run_list(rc: RunCollection):
+    return rc._runs
 
 
 def test_from_list(run_list: list[Run]):
@@ -120,123 +130,125 @@ def test_chdir_artifact_list(i: int, run_list: list[Run]):
     assert not Path("abc.txt").exists()
 
 
-def test_runs_repr(runs: RunCollection):
-    assert repr(runs) == "RunCollection(6)"
+def test_runs_repr(rc: RunCollection):
+    assert repr(rc) == "RunCollection(6)"
 
 
-def test_runs_first(runs: RunCollection):
-    run = runs.first()
+def test_runs_first(rc: RunCollection):
+    run = rc.first()
     assert isinstance(run, Run)
     assert run.data.params["p"] == "0"
 
 
-def test_runs_first_empty(runs: RunCollection):
-    runs._runs = []
+def test_runs_first_empty(rc: RunCollection):
+    rc._runs = []
     with pytest.raises(ValueError):
-        runs.first()
+        rc.first()
 
 
-def test_runs_try_first_none(runs: RunCollection):
-    runs._runs = []
-    assert runs.try_first() is None
+def test_runs_try_first_none(rc: RunCollection):
+    rc._runs = []
+    assert rc.try_first() is None
 
 
-def test_runs_last(runs: RunCollection):
-    run = runs.last()
+def test_runs_last(rc: RunCollection):
+    run = rc.last()
     assert isinstance(run, Run)
     assert run.data.params["p"] == "5"
 
 
-def test_runs_last_empty(runs: RunCollection):
-    runs._runs = []
+def test_runs_last_empty(rc: RunCollection):
+    rc._runs = []
     with pytest.raises(ValueError):
-        runs.last()
+        rc.last()
 
 
-def test_runs_try_last_none(runs: RunCollection):
-    runs._runs = []
-    assert runs.try_last() is None
+def test_runs_try_last_none(rc: RunCollection):
+    rc._runs = []
+    assert rc.try_last() is None
 
 
-def test_runs_filter(runs: RunCollection):
-    assert len(runs.filter()) == 6
-    assert len(runs.filter({})) == 6
-    assert len(runs.filter({"p": 1})) == 1
-    assert len(runs.filter({"q": 0})) == 5
-    assert len(runs.filter({"q": -1})) == 0
-    assert len(runs.filter(p=5)) == 1
-    assert len(runs.filter(q=0)) == 5
-    assert len(runs.filter(q=-1)) == 0
-    assert len(runs.filter({"r": 2})) == 2
-    assert len(runs.filter(r=0)) == 2
+def test_runs_filter(rc: RunCollection):
+    assert len(rc.filter()) == 6
+    assert len(rc.filter({})) == 6
+    assert len(rc.filter({"p": 1})) == 1
+    assert len(rc.filter({"q": 0})) == 5
+    assert len(rc.filter({"q": -1})) == 0
+    assert not rc.filter({"q": -1})
+    assert len(rc.filter(p=5)) == 1
+    assert len(rc.filter(q=0)) == 5
+    assert len(rc.filter(q=-1)) == 0
+    assert not rc.filter(q=-1)
+    assert len(rc.filter({"r": 2})) == 2
+    assert len(rc.filter(r=0)) == 2
 
 
-def test_runs_get(runs: RunCollection):
-    run = runs.get({"p": 4})
+def test_runs_get(rc: RunCollection):
+    run = rc.get({"p": 4})
     assert isinstance(run, Run)
-    run = runs.get(p=2)
+    run = rc.get(p=2)
     assert isinstance(run, Run)
 
 
-def test_runs_try_get(runs: RunCollection):
-    run = runs.try_get({"p": 5})
+def test_runs_try_get(rc: RunCollection):
+    run = rc.try_get({"p": 5})
     assert isinstance(run, Run)
-    run = runs.try_get(p=1)
+    run = rc.try_get(p=1)
     assert isinstance(run, Run)
-    run = runs.try_get(p=-1)
+    run = rc.try_get(p=-1)
     assert run is None
 
 
-def test_runs_get_params_names(runs: RunCollection):
-    names = runs.get_param_names()
+def test_runs_get_params_names(rc: RunCollection):
+    names = rc.get_param_names()
     assert len(names) == 3
     assert "p" in names
     assert "q" in names
     assert "r" in names
 
 
-def test_runs_get_params_dict(runs: RunCollection):
-    params = runs.get_param_dict()
+def test_runs_get_params_dict(rc: RunCollection):
+    params = rc.get_param_dict()
     assert params["p"] == ["0", "1", "2", "3", "4", "5"]
     assert params["q"] == ["0", "None"]
     assert params["r"] == ["0", "1", "2"]
 
 
-def test_runs_find(runs: RunCollection):
-    run = runs.find({"r": 0})
+def test_runs_find(rc: RunCollection):
+    run = rc.find({"r": 0})
     assert isinstance(run, Run)
     assert run.data.params["p"] == "0"
-    run = runs.find(r=2)
+    run = rc.find(r=2)
     assert isinstance(run, Run)
     assert run.data.params["p"] == "2"
 
 
-def test_runs_find_none(runs: RunCollection):
+def test_runs_find_none(rc: RunCollection):
     with pytest.raises(ValueError):
-        runs.find({"r": 10})
+        rc.find({"r": 10})
 
 
-def test_runs_try_find_none(runs: RunCollection):
-    run = runs.try_find({"r": 10})
+def test_runs_try_find_none(rc: RunCollection):
+    run = rc.try_find({"r": 10})
     assert run is None
 
 
-def test_runs_find_last(runs: RunCollection):
-    run = runs.find_last({"r": 0})
+def test_runs_find_last(rc: RunCollection):
+    run = rc.find_last({"r": 0})
     assert isinstance(run, Run)
     assert run.data.params["p"] == "3"
-    run = runs.find_last(r=2)
+    run = rc.find_last(r=2)
     assert isinstance(run, Run)
     assert run.data.params["p"] == "5"
 
 
-def test_runs_find_last_none(runs: RunCollection):
+def test_runs_find_last_none(rc: RunCollection):
     with pytest.raises(ValueError):
-        runs.find_last({"p": 10})
+        rc.find_last({"p": 10})
 
 
-def test_runs_try_find_last_none(runs: RunCollection):
-    run = runs.try_find_last({"p": 10})
+def test_runs_try_find_last_none(rc: RunCollection):
+    run = rc.try_find_last({"p": 10})
     assert run is None
 
 
@@ -248,7 +260,7 @@ def runs2(monkeypatch, tmp_path):
             mlflow.log_param("x", x)
 
 
-def test_list_runs(runs, runs2):
+def test_list_runs(rc, runs2):
     from hydraflow.mlflow import list_runs
 
     mlflow.set_experiment("test_run")
@@ -260,7 +272,7 @@ def test_list_runs(runs, runs2):
     assert len(all_runs) == 3
 
 
-def test_list_runs_empty_list(runs, runs2):
+def test_list_runs_empty_list(rc, runs2):
     from hydraflow.mlflow import list_runs
 
     all_runs = list_runs([])
@@ -268,117 +280,118 @@ def test_list_runs_empty_list(runs, runs2):
 
 
 @pytest.mark.parametrize(["name", "n"], [("test_run", 6), ("test_run2", 3)])
-def test_list_runs_list(runs, runs2, name, n):
+def test_list_runs_list(rc, runs2, name, n):
     from hydraflow.mlflow import list_runs
 
     filtered_runs = list_runs(name)
     assert len(filtered_runs) == n
 
 
-def test_list_runs_none(runs, runs2):
+def test_list_runs_none(rc, runs2):
     from hydraflow.mlflow import list_runs
 
     no_runs = list_runs(["non_existent_experiment"])
     assert len(no_runs) == 0
+    assert not no_runs
 
 
-def test_run_collection_map(runs: RunCollection):
-    results = list(runs.map(lambda run: run.info.run_id))
-    assert len(results) == len(runs._runs)
+def test_run_collection_map(rc: RunCollection):
+    results = list(rc.map(lambda run: run.info.run_id))
+    assert len(results) == len(rc._runs)
     assert all(isinstance(run_id, str) for run_id in results)
 
 
-def test_run_collection_map_args(runs: RunCollection):
-    results = list(runs.map(lambda run, x: run.info.run_id + x, "test"))
+def test_run_collection_map_args(rc: RunCollection):
+    results = list(rc.map(lambda run, x: run.info.run_id + x, "test"))
     assert all(x.endswith("test") for x in results)
 
 
-def test_run_collection_map_run_id(runs: RunCollection):
-    results = list(runs.map_run_id(lambda run_id: run_id))
-    assert len(results) == len(runs._runs)
+def test_run_collection_map_run_id(rc: RunCollection):
+    results = list(rc.map_run_id(lambda run_id: run_id))
+    assert len(results) == len(rc._runs)
     assert all(isinstance(run_id, str) for run_id in results)
 
 
-def test_run_collection_map_run_id_kwargs(runs: RunCollection):
-    results = list(runs.map_run_id(lambda run_id, x: x + run_id, x="test"))
+def test_run_collection_map_run_id_kwargs(rc: RunCollection):
+    results = list(rc.map_run_id(lambda run_id, x: x + run_id, x="test"))
     assert all(x.startswith("test") for x in results)
 
 
-def test_run_collection_map_uri(runs: RunCollection):
-    results = list(runs.map_uri(lambda uri: uri))
-    assert len(results) == len(runs._runs)
+def test_run_collection_map_uri(rc: RunCollection):
+    results = list(rc.map_uri(lambda uri: uri))
+    assert len(results) == len(rc._runs)
     assert all(isinstance(uri, str | type(None)) for uri in results)
 
 
-def test_run_collection_map_dir(runs: RunCollection):
-    results = list(runs.map_dir(lambda dir_path, x: dir_path / x, "a.csv"))
-    assert len(results) == len(runs._runs)
+def test_run_collection_map_dir(rc: RunCollection):
+    results = list(rc.map_dir(lambda dir_path, x: dir_path / x, "a.csv"))
+    assert len(results) == len(rc._runs)
     assert all(isinstance(dir_path, Path) for dir_path in results)
     assert all(dir_path.stem == "a" for dir_path in results)
 
 
-def test_run_collection_sort(runs: RunCollection):
-    runs.sort(key=lambda x: x.data.params["p"])
-    assert [run.data.params["p"] for run in runs] == ["0", "1", "2", "3", "4", "5"]
+def test_run_collection_sort(rc: RunCollection):
+    rc.sort(key=lambda x: x.data.params["p"])
+    assert [run.data.params["p"] for run in rc] == ["0", "1", "2", "3", "4", "5"]
 
-    runs.sort(reverse=True)
-    assert [run.data.params["p"] for run in runs] == ["5", "4", "3", "2", "1", "0"]
+    rc.sort(reverse=True)
+    assert [run.data.params["p"] for run in rc] == ["5", "4", "3", "2", "1", "0"]
 
 
-def test_run_collection_iter(runs: RunCollection):
-    assert list(runs) == runs._runs
+def test_run_collection_iter(rc: RunCollection):
+    assert list(rc) == rc._runs
 
 
 @pytest.mark.parametrize("i", range(6))
-def test_run_collection_getitem(runs: RunCollection, i: int):
-    assert runs[i] == runs._runs[i]
+def test_run_collection_getitem(rc: RunCollection, i: int):
+    assert rc[i] == rc._runs[i]
 
 
 @pytest.mark.parametrize("i", range(6))
-def test_run_collection_getitem_slice(runs: RunCollection, i: int):
-    assert runs[i : i + 2]._runs == runs._runs[i : i + 2]
+def test_run_collection_getitem_slice(rc: RunCollection, i: int):
+    assert rc[i : i + 2]._runs == rc._runs[i : i + 2]
 
 
 @pytest.mark.parametrize("i", range(6))
-def test_run_collection_getitem_slice_step(runs: RunCollection, i: int):
-    assert runs[i::2]._runs == runs._runs[i::2]
+def test_run_collection_getitem_slice_step(rc: RunCollection, i: int):
+    assert rc[i::2]._runs == rc._runs[i::2]
 
 
 @pytest.mark.parametrize("i", range(6))
-def test_run_collection_getitem_slice_step_neg(runs: RunCollection, i: int):
-    assert runs[i::-2]._runs == runs._runs[i::-2]
+def test_run_collection_getitem_slice_step_neg(rc: RunCollection, i: int):
+    assert rc[i::-2]._runs == rc._runs[i::-2]
 
 
-def test_run_collection_take(runs: RunCollection):
-    assert runs.take(3)._runs == runs._runs[:3]
-    assert len(runs.take(4)) == 4
-    assert runs.take(10)._runs == runs._runs
+def test_run_collection_take(rc: RunCollection):
+    assert rc.take(3)._runs == rc._runs[:3]
+    assert len(rc.take(4)) == 4
+    assert rc.take(10)._runs == rc._runs
 
 
-def test_run_collection_take_neg(runs: RunCollection):
-    assert runs.take(-3)._runs == runs._runs[-3:]
-    assert len(runs.take(-4)) == 4
-    assert runs.take(-10)._runs == runs._runs
+def test_run_collection_take_neg(rc: RunCollection):
+    assert rc.take(-3)._runs == rc._runs[-3:]
+    assert len(rc.take(-4)) == 4
+    assert rc.take(-10)._runs == rc._runs
 
 
 @pytest.mark.parametrize("i", range(6))
-def test_run_collection_contains(runs: RunCollection, i: int):
-    assert runs[i] in runs
-    assert runs._runs[i] in runs
+def test_run_collection_contains(rc: RunCollection, i: int):
+    assert rc[i] in rc
+    assert rc._runs[i] in rc
 
 
-def test_run_collection_group_by(runs: RunCollection):
-    grouped = runs.group_by(["p"])
+def test_run_collection_group_by(rc: RunCollection):
+    grouped = rc.group_by(["p"])
     assert len(grouped) == 6
     assert all(isinstance(group, RunCollection) for group in grouped.values())
     assert all(len(group) == 1 for group in grouped.values())
-    assert grouped[("0",)][0] == runs[0]
-    assert grouped[("1",)][0] == runs[1]
+    assert grouped[("0",)][0] == rc[0]
+    assert grouped[("1",)][0] == rc[1]
 
-    grouped = runs.group_by("q")
+    grouped = rc.group_by("q")
     assert len(grouped) == 2
 
-    grouped = runs.group_by("r")
+    grouped = rc.group_by("r")
     assert len(grouped) == 3
 
 
@@ -396,24 +409,24 @@ def test_filter_runs_no_match(run_list: list[Run]):
     assert x == []
 
 
-def test_get_run_no_match(runs: RunCollection):
+def test_get_run_no_match(rc: RunCollection):
     with pytest.raises(ValueError):
-        runs.get({"p": 10})
+        rc.get({"p": 10})
 
 
-def test_get_run_multiple_params(runs: RunCollection):
-    run = runs.get({"p": 4, "q": 0})
+def test_get_run_multiple_params(rc: RunCollection):
+    run = rc.get({"p": 4, "q": 0})
     assert isinstance(run, Run)
     assert run.data.params["p"] == "4"
     assert run.data.params["q"] == "0"
 
 
-def test_try_get_run_no_match(runs: RunCollection):
-    assert runs.try_get({"p": 10}) is None
+def test_try_get_run_no_match(rc: RunCollection):
+    assert rc.try_get({"p": 10}) is None
 
 
-def test_try_get_run_multiple_params(runs: RunCollection):
-    run = runs.try_get({"p": 4, "q": 0})
+def test_try_get_run_multiple_params(rc: RunCollection):
+    run = rc.try_get({"p": 4, "q": 0})
     assert isinstance(run, Run)
     assert run.data.params["p"] == "4"
     assert run.data.params["q"] == "0"