encode 1.0.0

A simple framework for encoding binary data.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

from __future__ import annotations

import itertools
import tomllib
import json
import typing
import os
import logging
import sys


def powerset[T](features: typing.Sequence[T]) -> typing.Iterator[typing.Tuple[T, ...]]:
    """Return an iterator over the powerset of the given sequence.

    The powerset is the set of all possible subsets of the given sequence.

    Args:

        features: The sequence to generate the powerset for.

    Returns:
        An iterator over the powerset of the given sequence
    """
    return itertools.chain.from_iterable(
        itertools.combinations(features, r) for r in range(len(features) + 1)
    )


def resolve_dependencies[T: typing.Hashable](
    features: typing.Iterable[T], tree: typing.Mapping[T, typing.Sequence[T]]
) -> typing.Generator[T]:
    """Resolve the dependencies of the given features in the given tree.

    The tree is a mapping from features to their dependencies.

    This function is a generator that yields the features in the order they should be

    Args:
        features: The features to resolve the dependencies for.
        tree: The tree to resolve the dependencies in.

    Returns:
        A generator that yields the features in the order they should be."""
    for feature in features:
        dependencies = tree.get(feature)
        if dependencies is None:
            continue
        elif len(dependencies):
            yield from resolve_dependencies(dependencies, tree)
        yield feature


def all_unique[T: typing.Hashable](iterable: typing.Iterable[T]) -> bool:
    """Return True if all elements in the given iterable are unique, False otherwise.

    Args:
        iterable: The iterable to check for uniqueness.

    Returns:
        True if all elements in the given iterable are unique, False otherwise.
    """
    seen = set()
    for e in iterable:
        if e in seen:
            return False
        seen.add(e)
    return True


def main(manifest_path: str, output_file: typing.Optional[typing.IO] = None):
    """Generate a matrix definition for CI based on the given Cargo.toml file.

    The matrix definition in JSON is written to the given output file, or to stdout if no output file is given.

    Args:
        manifest_path: The path to the Cargo.toml file to generate the matrix for.
        output_file: The file to write the matrix definition to. If not given, stdout is used.
    """
    with open(manifest_path, "rb") as f:
        data = tomllib.load(f)

    msrv = data["package"].get("rust-version", "")
    logging.debug("Minimum supported Rust version: %s", msrv)

    # Default isn't really a feature, but rather a predefined set of features
    if "features" in data:
        logging.debug("Features found")
        try:
            del data["features"]["default"]
        except KeyError:
            logging.debug("No default feature set found")
        features = sorted(data["features"].keys())
        logging.debug("Features: %s", features)

        seen = set()
        unique_disjoint_combinations = []
        for combination in powerset(features):
            resolved = tuple(
                sorted(resolve_dependencies(combination, data["features"]))
            )
            if resolved not in seen and all_unique(resolved):
                seen.add(resolved)
                unique_disjoint_combinations.append(",".join(resolved))
        logging.debug("Unique disjoint combinations: %s", unique_disjoint_combinations)
    else:
        logging.debug("No features found")
        features = []
        unique_disjoint_combinations = []
    json.dump(
        {
            "powerset": unique_disjoint_combinations,
            "features": features,
            "msrv": msrv,
        },
        output_file or sys.stdout,
    )


if __name__ == "__main__":
    log_level = os.environ.get("LOG_LEVEL", "INFO").upper()
    logging.basicConfig(level=log_level)
    main(os.environ.get("CARGO_MANIFEST_PATH", "Cargo.toml"))