Merge pull request #2 from mgorny/index-json

[WheelVariants] Implement getting sorted variants aided by `variants.json`

Author: DEKHTIARJonathan

.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "pypy-3.10", "pypy-3.11"]
+      fail-fast: false
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install the package and test dependencies
+        run: |
+          uv venv
+          uv pip install -e '.[test]'
+      - name: Run tests
+        run: uv run --no-project pytest

pyproject.toml

@@ -40,6 +40,7 @@ dev = [
 ]
 test = [
     "jsondiff>=2.2,<2.3",
+    "hypothesis>=6.0.0,<7",
     "pytest>=8.0.0,<9.0.0",
     "pytest-cov>=5.0.0,<6.0.0",
     "pytest-dotenv>=0.5.0,<1.0.0",

tests/test_combinations.py

@@ -1,14 +1,23 @@
 import json
 from pathlib import Path
+import random
+import string
 
+from hypothesis import assume
+from hypothesis import example
+from hypothesis import given
+from hypothesis import strategies as st
 import jsondiff
+import pytest
+from variantlib.combination import filtered_sorted_variants
 from variantlib.combination import get_combinations
 from variantlib.config import KeyConfig
 from variantlib.config import ProviderConfig
+from variantlib.meta import VariantDescription
 
 
-def test_get_combinations():
-    """Test `get_combinations` yields the expected result in the right order."""
+@pytest.fixture(scope="session")
+def configs():
     config_custom_hw = ProviderConfig(
         provider="custom_hw",
         configs=[
@@ -24,8 +33,11 @@ def test_get_combinations():
         ],
     )
 
-    configs = [config_custom_hw, config_networking]
+    return [config_custom_hw, config_networking]
+
 
+def test_get_combinations(configs):
+    """Test `get_combinations` yields the expected result in the right order."""
     result = [vdesc.serialize() for vdesc in get_combinations(configs)]
 
     json_file = Path("tests/artifacts/expected.json")
@@ -37,3 +49,81 @@ def test_get_combinations():
 
     differences = jsondiff.diff(result, expected)
     assert not differences, f"Serialization altered JSON: {differences}"
+
+
+def desc_to_json(desc_list: list[VariantDescription]) -> dict:
+    shuffled_desc_list = list(desc_list)
+    random.shuffle(shuffled_desc_list)
+    for desc in shuffled_desc_list:
+        variant_dict = {}
+        for variant_meta in desc:
+            provider_dict = variant_dict.setdefault(variant_meta.provider, {})
+            provider_dict[variant_meta.key] = variant_meta.value
+        yield (desc.hexdigest, variant_dict)
+
+
+def test_filtered_sorted_variants_roundtrip(configs):
+    """Test that we can round-trip all combinations via variants.json and get the same result."""
+    combinations = list(get_combinations(configs))
+    variants_from_json = {k: v for k, v in desc_to_json(combinations)}
+    assert filtered_sorted_variants(variants_from_json, configs) == combinations
+
+
+@example(
+    [
+        ProviderConfig(
+            provider="A",
+            configs=[
+                KeyConfig(key="A1", values=["x"]),
+                KeyConfig(key="A2", values=["x"]),
+            ],
+        ),
+        ProviderConfig(provider="B", configs=[KeyConfig(key="B1", values=["x"])]),
+        ProviderConfig(provider="C", configs=[KeyConfig(key="C1", values=["x"])]),
+    ]
+)
+@given(
+    st.lists(
+        min_size=1,
+        max_size=3,
+        unique_by=lambda provider_cfg: provider_cfg.provider,
+        elements=st.builds(
+            ProviderConfig,
+            provider=st.text(
+                string.ascii_letters + string.digits + "_", min_size=1, max_size=64
+            ),
+            configs=st.lists(
+                min_size=1,
+                max_size=2,
+                unique_by=lambda key_cfg: key_cfg.key,
+                elements=st.builds(
+                    KeyConfig,
+                    key=st.text(
+                        alphabet=string.ascii_letters + string.digits + "_",
+                        min_size=1,
+                        max_size=64,
+                    ),
+                    values=st.lists(
+                        min_size=1,
+                        max_size=3,
+                        unique=True,
+                        elements=st.text(
+                            alphabet=string.ascii_letters + string.digits + "_.",
+                            min_size=1,
+                            max_size=64,
+                        ),
+                    ),
+                ),
+            ),
+        ),
+    )
+)
+def test_filtered_sorted_variants_roundtrip_fuzz(configs):
+    def filter_long_combinations():
+        for i, x in enumerate(get_combinations(configs)):
+            assume(i < 65536)
+            yield x
+
+    combinations = list(filter_long_combinations())
+    variants_from_json = {k: v for k, v in desc_to_json(combinations)}
+    assert filtered_sorted_variants(variants_from_json, configs) == combinations

variantlib/combination.py

@@ -1,10 +1,13 @@
 import itertools
+import logging
 from collections.abc import Generator
 
 from variantlib.config import ProviderConfig
 from variantlib.meta import VariantDescription
 from variantlib.meta import VariantMeta
 
+logger = logging.getLogger(__name__)
+
 
 def get_combinations(data: list[ProviderConfig]) -> Generator[VariantDescription]:
     """Generate all possible combinations of `VariantMeta` given a list of
@@ -30,6 +33,79 @@ def get_combinations(data: list[ProviderConfig]) -> Generator[VariantDescription
                 yield VariantDescription(data=vmetas)
 
 
+def unpack_variants_from_json(variants_from_json: dict
+                              ) -> Generator[VariantDescription]:
+    def variant_to_metas(providers: dict) -> VariantMeta:
+        for provider, keys in providers.items():
+            for key, value in keys.items():
+                yield VariantMeta(provider=provider,
+                                  key=key,
+                                  value=value)
+
+    for variant_hash, providers in variants_from_json.items():
+        desc = VariantDescription(variant_to_metas(providers))
+        assert variant_hash == desc.hexdigest
+        yield desc
+
+
+def filtered_sorted_variants(variants_from_json: dict,
+                             data: list[ProviderConfig]
+                             ) -> Generator[VariantDescription]:
+    providers = {}
+    for provider_idx, provider_cnf in enumerate(data):
+        keys = {}
+        for key_idx, key_cnf in enumerate(provider_cnf.configs):
+            keys[key_cnf.key] = key_idx, key_cnf.values
+        providers[provider_cnf.provider] = provider_idx, keys
+
+    missing_providers = set()
+    missing_keys = {}
+
+    def variant_filter(desc: VariantDescription):
+        # Filter out the variant, unless all of its metas are supported.
+        for meta in desc:
+            if (provider_data := providers.get(meta.provider)) is None:
+                missing_providers.add(meta.provider)
+                return False
+            _, keys = provider_data
+            if (key_data := keys.get(meta.key)) is None:
+                missing_keys.setdefault(meta.provider, set()).add(meta.key)
+                return False
+            _, values = key_data
+            if meta.value not in values:
+                return False
+        return True
+
+    def meta_key(meta: VariantMeta) -> tuple[int, int, int]:
+        # The sort key is a tuple of (provider, key, value) indices, so that
+        # the metas with more preferred (provider, key, value) sort first.
+        provider_idx, keys = providers.get(meta.provider)
+        key_idx, values = keys.get(meta.key)
+        value_idx = values.index(meta.value)
+        return provider_idx, key_idx, value_idx
+
+    def variant_sort_key_gen(desc: VariantDescription) -> Generator[tuple]:
+        # Variants with more matched values should go first.
+        yield -len(desc.data)
+        # Sort meta sort keys by their sort keys, so that metas containing
+        # more preferred sort key sort first.
+        meta_keys = sorted(meta_key(x) for x in desc.data)
+        # Always prefer all values from the "stronger" keys over "weaker".
+        yield from (x[0:2] for x in meta_keys)
+        yield from (x[2] for x in meta_keys)
+
+    res = sorted(filter(variant_filter,
+                        unpack_variants_from_json(variants_from_json)),
+                 key=lambda x: tuple(variant_sort_key_gen(x)))
+    if missing_providers:
+        logger.warn("No plugins provide the following variant providers: "
+                    f"{' '.join(missing_providers)}; some variants will be ignored")
+    for provider, provider_missing_keys in missing_keys.items():
+        logger.warn(f"The {provider} provider does not provide the following expected keys: "
+                    f"{' '.join(provider_missing_keys)}; some variants will be ignored")
+    return res
+
+
 if __name__ == "__main__":  # pragma: no cover
     import json
     from pathlib import Path

variantlib/platform.py

@@ -6,6 +6,7 @@
 from importlib.metadata import entry_points
 from typing import TYPE_CHECKING
 
+from variantlib.combination import filtered_sorted_variants
 from variantlib.combination import get_combinations
 from variantlib.config import ProviderConfig
 
@@ -82,6 +83,7 @@ def _query_variant_plugins() -> dict[str, ProviderConfig]:
 
 def get_variant_hashes_by_priority(
     provider_priority_dict: dict[str:int] | None = None,
+    variants_json: dict | None = None,
 ) -> Generator[VariantDescription]:
     plugins = entry_points().select(group="variantlib.plugins")
 
@@ -134,7 +136,11 @@ def get_variant_hashes_by_priority(
     sorted_provider_cfgs = [provider_cfgs[plugin.name] for plugin in plugins]
 
     if sorted_provider_cfgs:
-        for variant_desc in get_combinations(sorted_provider_cfgs):
-            yield variant_desc.hexdigest
+        if (variants_json or {}).get("variants") is not None:
+            for variant_desc in filtered_sorted_variants(variants_json["variants"], sorted_provider_cfgs):
+                yield variant_desc.hexdigest
+        else:
+            for variant_desc in get_combinations(sorted_provider_cfgs):
+                yield variant_desc.hexdigest
     else:
         yield from []