toml-combine 0.3.0__tar.gz → 0.5.0__tar.gz

{toml_combine-0.3.0 → toml_combine-0.5.0}/.pre-commit-config.yaml

@@ -22,11 +22,11 @@ repos:
       - id: mixed-line-ending
   - repo: https://github.com/astral-sh/uv-pre-commit
     # uv version.
-    rev: 0.6.13
+    rev: 0.6.14
     hooks:
       - id: uv-lock
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.4
+    rev: v0.11.5
     hooks:
       - id: ruff
         args: [--fix, --unsafe-fixes, --show-fixes]

{toml_combine-0.3.0 → toml_combine-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: toml-combine
-Version: 0.3.0
+Version: 0.5.0
 Summary: A tool for combining complex configurations in TOML format.
 Author-email: Joachim Jablon <ewjoachim@gmail.com>
 License-Expression: MIT
@@ -29,7 +29,7 @@ parts that are common to everyone.
 
 ### The config file
 
-The configuration file is usually a TOML file. Here's a small example:
+The configuration file is (usually) a TOML file. Here's a small example:
 
 ```toml
 [dimensions]
@@ -65,11 +65,14 @@ Overrides define a set of condition where they apply (`when.<dimension> =
 "<value>"`) and the values that are overriden. Overrides are applied in order from less
 specific to more specific, each one overriding the values of the previous ones:
 
-- If an override contains conditions on more dimensions than another one, it's applied
-  later
-- In case 2 overrides contain the same number of dimensions and they're a disjoint set,
-  then it depends on how the dimensions are defined at the top of the file: dimensions
-  defined last have a greater priority
+- In case 2 overrides are applicable, the more specific one (the one with more
+  dimensions defined) has greater priority
+- In case 2 overrides use the same number of dimensions, then it depends on how the
+  dimensions are defined at the top of the file: dimensions defined last have a greater
+  priority
+- In case 2 overrides use the same dimensions, if they define the same configuration
+  values, an error will be raised. If they define different configuation values, then
+  the priority is irrelevant.
 
 > [!Note]
 > Defining a list as the value of one or more conditions in an override
@@ -141,9 +144,9 @@ Example with the config from the previous section:
 
 ```console
 $ toml-combine path/to/config.toml --environment=staging
-[dimensions]
-environment = "staging"
+```
 
+```toml
 [fruits]
 apple.color = "red"
 orange.color = "orange"
@@ -201,7 +204,10 @@ container.env.ENABLE_EXPENSIVE_MONITORING = false
 This produces the following configs:
 
 ```console
-$ uv run toml-combine example.toml --environment=production --service=frontend
+$ toml-combine example.toml --environment=production --service=frontend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-frontend"
@@ -212,6 +218,9 @@ image_name = "my-image-frontend"
 
 ```console
 $ toml-combine example.toml --environment=production --service=backend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-backend"
@@ -223,6 +232,9 @@ port = 8080
 
 ```console
 $ toml-combine example.toml --environment=staging --service=frontend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-frontend"
@@ -233,6 +245,9 @@ image_name = "my-image-frontend"
 
 ```console
 $ toml-combine example.toml --environment=staging --service=backend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-backend"
@@ -247,6 +262,9 @@ ENABLE_EXPENSIVE_MONITORING = false
 
 ```console
 $ toml-combine example.toml --environment=dev --service=backend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-backend"
@@ -257,5 +275,4 @@ port = 8080
 [container.env]
 DEBUG = true
 ENABLE_EXPENSIVE_MONITORING = false
-
 ```

{toml_combine-0.3.0 → toml_combine-0.5.0}/README.md

@@ -10,7 +10,7 @@ parts that are common to everyone.
 
 ### The config file
 
-The configuration file is usually a TOML file. Here's a small example:
+The configuration file is (usually) a TOML file. Here's a small example:
 
 ```toml
 [dimensions]
@@ -46,11 +46,14 @@ Overrides define a set of condition where they apply (`when.<dimension> =
 "<value>"`) and the values that are overriden. Overrides are applied in order from less
 specific to more specific, each one overriding the values of the previous ones:
 
-- If an override contains conditions on more dimensions than another one, it's applied
-  later
-- In case 2 overrides contain the same number of dimensions and they're a disjoint set,
-  then it depends on how the dimensions are defined at the top of the file: dimensions
-  defined last have a greater priority
+- In case 2 overrides are applicable, the more specific one (the one with more
+  dimensions defined) has greater priority
+- In case 2 overrides use the same number of dimensions, then it depends on how the
+  dimensions are defined at the top of the file: dimensions defined last have a greater
+  priority
+- In case 2 overrides use the same dimensions, if they define the same configuration
+  values, an error will be raised. If they define different configuation values, then
+  the priority is irrelevant.
 
 > [!Note]
 > Defining a list as the value of one or more conditions in an override
@@ -122,9 +125,9 @@ Example with the config from the previous section:
 
 ```console
 $ toml-combine path/to/config.toml --environment=staging
-[dimensions]
-environment = "staging"
+```
 
+```toml
 [fruits]
 apple.color = "red"
 orange.color = "orange"
@@ -182,7 +185,10 @@ container.env.ENABLE_EXPENSIVE_MONITORING = false
 This produces the following configs:
 
 ```console
-$ uv run toml-combine example.toml --environment=production --service=frontend
+$ toml-combine example.toml --environment=production --service=frontend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-frontend"
@@ -193,6 +199,9 @@ image_name = "my-image-frontend"
 
 ```console
 $ toml-combine example.toml --environment=production --service=backend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-backend"
@@ -204,6 +213,9 @@ port = 8080
 
 ```console
 $ toml-combine example.toml --environment=staging --service=frontend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-frontend"
@@ -214,6 +226,9 @@ image_name = "my-image-frontend"
 
 ```console
 $ toml-combine example.toml --environment=staging --service=backend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-backend"
@@ -228,6 +243,9 @@ ENABLE_EXPENSIVE_MONITORING = false
 
 ```console
 $ toml-combine example.toml --environment=dev --service=backend
+```
+
+```toml
 registry = "gcr.io/my-project/"
 service_account = "my-service-account"
 name = "service-backend"
@@ -238,5 +256,4 @@ port = 8080
 [container.env]
 DEBUG = true
 ENABLE_EXPENSIVE_MONITORING = false
-
 ```

{toml_combine-0.3.0 → toml_combine-0.5.0}/tests/test_combiner.py

@@ -103,7 +103,7 @@ def test_merge_configs__dicts_error():
         ),
     ],
 )
-def test_generate_for_mapping(mapping: dict, expected: dict[str, int]):
+def __full_chain(mapping: dict, expected: dict[str, int]):
     default = {
         "a": 1,
         "b": 2,
@@ -138,8 +138,11 @@ def test_generate_for_mapping(mapping: dict, expected: dict[str, int]):
     ]
 
     result = combiner.generate_for_mapping(
-        default=default,
-        overrides=overrides,
+        config=combiner.Config(
+            dimensions={"env": ["prod", "staging"], "region": ["us"]},
+            default=default,
+            overrides=overrides,
+        ),
         mapping=mapping,
     )
     assert result == expected
@@ -224,10 +227,7 @@ def test_build_config():
 def test_build_config__duplicate_overrides():
     raw_config = """
     [dimensions]
-    env = ["dev", "prod"]
-
-    [templates]
-    foo = "bar"
+    env = ["prod"]
 
     [[override]]
     when.env = "prod"
@@ -243,6 +243,52 @@ def test_build_config__duplicate_overrides():
         combiner.build_config(config)
 
 
+def test_build_config__duplicate_overrides_different_vars():
+    raw_config = """
+    [dimensions]
+    env = ["prod"]
+
+    [[override]]
+    when.env = "prod"
+    foo = "baz"
+
+    [[override]]
+    when.env = "prod"
+    baz = "qux"
+    """
+
+    config = toml.loads(raw_config)
+    assert len(combiner.build_config(config).overrides) == 2
+
+
+def test_build_config__duplicate_overrides_list():
+    raw_config = """
+    [dimensions]
+    env = ["prod", "dev"]
+
+    [[override]]
+    when.env = ["prod"]
+    foo = "baz"
+    hello = 1
+
+    [[override]]
+    when.env = ["prod", "dev"]
+    foo = "qux"
+    hello = 1
+    """
+
+    config = toml.loads(raw_config)
+    with pytest.raises(exceptions.DuplicateError) as excinfo:
+        combiner.build_config(config)
+
+    # Message is a bit complex so we test it too.
+    assert (
+        str(excinfo.value) == "In override {'env': ['prod', 'dev']}: "
+        "Overrides with the same dimensions cannot define the same configuration keys: "
+        "foo, hello"
+    )
+
+
 def test_build_config__dimension_not_found_in_override():
     raw_config = """
     [dimensions]
@@ -271,16 +317,79 @@ def test_build_config__dimension_value_not_found_in_override():
         combiner.build_config(config)
 
 
-@pytest.fixture
-def config():
-    return combiner.build_config(
+@pytest.mark.parametrize(
+    "mapping, expected",
+    [
+        (
+            {"env": "prod"},
+            {"foo": "bar"},
+        ),
+        (
+            {"env": "dev"},
+            {"foo": "baz"},
+        ),
+    ],
+)
+def test_generate_for_mapping__full_chain(mapping, expected):
+    config = combiner.build_config(
         toml.loads(
             """
-        [dimensions]
-        env = ["dev", "prod"]
+            [dimensions]
+            env = ["prod", "dev"]
+
+            [default]
+            foo = "bar"
 
-        [default]
-        foo = "bar"
+            [[override]]
+            when.env = "dev"
+            foo = "baz"
+            """,
+        )
+    )
+    result = combiner.generate_for_mapping(
+        config=config,
+        mapping=mapping,
+    )
+    assert result == expected
+
+
+def test_extract_keys():
+    config = toml.loads(
+        """
+        a = 1
+        b.c = 1
+        b.d = 1
+        e.f.g = 1
         """,
+    )
+
+    result = list(combiner.extract_keys(config))
+    assert result == [
+        ("a",),
+        ("b", "c"),
+        ("b", "d"),
+        ("e", "f", "g"),
+    ]
+
+
+def test_extract_definitions():
+    result = list(
+        combiner.extract_conditions_and_keys(
+            when={"env": ["dev", "staging"], "region": ["eu", "us"]},
+            config={
+                "a": 1,
+                "b.c.d": 4,
+            },
         )
     )
+    print(result)
+    assert result == [
+        ((("env", "dev"), ("region", "eu")), "a"),
+        ((("env", "dev"), ("region", "us")), "a"),
+        ((("env", "staging"), ("region", "eu")), "a"),
+        ((("env", "staging"), ("region", "us")), "a"),
+        ((("env", "dev"), ("region", "eu")), "b.c.d"),
+        ((("env", "dev"), ("region", "us")), "b.c.d"),
+        ((("env", "staging"), ("region", "eu")), "b.c.d"),
+        ((("env", "staging"), ("region", "us")), "b.c.d"),
+    ]

{toml_combine-0.3.0 → toml_combine-0.5.0}/toml_combine/combiner.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import copy
 import dataclasses
-from collections.abc import Mapping, Sequence
+import itertools
+from collections.abc import Iterable, Mapping, Sequence
 from functools import partial
 from typing import Any, TypeVar
 
@@ -80,6 +81,18 @@ def override_sort_key(
       {"env": "dev", "region": "us"} (less specific)
     - Override with {"env": "dev"} comes before override with {"region": "us"} ("env"
       is defined before "region" in the dimensions list)
+
+    Parameters:
+    -----------
+    override: An Override object that defines the condition when it applies
+                (override.when)
+    dimensions: The dict of all existing dimensions and their values, in order of
+                definition
+
+    Returns:
+    --------
+    A tuple that supports comparisons. Less specific Overrides should return smaller
+    values and vice versa.
     """
     result = [len(override.when)]
     for i, dimension in enumerate(dimensions):
@@ -111,6 +124,35 @@ def merge_configs(a: T, b: T, /) -> T:
     return result
 
 
+def extract_keys(config: Any) -> Iterable[tuple[str, ...]]:
+    """
+    Extract the keys from a config.
+    """
+    if isinstance(config, dict):
+        for key, value in config.items():
+            for sub_key in extract_keys(value):
+                yield (key, *sub_key)
+    else:
+        yield tuple()
+
+
+def extract_conditions_and_keys(
+    when: dict[str, list[str]], config: dict[str, Any]
+) -> Iterable[tuple[Any, ...]]:
+    """
+    Extract the definitions from an override.
+    """
+    when_definitions = []
+    for key, values in when.items():
+        when_definitions.append([(key, value) for value in values])
+
+    when_combined_definitions = list(itertools.product(*when_definitions))
+    config_keys = extract_keys(config)
+    for config_key in config_keys:
+        for when_definition in when_combined_definitions:
+            yield (when_definition, *config_key)
+
+
 def build_config(config: dict[str, Any]) -> Config:
     config = copy.deepcopy(config)
     # Parse dimensions
@@ -119,7 +161,9 @@ def build_config(config: dict[str, Any]) -> Config:
     # Parse template
     default = config.pop("default", {})
 
-    seen_conditions = set()
+    # The rule is: the same exact set of conditions cannot be used twice to define
+    # the same values (on the same or different overrides)
+    seen_conditions_and_keys = set()
     overrides = []
     for override in config.pop("override", []):
         try:
@@ -132,20 +176,17 @@ def build_config(config: dict[str, Any]) -> Config:
             type="override",
         )
 
-        conditions = tuple((k, tuple(v)) for k, v in when.items())
-        if conditions in seen_conditions:
-            raise exceptions.DuplicateError(type="override", id=when)
+        conditions_and_keys = set(
+            extract_conditions_and_keys(when=when, config=override)
+        )
+        if duplicates := (conditions_and_keys & seen_conditions_and_keys):
+            duplicate_str = ", ".join(sorted(key for *_, key in duplicates))
+            raise exceptions.DuplicateError(id=when, details=duplicate_str)
 
-        seen_conditions.add(conditions)
+        seen_conditions_and_keys |= conditions_and_keys
+
+        overrides.append(Override(when=when, config=override))
 
-        overrides.append(
-            Override(
-                when=clean_dimensions_dict(
-                    to_sort=when, clean=dimensions, type="override"
-                ),
-                config=override,
-            )
-        )
     # Sort overrides by increasing specificity
     overrides = sorted(
         overrides,
@@ -159,7 +200,7 @@ def build_config(config: dict[str, Any]) -> Config:
     )
 
 
-def mapping_matches_override(mapping: dict[str, str], override: Override) -> bool:
+def mapping_matches_override(mapping: Mapping[str, str], override: Override) -> bool:
     """
     Check if the values in the override match the given dimensions.
     """
@@ -174,13 +215,12 @@ def mapping_matches_override(mapping: dict[str, str], override: Override) -> boo
 
 
 def generate_for_mapping(
-    default: Mapping[str, Any],
-    overrides: Sequence[Override],
-    mapping: dict[str, str],
-) -> dict[str, Any]:
-    result = copy.deepcopy(default)
+    config: Config,
+    mapping: Mapping[str, str],
+) -> Mapping[str, Any]:
+    result = copy.deepcopy(config.default)
     # Apply each matching override
-    for override in overrides:
+    for override in config.overrides:
         # Check if all dimension values in the override match
 
         if mapping_matches_override(mapping=mapping, override=override):

{toml_combine-0.3.0 → toml_combine-0.5.0}/toml_combine/exceptions.py

@@ -20,7 +20,7 @@ class TomlEncodeError(TomlCombineError):
 
 
 class DuplicateError(TomlCombineError):
-    """In {type} {id}: Cannot have multiple {type}s with the same dimensions."""
+    """In override {id}: Overrides with the same dimensions cannot define the same configuration keys: {details}"""
 
 
 class DimensionNotFound(TomlCombineError):

{toml_combine-0.3.0 → toml_combine-0.5.0}/toml_combine/lib.py

@@ -52,7 +52,6 @@ def combine(*, config=None, config_file=None, **mapping):
     config_obj = combiner.build_config(dict_config)
 
     return combiner.generate_for_mapping(
-        default=config_obj.default,
-        overrides=config_obj.overrides,
+        config=config_obj,
         mapping=mapping,
     )

{toml_combine-0.3.0 → toml_combine-0.5.0}/toml_combine/toml.py

@@ -22,6 +22,6 @@ def dumps(config: dict) -> str:
     # 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)))
+        return tomlkit.dumps(json.loads(json.dumps(config)), sort_keys=False)
     except tomlkit.exceptions.TOMLKitError as e:
         raise exceptions.TomlEncodeError from e