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

toml_combine-1.0.0/CONTRIBUTING.md

@@ -0,0 +1,34 @@
+## Development
+
+This project uses [uv](https://docs.astral.sh/uv/).
+
+If you don't have uv installed, install it with:
+
+```console
+$ curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+or using a package manager, such as [brew](https://brew.sh/):
+
+```console
+$ brew install uv
+```
+
+Then you can directly launch the tests with:
+
+```console
+$ uv run pytest
+```
+
+or create a virtual environment to work on the package and activate it:
+
+```console
+$ uv sync
+$ source .venv/bin/activate
+```
+
+or launch the command itself with uv (no need to activate the venv):
+
+```console
+$ uv run toml-combine --help
+```

toml_combine-1.0.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2025- Joachim Jablon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{toml_combine-0.6.0 → toml_combine-1.0.0}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: toml-combine
-Version: 0.6.0
+Version: 1.0.0
 Summary: A tool for combining complex configurations in TOML format.
 Author-email: Joachim Jablon <ewjoachim@gmail.com>
 License-Expression: MIT
+License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -19,6 +20,12 @@ Description-Content-Type: text/markdown
 
 # Toml-combine
 
+[![Deployed to PyPI](https://img.shields.io/pypi/v/toml-combine?logo=pypi&logoColor=white)](https://pypi.org/pypi/toml-combine)
+[![Deployed to PyPI](https://img.shields.io/pypi/pyversions/toml-combine?logo=pypi&logoColor=white)](https://pypi.org/pypi/toml-combine)
+[![GitHub Repository](https://img.shields.io/github/stars/ewjoachim/toml-combine?style=flat&logo=github&color=brightgreen)](https://github.com/ewjoachim/toml-combine/)
+[![Continuous Integration](https://img.shields.io/github/actions/workflow/status/ewjoachim/toml-combine/ci.yml?logo=github&branch=main)](https://github.com/ewjoachim/toml-combine/actions?workflow=CI)
+[![MIT License](https://img.shields.io/github/license/ewjoachim/toml-combine?logo=open-source-initiative&logoColor=white)](https://github.com/ewjoachim/toml-combine/blob/main/LICENSE)
+
 `toml-combine` is a Python lib and CLI-tool that reads a TOML configuration file
 defining a default configuration alongside with overrides, and merges everything
 following rules you define to get final configurations. Let's say: you have multiple
@@ -62,7 +69,7 @@ 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 overridden when they're applicable.
+"<value>"`) and the values that are overridgden when they're applicable.
 
 - 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

{toml_combine-0.6.0 → toml_combine-1.0.0}/README.md

@@ -1,5 +1,11 @@
 # Toml-combine
 
+[![Deployed to PyPI](https://img.shields.io/pypi/v/toml-combine?logo=pypi&logoColor=white)](https://pypi.org/pypi/toml-combine)
+[![Deployed to PyPI](https://img.shields.io/pypi/pyversions/toml-combine?logo=pypi&logoColor=white)](https://pypi.org/pypi/toml-combine)
+[![GitHub Repository](https://img.shields.io/github/stars/ewjoachim/toml-combine?style=flat&logo=github&color=brightgreen)](https://github.com/ewjoachim/toml-combine/)
+[![Continuous Integration](https://img.shields.io/github/actions/workflow/status/ewjoachim/toml-combine/ci.yml?logo=github&branch=main)](https://github.com/ewjoachim/toml-combine/actions?workflow=CI)
+[![MIT License](https://img.shields.io/github/license/ewjoachim/toml-combine?logo=open-source-initiative&logoColor=white)](https://github.com/ewjoachim/toml-combine/blob/main/LICENSE)
+
 `toml-combine` is a Python lib and CLI-tool that reads a TOML configuration file
 defining a default configuration alongside with overrides, and merges everything
 following rules you define to get final configurations. Let's say: you have multiple
@@ -43,7 +49,7 @@ 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 overridden when they're applicable.
+"<value>"`) and the values that are overridgden when they're applicable.
 
 - 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

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

@@ -31,90 +31,6 @@ def test_merge_configs__dicts_error():
         combiner.merge_configs({"a": 1}, {"a": {"b": 2}})
 
 
-@pytest.mark.parametrize(
-    "mapping, expected",
-    [
-        pytest.param(
-            {"env": "dev"},
-            {
-                "a": 1,
-                "b": 2,
-                "c": 3,
-                "d": {"e": {"h": {"i": {"j": 4}}}},
-                "g": 6,
-            },
-            id="no_matches",
-        ),
-        pytest.param(
-            {"env": "prod"},
-            {
-                "a": 10,
-                "b": 2,
-                "c": 30,
-                "d": {"e": {"h": {"i": {"j": 40}}}},
-                "g": 60,
-            },
-            id="single_match",
-        ),
-        pytest.param(
-            {"env": "staging"},
-            {
-                "a": 1,
-                "b": 200,
-                "c": 300,
-                "d": {"e": {"h": {"i": {"j": 400}}}},
-                "f": 500,
-                "g": 6,
-            },
-            id="dont_override_if_match_is_more_specific",
-        ),
-    ],
-)
-def __full_chain(mapping: dict, expected: dict[str, int]):
-    default = {
-        "a": 1,
-        "b": 2,
-        "c": 3,
-        "d": {"e": {"h": {"i": {"j": 4}}}},
-        "g": 6,
-    }
-
-    overrides = [
-        combiner.Override(
-            when={"env": ["prod"]},
-            config={
-                "a": 10,
-                "c": 30,
-                "d": {"e": {"h": {"i": {"j": 40}}}},
-                "g": 60,
-            },
-        ),
-        combiner.Override(
-            when={"env": ["staging"]},
-            config={
-                "b": 200,
-                "c": 300,
-                "d": {"e": {"h": {"i": {"j": 400}}}},
-                "f": 500,
-            },
-        ),
-        combiner.Override(
-            when={"env": ["staging"], "region": ["us"]},
-            config={"f": 5000, "g": 6000},
-        ),
-    ]
-
-    result = combiner.generate_for_mapping(
-        config=combiner.Config(
-            dimensions={"env": ["prod", "staging"], "region": ["us"]},
-            default=default,
-            overrides=overrides,
-        ),
-        mapping=mapping,
-    )
-    assert result == expected
-
-
 @pytest.mark.parametrize(
     "mapping, override, expected",
     [
@@ -159,16 +75,18 @@ def test_build_config():
     raw_config = """
     [dimensions]
     env = ["dev", "staging", "prod"]
+    region = ["eu"]
 
     [default]
     foo = "bar"
 
     [[override]]
     when.env = ["dev", "staging"]
+    when.region = ["eu"]
     foo = "baz"
 
     [[override]]
-    when.env = "prod"
+    when.env = "dev"
     foo = "qux"
     """
 
@@ -176,89 +94,23 @@ def test_build_config():
     config = combiner.build_config(config_dict)
 
     assert config == combiner.Config(
-        dimensions={"env": ["dev", "staging", "prod"]},
+        dimensions={"env": ["dev", "staging", "prod"], "region": ["eu"]},
         default={"foo": "bar"},
         overrides=[
+            # Note: The order of the overrides is important: more specific overrides
+            # must be listed last.
             combiner.Override(
-                when={"env": ["dev", "staging"]},
-                config={"foo": "baz"},
+                when={"env": ["dev"]},
+                config={"foo": "qux"},
             ),
             combiner.Override(
-                when={"env": ["prod"]},
-                config={"foo": "qux"},
+                when={"env": ["dev", "staging"], "region": ["eu"]},
+                config={"foo": "baz"},
             ),
         ],
     )
 
 
-def test_generate_for_mapping__duplicate_overrides():
-    raw_config = """
-    [dimensions]
-    env = ["prod"]
-
-    [[override]]
-    when.env = "prod"
-    foo = "baz"
-
-    [[override]]
-    when.env = "prod"
-    foo = "qux"
-    """
-
-    config = combiner.build_config(toml.loads(raw_config))
-    with pytest.raises(exceptions.DuplicateError):
-        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():
     raw_config = """
     [dimensions]
@@ -287,42 +139,6 @@ def test_build_config__dimension_value_not_found_in_override():
         combiner.build_config(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 = ["prod", "dev"]
-
-            [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(
         """
@@ -393,3 +209,189 @@ def test_extract_keys():
 )
 def test_are_conditions_compatible(a, b, expected):
     assert combiner.are_conditions_compatible(a, b) == expected
+
+
+@pytest.mark.parametrize(
+    "mapping, expected",
+    [
+        (
+            {"env": "prod"},
+            {"foo": "bar"},
+        ),
+        (
+            {"env": "staging"},
+            {"foo": "baz"},
+        ),
+    ],
+)
+def test_generate_for_mapping__simple_case(mapping, expected):
+    config = combiner.build_config(
+        toml.loads(
+            """
+            [dimensions]
+            env = ["prod", "staging"]
+
+            [default]
+            foo = "bar"
+
+            [[override]]
+            when.env = "staging"
+            foo = "baz"
+            """,
+        )
+    )
+    result = combiner.generate_for_mapping(
+        config=config,
+        mapping=mapping,
+    )
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "mapping, expected",
+    [
+        pytest.param(
+            {"env": "dev"},
+            {
+                "a": 1,
+                "b": 2,
+                "c": 3,
+                "d": {"e": {"h": {"i": {"j": 4}}}},
+                "g": 6,
+            },
+            id="no_matches",
+        ),
+        pytest.param(
+            {"env": "prod"},
+            {
+                "a": 10,
+                "b": 2,
+                "c": 30,
+                "d": {"e": {"h": {"i": {"j": 40}}}},
+                "g": 60,
+            },
+            id="single_match",
+        ),
+        pytest.param(
+            {"env": "staging"},
+            {
+                "a": 1,
+                "b": 200,
+                "c": 300,
+                "d": {"e": {"h": {"i": {"j": 400}}}},
+                "f": 500,
+                "g": 6,
+            },
+            id="dont_override_if_match_is_more_specific",
+        ),
+    ],
+)
+def test_generate_for_mapping__complex_case(mapping: dict, expected: dict[str, int]):
+    default = {
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": {"e": {"h": {"i": {"j": 4}}}},
+        "g": 6,
+    }
+
+    overrides = [
+        combiner.Override(
+            when={"env": ["prod"]},
+            config={
+                "a": 10,
+                "c": 30,
+                "d": {"e": {"h": {"i": {"j": 40}}}},
+                "g": 60,
+            },
+        ),
+        combiner.Override(
+            when={"env": ["staging"]},
+            config={
+                "b": 200,
+                "c": 300,
+                "d": {"e": {"h": {"i": {"j": 400}}}},
+                "f": 500,
+            },
+        ),
+        combiner.Override(
+            when={"env": ["staging"], "region": ["us"]},
+            config={"f": 5000, "g": 6000},
+        ),
+    ]
+    config = combiner.Config(
+        dimensions={"env": ["prod", "staging"], "region": ["us"]},
+        default=default,
+        overrides=overrides,
+    )
+
+    result = combiner.generate_for_mapping(config=config, mapping=mapping)
+    assert result == expected
+
+
+def test_generate_for_mapping__duplicate_overrides():
+    raw_config = """
+    [dimensions]
+    env = ["prod"]
+
+    [[override]]
+    when.env = "prod"
+    foo = "baz"
+
+    [[override]]
+    when.env = "prod"
+    foo = "qux"
+    """
+
+    config = combiner.build_config(toml.loads(raw_config))
+    with pytest.raises(exceptions.IncompatibleOverrides):
+        combiner.generate_for_mapping(config=config, mapping={"env": "prod"})
+
+
+def test_generate_for_mapping__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_generate_for_mapping__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.IncompatibleOverrides) 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']}"
+    )

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

@@ -97,7 +97,7 @@ def are_conditions_compatible(
 ) -> bool:
     """
     `a` and `b` are dictionaries representing override conditions (`when`). Return
-    `True` if the conditions represented by `a` are compatible. Conditions are
+    `True` if the conditions represented by `a` are compatible with `b`. Conditions are
     compatible if one is stricly more specific than the other or if they're mutually
     exclusive.
     """
@@ -166,7 +166,7 @@ def generate_for_mapping(
     mapping: Mapping[str, str],
 ) -> Mapping[str, Any]:
     result = copy.deepcopy(config.default)
-    keys_to_conditions: dict[tuple[str, ...], list[dict[str, list[str]]]] = {}
+    keys_to_conditions: dict[tuple[str, ...], list[Mapping[str, list[str]]]] = {}
     # Apply each matching override
     for override in config.overrides:
         # Check if all dimension values in the override match
@@ -180,7 +180,7 @@ def generate_for_mapping(
 
                 for previous_condition in previous_conditions:
                     if not are_conditions_compatible(previous_condition, override.when):
-                        raise exceptions.DuplicateError(
+                        raise exceptions.IncompatibleOverrides(
                             id=override.when,
                             key=".".join(key),
                             other_override=previous_condition,

{toml_combine-0.6.0 → toml_combine-1.0.0}/toml_combine/exceptions.py

@@ -19,7 +19,7 @@ class TomlEncodeError(TomlCombineError):
     """Error while encoding configuration file."""
 
 
-class DuplicateError(TomlCombineError):
+class IncompatibleOverrides(TomlCombineError):
     """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}"""