toml-combine 0.1.9__py3-none-any.whl → 0.3.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,26 +2,13 @@ from __future__ import annotations
 
 import copy
 import dataclasses
-import itertools
 from collections.abc import Mapping, Sequence
 from functools import partial
-from typing import Any, TypeVar, Union
+from typing import Any, TypeVar
 
 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, list[str]]
@@ -34,55 +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
-
-
-T = TypeVar("T", bound=Union[str, list[str]])
-
-
 def clean_dimensions_dict(
-    to_sort: Mapping[str, T], clean: dict[str, list[str]], type: str
-) -> dict[str, T]:
+    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
 
@@ -117,7 +89,10 @@ def override_sort_key(
     return tuple(result)
 
 
-def merge_configs(a: Any, b: Any, /) -> Any:
+T = TypeVar("T", dict, list, str, int, float, bool)
+
+
+def merge_configs(a: T, b: T, /) -> T:
     """
     Recursively merge two configuration dictionaries, with b taking precedence.
     """
@@ -128,7 +103,7 @@ def merge_configs(a: Any, b: Any, /) -> Any:
         return b
 
     result = a.copy()
-    for key, b_value in b.items():
+    for key, b_value in b.items():  # type: ignore
         if a_value := a.get(key):
             result[key] = merge_configs(a_value, b_value)
         else:
@@ -137,6 +112,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")
 
@@ -150,8 +126,11 @@ def build_config(config: dict[str, Any]) -> Config:
             when = override.pop("when")
         except KeyError:
             raise exceptions.MissingOverrideCondition(id=override)
-
-        when = {k: wrap_in_list(v) for k, v in when.items()}
+        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(v)) for k, v in when.items())
         if conditions in seen_conditions:
@@ -173,93 +152,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()):
-            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 output_matches_override(output: Output, override: Override) -> bool:
+def mapping_matches_override(mapping: dict[str, str], override: Override) -> bool:
     """
-    Check if the values in the override match the output dimensions.
+    Check if the values in the override match the given dimensions.
     """
     for dim, values in override.when.items():
-        if dim not in output.dimensions:
+        if dim not in mapping:
             return False
 
-        if output.dimensions[dim] not in values:
+        if mapping[dim] not in values:
             return False
 
     return True
 
 
-def generate_output(
-    default: Mapping[str, Any], overrides: Sequence[Override], output: Output
+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 output_matches_override(output=output, override=override):
+        if mapping_matches_override(mapping=mapping, override=override):
             result = merge_configs(result, override.config)
 
-    return {"dimensions": output.dimensions, **result}
-
-
-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

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.9.dist-info → toml_combine-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: toml-combine
-Version: 0.1.9
+Version: 0.3.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,16 +126,28 @@ 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.
 
-### CLI
+### Mapping
 
-```console
-$ toml-combine {path/to/config.toml}
-```
+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.
+
+By default, the output is `toml` though you can switch to `json` with `--format=json`
 
-Generates all the outputs described by the given TOML config.
+## CLI
 
-Note that you can restrict generation to some dimension values by passing
-`--{dimension}={value}`
+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
 
@@ -163,40 +155,23 @@ Note that you can restrict generation to some dimension values by passing
 import toml_combine
 
 
-result = toml_combine.combine(
-        config_file=config_file,
-        environment=["production", "staging"],
-        type="job",
-        job=["manage", "special-command"],
-    )
+result = toml_combine.combine(config_file=config_file, environment="staging")
 
 print(result)
 {
-  "production-job-manage": {...},
-  "production-job-special-command": {...},
-  "staging-job-manage": {...},
-  "staging-job-special-command": {...},
+  "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()`. Additional `kwargs` restrict the output.
+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
+## 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"
@@ -225,81 +200,62 @@ container.env.ENABLE_EXPENSIVE_MONITORING = false
 
 This produces the following configs:
 
-```json
-{
-  "production-frontend-eu": {
-    "dimensions": {
-      "environment": "production",
-      "service": "frontend",
-      "region": "eu"
-    },
-    "registry": "gcr.io/my-project/",
-    "service_account": "my-service-account",
-    "name": "service-frontend",
-    "container": {
-      "image_name": "my-image-frontend"
-    }
-  },
-  "production-backend-eu": {
-    "dimensions": {
-      "environment": "production",
-      "service": "backend",
-      "region": "eu"
-    },
-    "registry": "gcr.io/my-project/",
-    "service_account": "my-service-account",
-    "name": "service-backend",
-    "container": {
-      "image_name": "my-image-backend",
-      "port": 8080
-    }
-  },
-  "staging-frontend-eu": {
-    "dimensions": {
-      "environment": "staging",
-      "service": "frontend",
-      "region": "eu"
-    },
-    "registry": "gcr.io/my-project/",
-    "service_account": "my-service-account",
-    "name": "service-frontend",
-    "container": {
-      "image_name": "my-image-frontend"
-    }
-  },
-  "staging-backend-eu": {
-    "dimensions": {
-      "environment": "staging",
-      "service": "backend",
-      "region": "eu"
-    },
-    "registry": "gcr.io/my-project/",
-    "service_account": "my-service-account",
-    "name": "service-backend",
-    "container": {
-      "image_name": "my-image-backend",
-      "port": 8080,
-      "env": {
-        "ENABLE_EXPENSIVE_MONITORING": false
-      }
-    }
-  },
-  "dev-backend": {
-    "dimensions": {
-      "environment": "dev",
-      "service": "backend"
-    },
-    "registry": "gcr.io/my-project/",
-    "service_account": "my-service-account",
-    "name": "service-backend",
-    "container": {
-      "env": {
-        "DEBUG": true,
-        "ENABLE_EXPENSIVE_MONITORING": false
-      },
-      "image_name": "my-image-backend",
-      "port": 8080
-    }
-  }
-}
+```console
+$ uv run toml-combine example.toml --environment=production --service=frontend
+registry = "gcr.io/my-project/"
+service_account = "my-service-account"
+name = "service-frontend"
+
+[container]
+image_name = "my-image-frontend"
+```
+
+```console
+$ toml-combine example.toml --environment=production --service=backend
+registry = "gcr.io/my-project/"
+service_account = "my-service-account"
+name = "service-backend"
+
+[container]
+image_name = "my-image-backend"
+port = 8080
+```
+
+```console
+$ toml-combine example.toml --environment=staging --service=frontend
+registry = "gcr.io/my-project/"
+service_account = "my-service-account"
+name = "service-frontend"
+
+[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"
+
+[container]
+image_name = "my-image-backend"
+port = 8080
+
+[container.env]
+ENABLE_EXPENSIVE_MONITORING = false
+```
+
+```console
+$ toml-combine example.toml --environment=dev --service=backend
+registry = "gcr.io/my-project/"
+service_account = "my-service-account"
+name = "service-backend"
+
+[container]
+image_name = "my-image-backend"
+port = 8080
+[container.env]
+DEBUG = true
+ENABLE_EXPENSIVE_MONITORING = false
+
 ```

toml_combine-0.3.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=RhhCevncnVvxFYNywvtVWkVMpiqtF0mq_APjg76Tg4Q,5546
+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.3.0.dist-info/METADATA,sha256=xWGk3SSYPwWdcnqiRthODPYSLo3SSl84d_nSwUk3wJU,7354
+toml_combine-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+toml_combine-0.3.0.dist-info/entry_points.txt,sha256=dXUQNom54uZt_7ylEG81iNYMamYpaFo9-ItcZJU6Uzc,58
+toml_combine-0.3.0.dist-info/RECORD,,

toml_combine-0.1.9.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=_sSOCVBlv8ljAdMd6BEthS6rxiCnt-VV9rMEPSK_Cvk,7643
-toml_combine/exceptions.py,sha256=SepRFDxeWQEbD88jhF5g7laZSSULthho83BpW8u9RWs,897
-toml_combine/toml.py,sha256=_vCINvfJeS3gWid35Pmm3Yz4xyJ8LpKJRHL0axSU8nk,384
-toml_combine-0.1.9.dist-info/METADATA,sha256=ti8e_ng-_KdRPCAJybModogRhP4guqH8UilQTeXQHAk,8375
-toml_combine-0.1.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-toml_combine-0.1.9.dist-info/entry_points.txt,sha256=dXUQNom54uZt_7ylEG81iNYMamYpaFo9-ItcZJU6Uzc,58
-toml_combine-0.1.9.dist-info/RECORD,,