toml-combine 0.1.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

toml_combine/__init__.py

@@ -1,55 +1,5 @@
 from __future__ import annotations
 
-import pathlib
-from typing import Any, cast, overload
+from .lib import combine
 
-from . import combiner, toml
-
-
-# Provide already parsed config
-@overload
-def combine(
-    *, config: dict[str, Any], **filters: str | list[str]
-) -> dict[str, Any]: ...
-# Provide toml config content
-@overload
-def combine(*, config: str, **filters: str | list[str]) -> dict[str, Any]: ...
-# Provide toml config file path
-@overload
-def combine(
-    *, config_file: str | pathlib.Path, **filters: str | list[str]
-) -> dict[str, Any]: ...
-
-
-def combine(*, config=None, config_file=None, **filters):
-    """
-    Generate outputs of configurations based on the provided TOML
-    configuration.
-
-    Args:
-        config: The TOML configuration as a string or an already parsed dictionary.
-        OR:
-        config_file: The path to the TOML configuration file.
-        **filters: Filters to apply to the combined configuration
-            (dimension="value" or dimension=["list", "of", "values"]).
-
-    Returns:
-        dict[str, Any]: The combined configuration ({"output_id": {...}}).
-    """
-    if (config is None) is (config_file is None):
-        raise ValueError("Either 'config' or 'config_file' must be provided.")
-
-    if isinstance(config, dict):
-        dict_config = config
-    else:
-        if config_file:
-            config_string = pathlib.Path(config_file).read_text()
-        else:
-            config = cast(str, config)
-            config_string = config
-
-        dict_config = toml.loads(config_string)
-
-    config_obj = combiner.build_config(dict_config)
-
-    return combiner.generate_outputs(config_obj, **filters)
+__all__ = ["combine"]

toml_combine/cli.py

@@ -6,7 +6,7 @@ import pathlib
 import sys
 from collections.abc import Mapping
 
-from . import combiner, exceptions, toml
+from . import combiner, exceptions, lib, toml
 
 
 def get_argument_parser(
@@ -17,20 +17,30 @@ def get_argument_parser(
         description="Create combined configurations from a TOML file",
         add_help=(dimensions is not None),
     )
+    arg_parser.add_argument(
+        "--format",
+        choices=["json", "toml"],
+        default="toml",
+        help="Output format",
+    )
     arg_parser.add_argument(
         "config",
         type=pathlib.Path,
         help="Path to the TOML configuration file",
     )
-    if dimensions:
+    if dimensions is None:
+        arg_parser.epilog = (
+            "Additional arguments will be provided with a valid config file."
+        )
+    else:
         group = arg_parser.add_argument_group(
             "dimensions",
-            "Filter the generated outputs by dimensions",
+            "Output the file with these dimensions",
         )
 
         for name, values in dimensions.items():
             group.add_argument(
-                f"--{name}", choices=values, help=f"Limit to given {name}"
+                f"--{name}", choices=values, help=f"Provide value for {name}"
             )
 
     return arg_parser
@@ -41,7 +51,12 @@ def cli(argv) -> int:
 
     # Parse the config file argument to get the dimensions
     arg_parser = get_argument_parser(dimensions=None)
-    args, _ = arg_parser.parse_known_args(argv)
+    try:
+        args, _ = arg_parser.parse_known_args(argv)
+    except SystemExit:
+        # If the user didn't provide a config file, print the help message
+        arg_parser.print_help()
+        return 1
 
     try:
         dict_config = toml.loads(args.config.read_text())
@@ -62,22 +77,25 @@ def cli(argv) -> int:
     arg_parser = get_argument_parser(dimensions=config.dimensions)
     args = arg_parser.parse_args(argv)
 
-    dimensions_filter = {
+    mapping = {
         key: value
         for key, value in vars(args).items()
         if key in config.dimensions and value
     }
-    # Generate final configurations for each output
+    # Generate final configurations for requested mapping
     try:
-        result = combiner.generate_outputs(config=config, **dimensions_filter)
+        result = lib.combine(config=dict_config, **mapping)
     except exceptions.TomlCombineError as exc:
         print(exc, file=sys.stderr)
         return 1
 
-    if not result:
-        print("No outputs found", file=sys.stderr)
+    if args.format == "toml":
+        # Convert the result to TOML format
 
-    print(json.dumps(result, indent=2))
+        print(toml.dumps(result))
+    else:
+        # Convert the result to JSON format
+        print(json.dumps(result, indent=2))
 
     return 0
 

toml_combine/combiner.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import copy
 import dataclasses
-import itertools
 from collections.abc import Mapping, Sequence
 from functools import partial
 from typing import Any
@@ -10,21 +9,9 @@ from typing import Any
 from . import exceptions
 
 
-@dataclasses.dataclass()
-class Output:
-    dimensions: Mapping[str, str]
-
-    @property
-    def id(self) -> str:
-        return f"{'-'.join(self.dimensions.values())}"
-
-    def __str__(self) -> str:
-        return f"Output(id={self.id})"
-
-
 @dataclasses.dataclass()
 class Override:
-    when: Mapping[str, str | list[str]]
+    when: Mapping[str, list[str]]
     config: Mapping[str, Any]
 
     def __str__(self) -> str:
@@ -34,52 +21,40 @@ class Override:
 @dataclasses.dataclass()
 class Config:
     dimensions: Mapping[str, list[str]]
-    outputs: list[Output]
     default: Mapping[str, Any]
     overrides: Sequence[Override]
 
 
-def wrap_in_list(value: str | list[str]) -> list[str]:
-    """
-    Wrap a string in a list if it's not already a list.
-    """
-    if isinstance(value, str):
-        return [value]
-    return value
-
-
 def clean_dimensions_dict(
-    to_sort: Mapping[str, str | list[str]], clean: dict[str, list[str]], type: str
-) -> dict[str, str]:
+    to_sort: Mapping[str, list[str]], clean: dict[str, list[str]], type: str
+) -> dict[str, list[str]]:
     """
     Recreate a dictionary of dimension values with the same order as the
     dimensions list.
     """
     result = {}
-    remaining = dict(to_sort)
+    if invalid_dimensions := set(to_sort) - set(clean):
+        raise exceptions.DimensionNotFound(
+            type=type,
+            id=to_sort,
+            dimension=", ".join(invalid_dimensions),
+        )
 
+    # Fix the order of the dimensions
     for dimension, valid_values in clean.items():
-        valid_values = set(valid_values)
         if dimension not in to_sort:
             continue
 
-        original_value = remaining.pop(dimension)
-        values = set(wrap_in_list(original_value))
-        if invalid_values := values - valid_values:
+        original_values = to_sort[dimension]
+        if invalid_values := set(original_values) - set(valid_values):
             raise exceptions.DimensionValueNotFound(
                 type=type,
                 id=to_sort,
                 dimension=dimension,
                 value=", ".join(invalid_values),
             )
-        result[dimension] = original_value
-
-    if remaining:
-        raise exceptions.DimensionNotFound(
-            type=type,
-            id=to_sort,
-            dimension=", ".join(to_sort),
-        )
+        # Fix the order of the values
+        result[dimension] = [e for e in valid_values if e in original_values]
 
     return result
 
@@ -134,6 +109,7 @@ def merge_configs(a: Any, b: Any, /) -> Any:
 
 
 def build_config(config: dict[str, Any]) -> Config:
+    config = copy.deepcopy(config)
     # Parse dimensions
     dimensions = config.pop("dimensions")
 
@@ -147,8 +123,13 @@ def build_config(config: dict[str, Any]) -> Config:
             when = override.pop("when")
         except KeyError:
             raise exceptions.MissingOverrideCondition(id=override)
+        when = clean_dimensions_dict(
+            to_sort={k: v if isinstance(v, list) else [v] for k, v in when.items()},
+            clean=dimensions,
+            type="override",
+        )
 
-        conditions = tuple((k, tuple(wrap_in_list(v))) for k, v in when.items())
+        conditions = tuple((k, tuple(v)) for k, v in when.items())
         if conditions in seen_conditions:
             raise exceptions.DuplicateError(type="override", id=when)
 
@@ -168,82 +149,38 @@ def build_config(config: dict[str, Any]) -> Config:
         key=partial(override_sort_key, dimensions=dimensions),
     )
 
-    outputs = []
-    seen_conditions = set()
-
-    for output in config.pop("output", []):
-        for key in output:
-            output[key] = wrap_in_list(output[key])
-
-        for cartesian_product in itertools.product(*output.values()):
-            # Create a dictionary with the same keys as when
-            single_output = dict(zip(output.keys(), cartesian_product))
-
-            conditions = tuple(single_output.items())
-            if conditions in seen_conditions:
-                raise exceptions.DuplicateError(type="output", id=output.id)
-            seen_conditions.add(conditions)
-
-            outputs.append(
-                Output(
-                    dimensions=clean_dimensions_dict(
-                        single_output, dimensions, type="output"
-                    ),
-                )
-            )
-
     return Config(
         dimensions=dimensions,
-        outputs=outputs,
         default=default,
         overrides=overrides,
     )
 
 
-def generate_output(
-    default: Mapping[str, Any], overrides: Sequence[Override], output: Output
+def mapping_matches_override(mapping: dict[str, str], override: Override) -> bool:
+    """
+    Check if the values in the override match the given dimensions.
+    """
+    for dim, values in override.when.items():
+        if dim not in mapping:
+            return False
+
+        if mapping[dim] not in values:
+            return False
+
+    return True
+
+
+def generate_for_mapping(
+    default: Mapping[str, Any],
+    overrides: Sequence[Override],
+    mapping: dict[str, str],
 ) -> dict[str, Any]:
     result = copy.deepcopy(default)
     # Apply each matching override
     for override in overrides:
         # Check if all dimension values in the override match
-        if all(
-            override.when.get(dim) == output.dimensions.get(dim)
-            for dim in override.when.keys()
-        ):
-            result = merge_configs(result, override.config)
-
-    return {"dimensions": output.dimensions, **result}
 
+        if mapping_matches_override(mapping=mapping, override=override):
+            result = merge_configs(result, override.config)
 
-def generate_outputs(config: Config, **filter: str | list[str]) -> dict[str, Any]:
-    result = {}
-    filter_with_lists: dict[str, list[str]] = {}
-
-    for key, value in list(filter.items()):
-        if key not in config.dimensions:
-            raise exceptions.DimensionNotFound(type="arguments", id="", dimension=key)
-
-        value = wrap_in_list(value)
-
-        if set(value) - set(config.dimensions[key]):
-            raise exceptions.DimensionValueNotFound(
-                type="arguments",
-                id="",
-                dimension=key,
-                value=", ".join(set(value) - set(config.dimensions[key])),
-            )
-        filter_with_lists[key] = value
-
-    for output in config.outputs:
-        if all(
-            output.dimensions.get(key) in value
-            for key, value in filter_with_lists.items()
-        ):
-            result[output.id] = generate_output(
-                default=config.default,
-                overrides=config.overrides,
-                output=output,
-            )
-
-    return result
+    return {"dimensions": mapping, **result}

toml_combine/exceptions.py

@@ -15,6 +15,10 @@ class TomlDecodeError(TomlCombineError):
     """Error while decoding configuration file."""
 
 
+class TomlEncodeError(TomlCombineError):
+    """Error while encoding configuration file."""
+
+
 class DuplicateError(TomlCombineError):
     """In {type} {id}: Cannot have multiple {type}s with the same dimensions."""
 

toml_combine/lib.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import pathlib
+from typing import Any, cast, overload
+
+from . import combiner, toml
+
+
+# Provide already parsed config
+@overload
+def combine(
+    *, config: dict[str, Any], **mapping: str | list[str]
+) -> dict[str, Any]: ...
+# Provide toml config content
+@overload
+def combine(*, config: str, **mapping: str | list[str]) -> dict[str, Any]: ...
+# Provide toml config file path
+@overload
+def combine(
+    *, config_file: str | pathlib.Path, **mapping: str | list[str]
+) -> dict[str, Any]: ...
+
+
+def combine(*, config=None, config_file=None, **mapping):
+    """
+    Generate outputs of configurations based on the provided TOML
+    configuration and a mapping of dimensions values.
+
+    Args:
+        config: The TOML configuration as a string or an already parsed dictionary.
+        OR:
+        config_file: The path to the TOML configuration file.
+        **mapping: Define the values you want for dimensions {"<dimension>": "<value>", ...}.
+
+    Returns:
+        dict[str, Any]: The combined configuration.
+    """
+    if (config is None) is (config_file is None):
+        raise ValueError("Either 'config' or 'config_file' must be provided.")
+
+    if isinstance(config, dict):
+        dict_config = config
+    else:
+        if config_file:
+            config_string = pathlib.Path(config_file).read_text()
+        else:
+            config = cast(str, config)
+            config_string = config
+
+        dict_config = toml.loads(config_string)
+
+    config_obj = combiner.build_config(dict_config)
+
+    return combiner.generate_for_mapping(
+        default=config_obj.default,
+        overrides=config_obj.overrides,
+        mapping=mapping,
+    )

toml_combine/toml.py

@@ -1,17 +1,27 @@
 from __future__ import annotations
 
+import json
 from typing import Any
 
-import tomli
+import tomlkit
+import tomlkit.exceptions
 
 from . import exceptions
 
 
 def loads(raw_config: str) -> dict[str, Any]:
     try:
-        return tomli.loads(raw_config)
-    except tomli.TOMLDecodeError as e:
-        raise exceptions.TomlDecodeError(
-            message="Syntax error in TOML configuration file",
-            context=str(e),
-        ) from e
+        return tomlkit.loads(raw_config)
+    except tomlkit.exceptions.ParseError as e:
+        raise exceptions.TomlDecodeError from e
+
+
+def dumps(config: dict) -> str:
+    # https://github.com/python-poetry/tomlkit/issues/411
+    # While we're waiting for a fix, the workaround is to give up "style-preserving"
+    # features. The easiest way to turn tomlkit objects into plain dicts and strings
+    # is through a json round-trip.
+    try:
+        return tomlkit.dumps(json.loads(json.dumps(config)))
+    except tomlkit.exceptions.TOMLKitError as e:
+        raise exceptions.TomlEncodeError from e

{toml_combine-0.1.7.dist-info → toml_combine-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: toml-combine
-Version: 0.1.7
+Version: 0.2.0
 Summary: A tool for combining complex configurations in TOML format.
 Author-email: Joachim Jablon <ewjoachim@gmail.com>
 License-Expression: MIT
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
-Requires-Dist: tomli>=2.2.1
+Requires-Dist: tomlkit
 Description-Content-Type: text/markdown
 
 # Toml-combine
@@ -35,12 +35,6 @@ The configuration file is usually a TOML file. Here's a small example:
 [dimensions]
 environment = ["production", "staging"]
 
-[[output]]
-environment = "production"
-
-[[output]]
-environment = "staging"
-
 [default]
 name = "my-service"
 registry = "gcr.io/my-project/"
@@ -61,16 +55,6 @@ Dimensions lets you describe the main "thing" that makes the outputs differents,
 service might be `frontend` or `backend`. Some combinations of dimensions might not
 exists, for example, maybe there's no `staging` in `eu`.
 
-### Outputs
-
-Create a `output` for each configuration you want to generate, and specify the
-dimensions relevant for this output. It's ok to omit some dimensions when they're not
-used for a given output.
-
-> [!Note]
-> Defining a list as the value of one or more dimensions in a output
-> is a shorthand for defining all combinations of dimensions
-
 ### Default
 
 The common configuration to start from, before we start overlaying overrides on top.
@@ -93,7 +77,7 @@ specific to more specific, each one overriding the values of the previous ones:
 
 ### The configuration itself
 
-Under the layer of `dimensions/output/default/override` system, what you actually define
+Under the layer of `dimensions/default/override/mapping` system, what you actually define
 in the configuration is completely up to you. That said, only nested
 "dictionnaries"/"objects"/"tables"/"mapping" (those are all the same things in
 Python/JS/Toml lingo) will be merged between the default and the overrides, while
@@ -110,9 +94,6 @@ Let's look at an example:
 [dimensions]
 environment = ["production", "staging"]
 
-[[output]]
-environment = ["production", "staging"]
-
 [default]
 fruits = [{name="apple", color="red"}]
 
@@ -121,17 +102,16 @@ when.environment = "staging"
 fruits = [{name="orange", color="orange"}]
 ```
 
-In this example, on staging, `fruits` is `[{name="orange", color="orange"}]` and not `[{name="apple", color="red"}, {name="orange", color="orange"}]`.
-The only way to get multiple values to be merged is if they are tables: you'll need
+In this example, with `{"environment": "staging"}`, `fruits` is
+`[{name="orange", color="orange"}]` and not
+`[{name="apple", color="red"}, {name="orange", color="orange"}]`.
+The only way to get multiple values to be merged is if they are dicts: you'll need
 to chose an element to become the key:
 
 ```toml
 [dimensions]
 environment = ["production", "staging"]
 
-[[output]]
-environment = ["production", "staging"]
-
 [default]
 fruits.apple.color = "red"
 
@@ -146,22 +126,54 @@ This example is simple because `name` is a natural choice for the key. In some c
 the choice is less natural, but you can always decide to name the elements of your
 list and use that name as a key. Also, yes, you'll loose ordering.
 
-### A bigger example
+### Mapping
+
+When you call the tool either with the CLI or the lib (see both below), you will have to
+provide a mapping of the desired dimentions. These values will be compared to overrides
+to apply overrides when relevant. It's ok to omit some dimensions, corresponding
+overrides won't be selected. The mapping you pass is also returned in the output as a
+dict under the `dimensions` key.
+
+By default, the output is `toml` though you can switch to `json` with `--format=json`
+
+## CLI
+
+Example with the config from the previous section:
+
+```console
+$ toml-combine path/to/config.toml --environment=staging
+[dimensions]
+environment = "staging"
+
+[fruits]
+apple.color = "red"
+orange.color = "orange"
+```
+
+## Lib
+
+```python
+import toml_combine
+
+
+result = toml_combine.combine(config_file=config_file, environment="staging")
+
+print(result)
+{
+  "dimensions": {"environment": "staging"},
+  "fruits": {"apple": {"color": "red"}, "orange": {"color": "orange"}}
+}
+```
+
+You can pass either `config` (TOML string or dict) or `config_file` (`pathlib.Path` or string path) to `combine()`. All other `kwargs` specify the mapping you want.
+
+## A bigger example
 
 ```toml
 [dimensions]
 environment = ["production", "staging", "dev"]
 service = ["frontend", "backend"]
 
-# All 4 combinations of those values will exist
-[[output]]
-environment = ["production", "staging"]
-service = ["frontend", "backend"]
-
-# On dev, the "service" is not defined. That's ok.
-[[output]]
-environment = "dev"
-
 [default]
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
@@ -181,39 +193,86 @@ container.port = 8080
 name = "service-dev"
 when.environment = "dev"
 container.env.DEBUG = true
+
+[[override]]
+when.environment = ["staging", "dev"]
+when.service = "backend"
+container.env.ENABLE_EXPENSIVE_MONITORING = false
 ```
 
-### CLI
+This produces the following configs:
 
 ```console
-$ toml-combine {path/to/config.toml}
+$ uv run toml-combine example.toml --environment=production --service=frontend
+registry = "gcr.io/my-project/"
+service_account = "my-service-account"
+name = "service-frontend"
+[dimensions]
+environment = "production"
+service = "frontend"
+
+[container]
+image_name = "my-image-frontend"
 ```
 
-Generates all the outputs described by the given TOML config.
+```console
+$ toml-combine example.toml --environment=production --service=backend
+registry = "gcr.io/my-project/"
+service_account = "my-service-account"
+name = "service-backend"
+[dimensions]
+environment = "production"
+service = "backend"
 
-Note that you can restrict generation to some dimension values by passing
-`--{dimension}={value}`
+[container]
+image_name = "my-image-backend"
+port = 8080
+```
 
-## Lib
+```console
+$ toml-combine example.toml --environment=staging --service=frontend
+registry = "gcr.io/my-project/"
+service_account = "my-service-account"
+name = "service-frontend"
+[dimensions]
+environment = "staging"
+service = "frontend"
 
-```python
-import toml_combine
+[container]
+image_name = "my-image-frontend"
+```
 
+```console
+$ toml-combine example.toml --environment=staging --service=backend
+registry = "gcr.io/my-project/"
+service_account = "my-service-account"
+name = "service-backend"
+[dimensions]
+environment = "staging"
+service = "backend"
 
-result = toml_combine.combine(
-        config_file=config_file,
-        environment=["production", "staging"],
-        type="job",
-        job=["manage", "special-command"],
-    )
+[container]
+image_name = "my-image-backend"
+port = 8080
 
-print(result)
-{
-  "production-job-manage": {...},
-  "production-job-special-command": {...},
-  "staging-job-manage": {...},
-  "staging-job-special-command": {...},
-}
+[container.env]
+ENABLE_EXPENSIVE_MONITORING = false
 ```
 
-You can pass either `config` (TOML string or dict) or `config_file` (`pathlib.Path` or string path) to `combine()`. Additional `kwargs` restrict the output.
+```console
+$ toml-combine example.toml --environment=dev --service=backend
+registry = "gcr.io/my-project/"
+service_account = "my-service-account"
+name = "service-backend"
+[dimensions]
+environment = "dev"
+service = "backend"
+
+[container]
+image_name = "my-image-backend"
+port = 8080
+[container.env]
+DEBUG = true
+ENABLE_EXPENSIVE_MONITORING = false
+
+```

toml_combine-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+toml_combine/__init__.py,sha256=TDkOwwEM-nS6hOh79u9Qae6g2Q6VfANpPpnKGfSgu80,84
+toml_combine/__main__.py,sha256=hmF8N8xX6UEApzbKTVZ-4E1HU5-rjgUkdXNLO-mF6vo,100
+toml_combine/cli.py,sha256=hG03eDKz7xU-ydJIa1kDuu6WlFzNS3GTMJ6zals9M9c,2843
+toml_combine/combiner.py,sha256=LLjBFNKz4sjwiyOM5hq9JaqvyNuogdzdyWJbGS5hpXs,5500
+toml_combine/exceptions.py,sha256=tAFTDRSg6d10bBruBhsasZXrNNgLTmr_nKfvIsRR_yU,991
+toml_combine/lib.py,sha256=Iw7F8SCyQMlhaqSD2vtnmM6jbnrgzCZeX0d-LTM3VVg,1683
+toml_combine/toml.py,sha256=hqWEdBQiM960uga_9A6gXRhWhT2gVZT8IiLRc3jkyT8,797
+toml_combine-0.2.0.dist-info/METADATA,sha256=tuHxaP5V3DhE0unQt-XOnsL_TmCrNGP3mpxrSLuk30E,7777
+toml_combine-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+toml_combine-0.2.0.dist-info/entry_points.txt,sha256=dXUQNom54uZt_7ylEG81iNYMamYpaFo9-ItcZJU6Uzc,58
+toml_combine-0.2.0.dist-info/RECORD,,

toml_combine-0.1.7.dist-info/RECORD

@@ -1,10 +0,0 @@
-toml_combine/__init__.py,sha256=l7i0GkM9k7cc__wj1yqK5XjpB3IJ0jqFU63tqKMuYlY,1625
-toml_combine/__main__.py,sha256=hmF8N8xX6UEApzbKTVZ-4E1HU5-rjgUkdXNLO-mF6vo,100
-toml_combine/cli.py,sha256=MZrAEP4wt6f9Qn0TEXIjeLoQMlvQulFpkMciwU8GRO4,2328
-toml_combine/combiner.py,sha256=98iWUnkbzDVGEkw-dXFZEt5G7io5SQzayceuTU2hRvo,7315
-toml_combine/exceptions.py,sha256=SepRFDxeWQEbD88jhF5g7laZSSULthho83BpW8u9RWs,897
-toml_combine/toml.py,sha256=_vCINvfJeS3gWid35Pmm3Yz4xyJ8LpKJRHL0axSU8nk,384
-toml_combine-0.1.7.dist-info/METADATA,sha256=vUsTB2Phm6t8GMpu28aPPsIxkSNOb0nBIFnQuKJSj_Y,6401
-toml_combine-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-toml_combine-0.1.7.dist-info/entry_points.txt,sha256=dXUQNom54uZt_7ylEG81iNYMamYpaFo9-ItcZJU6Uzc,58
-toml_combine-0.1.7.dist-info/RECORD,,