toml-combine 0.4.0__tar.gz → 0.6.0__tar.gz

{toml_combine-0.4.0 → toml_combine-0.6.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.4.0 → toml_combine-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: toml-combine
-Version: 0.4.0
+Version: 0.6.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]
@@ -62,14 +62,19 @@ The common configuration to start from, before we start overlaying overrides on
 ### Overrides
 
 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:
+"<value>"`) and the values that are overridden when they're applicable.
 
-- 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 and define a value for the same key, if one is more
+  specific than the other (e.g. env=prod,region=us is more specific than env=prod) then
+  its values will have precedence.
+- If they are mutually exclusive, (env=prod vs env=staging) precedence is irrelevant.
+- If you try to generate the configuration and 2 applicable overrides define a value for
+  the same key, an error will be raised (e.g. env=staging and region=eu). In that case,
+  you should add dimensions to either override to make them mutually exclusive or make
+  one more specific than the other.
+
+  Note that it's not a problem if incompatible overrides exist in your configuration, as
+  long as they are not both applicable in the same call.
 
 > [!Note]
 > Defining a list as the value of one or more conditions in an override
@@ -77,14 +82,11 @@ specific to more specific, each one overriding the values of the previous ones:
 
 ### The configuration itself
 
-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
+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
-arrays will just replace one another. See `Arrays` below.
-
-In the generated configuration, the dimensions of the output will appear in the generated
-object as an object under the `dimensions` key.
+Python/JS/Toml lingo) will be merged between the default and the applicable overrides,
+while arrays will just replace one another. See `Arrays` below.
 
 ### Arrays
 
@@ -141,9 +143,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"
@@ -188,8 +190,9 @@ container.image_name = "my-image-backend"
 container.port = 8080
 
 [[override]]
-name = "service-dev"
+when.service = "backend"
 when.environment = "dev"
+name = "service-dev"
 container.env.DEBUG = true
 
 [[override]]
@@ -202,6 +205,9 @@ This produces the following configs:
 
 ```console
 $ 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.4.0 → toml_combine-0.6.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]
@@ -43,14 +43,19 @@ The common configuration to start from, before we start overlaying overrides on
 ### Overrides
 
 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:
+"<value>"`) and the values that are overridden when they're applicable.
 
-- 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 and define a value for the same key, if one is more
+  specific than the other (e.g. env=prod,region=us is more specific than env=prod) then
+  its values will have precedence.
+- If they are mutually exclusive, (env=prod vs env=staging) precedence is irrelevant.
+- If you try to generate the configuration and 2 applicable overrides define a value for
+  the same key, an error will be raised (e.g. env=staging and region=eu). In that case,
+  you should add dimensions to either override to make them mutually exclusive or make
+  one more specific than the other.
+
+  Note that it's not a problem if incompatible overrides exist in your configuration, as
+  long as they are not both applicable in the same call.
 
 > [!Note]
 > Defining a list as the value of one or more conditions in an override
@@ -58,14 +63,11 @@ specific to more specific, each one overriding the values of the previous ones:
 
 ### The configuration itself
 
-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
+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
-arrays will just replace one another. See `Arrays` below.
-
-In the generated configuration, the dimensions of the output will appear in the generated
-object as an object under the `dimensions` key.
+Python/JS/Toml lingo) will be merged between the default and the applicable overrides,
+while arrays will just replace one another. See `Arrays` below.
 
 ### Arrays
 
@@ -122,9 +124,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"
@@ -169,8 +171,9 @@ container.image_name = "my-image-backend"
 container.port = 8080
 
 [[override]]
-name = "service-dev"
+when.service = "backend"
 when.environment = "dev"
+name = "service-dev"
 container.env.DEBUG = true
 
 [[override]]
@@ -183,6 +186,9 @@ This produces the following configs:
 
 ```console
 $ 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.4.0 → toml_combine-0.6.0}/tests/test.toml

@@ -49,6 +49,7 @@ cloudsql_instance = "staging-postgres"
 containers.app.env.APP_FOO = "qux"
 
 [[override]]
+when.stack = "django"
 # The following line defines when in an array. It's not useful, as there's only one
 # value,  but we want to test that arrays work too.
 when.service = ["admin"]
@@ -57,6 +58,7 @@ containers.app.env.APP_ADMIN_ENABLED = true
 containers.app.env.APP_ID = 1234
 
 [[override]]
+when.stack = "django"
 when.service = "admin"
 when.environment = "staging"
 containers.app.env.APP_ID = 5678
@@ -66,11 +68,13 @@ when.type = "job"
 containers.app.job.max_retries = 1
 
 [[override]]
+when.stack = "django"
 when.job = "manage"
 containers.app.name = "manage"
 containers.app.command = ["./manage.py"]
 
 [[override]]
+when.stack = "django"
 when.job = "special-command"
 containers.app.name = "special-command"
 containers.app.container_cpu = 8

{toml_combine-0.4.0 → toml_combine-0.6.0}/tests/test_cli.py

@@ -8,7 +8,7 @@ from toml_combine import cli, toml
 
 def test_cli__json(capsys):
     """Test the CLI."""
-    cli.cli(
+    exit_code = cli.cli(
         argv=[
             "tests/test.toml",
             "--format",
@@ -28,6 +28,7 @@ def test_cli__json(capsys):
     print(out)
     print("err:")
     print(err)
+    assert exit_code == 0
 
     expected = json.loads((pathlib.Path(__file__).parent / "result.json").read_text())
     assert json.loads(out) == expected["staging-service-django-admin"]

{toml_combine-0.4.0 → toml_combine-0.6.0}/tests/test_combiner.py

@@ -5,39 +5,6 @@ import pytest
 from toml_combine import combiner, exceptions, toml
 
 
-@pytest.mark.parametrize(
-    "small_override, large_override, dimensions",
-    [
-        pytest.param(
-            {"env": "prod"},
-            {"env": "prod", "region": "eu"},
-            {"env": ["prod"], "region": ["eu"]},
-            id="less_specific_override_comes_first",
-        ),
-        pytest.param(
-            {"env": "prod", "region": "eu"},
-            {"env": "prod", "service": "web"},
-            {"env": ["prod"], "region": ["eu"], "service": ["web"]},
-            id="different_dimensions_sorted_by_dimension",
-        ),
-        pytest.param(
-            {"env": "prod"},
-            {"region": "eu"},
-            {"env": ["prod"], "region": ["eu"]},
-            id="completely_different_dimensions",
-        ),
-    ],
-)
-def test_override_sort_key(small_override, large_override, dimensions):
-    small_key = combiner.override_sort_key(
-        combiner.Override(when=small_override, config={}), dimensions
-    )
-    large_key = combiner.override_sort_key(
-        combiner.Override(when=large_override, config={}), dimensions
-    )
-    assert small_key < large_key
-
-
 @pytest.mark.parametrize(
     "a, b, expected",
     [
@@ -103,7 +70,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 +105,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
@@ -221,13 +191,10 @@ def test_build_config():
     )
 
 
-def test_build_config__duplicate_overrides():
+def test_generate_for_mapping__duplicate_overrides():
     raw_config = """
     [dimensions]
-    env = ["dev", "prod"]
-
-    [templates]
-    foo = "bar"
+    env = ["prod"]
 
     [[override]]
     when.env = "prod"
@@ -238,9 +205,58 @@ def test_build_config__duplicate_overrides():
     foo = "qux"
     """
 
-    config = toml.loads(raw_config)
+    config = combiner.build_config(toml.loads(raw_config))
     with pytest.raises(exceptions.DuplicateError):
-        combiner.build_config(config)
+        combiner.generate_for_mapping(config=config, mapping={"env": "prod"})
+
+
+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 = combiner.build_config(toml.loads(raw_config))
+    assert combiner.generate_for_mapping(config=config, mapping={"env": "prod"}) == {
+        "foo": "baz",
+        "baz": "qux",
+    }
+
+
+def test_build_config__duplicate_overrides_list():
+    raw_config = """
+    [dimensions]
+    env = ["prod", "dev"]
+
+    [[override]]
+    when.env = ["prod"]
+    hello.world = 1
+
+    [[override]]
+    when.env = ["prod", "dev"]
+    hello.world = 2
+    """
+
+    config = combiner.build_config(toml.loads(raw_config))
+    with pytest.raises(exceptions.DuplicateError) as excinfo:
+        combiner.generate_for_mapping(config=config, mapping={"env": "prod"})
+
+    # Message is a bit complex so we test it too.
+    assert (
+        str(excinfo.value)
+        == "In override {'env': ['prod', 'dev']}: Overrides defining the same "
+        "configuration keys must be included in one another or mutually exclusive.\n"
+        "Key defined multiple times: hello.world\n"
+        "Other override: {'env': ['prod']}"
+    )
 
 
 def test_build_config__dimension_not_found_in_override():
@@ -271,16 +287,109 @@ 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"),
+    ]
+
+
+@pytest.mark.parametrize(
+    "a, b, expected",
+    [
+        pytest.param(
+            {"env": ["dev"], "region": ["eu"]},
+            {"env": ["dev"]},
+            True,
+            id="subset1",
+        ),
+        pytest.param(
+            {"env": ["dev"]},
+            {"env": ["dev"], "region": ["eu"]},
+            True,
+            id="subset2",
+        ),
+        pytest.param(
+            {"env": ["prod"], "region": ["eu"]},
+            {"env": ["dev"]},
+            True,
+            id="subset3",
+        ),
+        pytest.param(
+            {"env": ["dev"]},
+            {"env": ["prod"], "region": ["eu"]},
+            True,
+            id="subset4",
+        ),
+        pytest.param({"env": ["dev"]}, {"region": ["eu"]}, False, id="disjoint"),
+        pytest.param(
+            {"env": ["dev"], "service": ["frontend"]},
+            {"region": ["eu"], "service": ["frontend"]},
+            False,
+            id="overlap",
+        ),
+        pytest.param({"env": ["dev"]}, {"env": ["dev"]}, False, id="same_keys1"),
+        pytest.param(
+            {"env": ["dev", "prod"]}, {"env": ["dev"]}, False, id="same_keys1"
+        ),
+        pytest.param(
+            {"env": ["prod"]}, {"env": ["dev"]}, True, id="same_keys_disjoint"
+        ),
+        pytest.param(
+            {"env": ["prod", "staging"]},
+            {"env": ["dev", "sandbox"]},
+            True,
+            id="multiple_keys_disjoint",
+        ),
+    ],
+)
+def test_are_conditions_compatible(a, b, expected):
+    assert combiner.are_conditions_compatible(a, b) == expected

{toml_combine-0.4.0 → toml_combine-0.6.0}/tests/test_lib.py

@@ -16,23 +16,19 @@ def expected():
     return json.loads((pathlib.Path(__file__).parent / "result.json").read_text())
 
 
-@pytest.mark.parametrize(
-    "kwargs",
-    [
-        {"config_file": config_file},
-        {"config_file": str(config_file)},
-        {"config": config_file.read_text()},
-        {"config": toml.loads(config_file.read_text())},
-    ],
-)
 @pytest.mark.parametrize(
     "mapping, expected_key",
     [
-        (
-            {"environment": "staging", "type": "service", "stack": "next"},
+        pytest.param(
+            {
+                "environment": "staging",
+                "type": "service",
+                "stack": "next",
+            },
             "staging-service-next",
+            id="staging-service-next",
         ),
-        (
+        pytest.param(
             {
                 "environment": "staging",
                 "type": "service",
@@ -40,8 +36,9 @@ def expected():
                 "service": "api",
             },
             "staging-service-django-api",
+            id="staging-service-django-api",
         ),
-        (
+        pytest.param(
             {
                 "environment": "staging",
                 "type": "service",
@@ -49,8 +46,9 @@ def expected():
                 "service": "admin",
             },
             "staging-service-django-admin",
+            id="staging-service-django-admin",
         ),
-        (
+        pytest.param(
             {
                 "environment": "staging",
                 "type": "job",
@@ -58,8 +56,9 @@ def expected():
                 "job": "manage",
             },
             "staging-job-django-manage",
+            id="staging-job-django-manage",
         ),
-        (
+        pytest.param(
             {
                 "environment": "staging",
                 "type": "job",
@@ -67,12 +66,18 @@ def expected():
                 "job": "special-command",
             },
             "staging-job-django-special-command",
+            id="staging-job-django-special-command",
         ),
-        (
-            {"environment": "production", "type": "service", "stack": "next"},
+        pytest.param(
+            {
+                "environment": "production",
+                "type": "service",
+                "stack": "next",
+            },
             "production-service-next",
+            id="production-service-next",
         ),
-        (
+        pytest.param(
             {
                 "environment": "production",
                 "type": "service",
@@ -80,8 +85,9 @@ def expected():
                 "service": "api",
             },
             "production-service-django-api",
+            id="production-service-django-api",
         ),
-        (
+        pytest.param(
             {
                 "environment": "production",
                 "type": "service",
@@ -89,8 +95,9 @@ def expected():
                 "service": "admin",
             },
             "production-service-django-admin",
+            id="production-service-django-admin",
         ),
-        (
+        pytest.param(
             {
                 "environment": "production",
                 "type": "job",
@@ -98,8 +105,9 @@ def expected():
                 "job": "manage",
             },
             "production-job-django-manage",
+            id="production-job-django-manage",
         ),
-        (
+        pytest.param(
             {
                 "environment": "production",
                 "type": "job",
@@ -107,9 +115,30 @@ def expected():
                 "job": "special-command",
             },
             "production-job-django-special-command",
+            id="production-job-django-special-command",
         ),
     ],
 )
-def test_full(kwargs, mapping, expected, expected_key):
-    result = toml_combine.combine(**kwargs, **mapping)
+def test_full_config(mapping, expected, expected_key):
+    result = toml_combine.combine(config_file=config_file, **mapping)
     assert result == expected[expected_key]
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        pytest.param({"config_file": config_file}, id="path"),
+        pytest.param({"config_file": str(config_file)}, id="path_str"),
+        pytest.param({"config": config_file.read_text()}, id="text"),
+        pytest.param({"config": toml.loads(config_file.read_text())}, id="parsed"),
+    ],
+)
+def test_full_load_kwargs(kwargs, expected):
+    result = toml_combine.combine(
+        **kwargs,
+        environment="production",
+        type="service",
+        stack="django",
+        service="api",
+    )
+    assert result == expected["production-service-django-api"]

{toml_combine-0.4.0 → toml_combine-0.6.0}/toml_combine/combiner.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 import copy
 import dataclasses
-from collections.abc import Mapping, Sequence
-from functools import partial
+from collections.abc import Iterable, Mapping, Sequence
 from typing import Any, TypeVar
 
 from . import exceptions
@@ -59,36 +58,6 @@ def clean_dimensions_dict(
     return result
 
 
-def override_sort_key(
-    override: Override, dimensions: dict[str, list[str]]
-) -> tuple[int, ...]:
-    """
-    We sort overrides before applying them, and they are applied in the order of the
-    sorted list, each override replacing the common values of the previous overrides.
-
-    override_sort_key defines the sort key for overrides that ensures less specific
-    overrides come first:
-    - Overrides with fewer dimensions come first (will be overridden
-      by more specific ones)
-    - If two overrides have the same number of dimensions but define different
-      dimensions, we sort by the definition order of the dimensions.
-
-    Example:
-    dimensions = {"env": ["dev", "prod"], "region": ["us", "eu"]}
-
-    - Override with {"env": "dev"} comes before override with
-      {"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)
-    """
-    result = [len(override.when)]
-    for i, dimension in enumerate(dimensions):
-        if dimension in override.when:
-            result.append(i)
-
-    return tuple(result)
-
-
 T = TypeVar("T", dict, list, str, int, float, bool)
 
 
@@ -111,6 +80,41 @@ 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 are_conditions_compatible(
+    a: Mapping[str, list[str]], b: Mapping[str, list[str]], /
+) -> bool:
+    """
+    `a` and `b` are dictionaries representing override conditions (`when`). Return
+    `True` if the conditions represented by `a` are compatible. Conditions are
+    compatible if one is stricly more specific than the other or if they're mutually
+    exclusive.
+    """
+    # Subset
+    if set(a) < set(b) or set(b) < set(a):
+        return True
+
+    # Disjoint or overlapping sets
+    if set(a) != set(b):
+        return False
+
+    # Equal sets: it's only compatible if the values are disjoint
+    if any(set(a[key]) & set(b[key]) for key in a.keys()):
+        return False
+    return True
+
+
 def build_config(config: dict[str, Any]) -> Config:
     config = copy.deepcopy(config)
     # Parse dimensions
@@ -119,7 +123,6 @@ def build_config(config: dict[str, Any]) -> Config:
     # Parse template
     default = config.pop("default", {})
 
-    seen_conditions = set()
     overrides = []
     for override in config.pop("override", []):
         try:
@@ -132,25 +135,10 @@ 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)
-
-        seen_conditions.add(conditions)
+        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,
-        key=partial(override_sort_key, dimensions=dimensions),
-    )
+    overrides = sorted(overrides, key=lambda override: len(override.when))
 
     return Config(
         dimensions=dimensions,
@@ -159,7 +147,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,16 +162,32 @@ 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)
+    keys_to_conditions: dict[tuple[str, ...], list[dict[str, list[str]]]] = {}
     # 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):
+            # Check that all applicableoverrides are compatible
+            keys = extract_keys(override.config)
+
+            for key in keys:
+                previous_conditions = keys_to_conditions.setdefault(key, [])
+
+                for previous_condition in previous_conditions:
+                    if not are_conditions_compatible(previous_condition, override.when):
+                        raise exceptions.DuplicateError(
+                            id=override.when,
+                            key=".".join(key),
+                            other_override=previous_condition,
+                        )
+
+                keys_to_conditions[key].append(override.when)
+
             result = merge_configs(result, override.config)
 
     return result

{toml_combine-0.4.0 → toml_combine-0.6.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 defining the same configuration keys must be included in one another or mutually exclusive.\nKey defined multiple times: {key}\nOther override: {other_override}"""
 
 
 class DimensionNotFound(TomlCombineError):

{toml_combine-0.4.0 → toml_combine-0.6.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,
     )