configaroo 0.4.0__tar.gz → 0.4.2__tar.gz

{configaroo-0.4.0/src/configaroo.egg-info → configaroo-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: configaroo
-Version: 0.4.0
+Version: 0.4.2
 Summary: Bouncy handling of configuration files
 Author-email: Geir Arne Hjelle <geirarne@gmail.com>
 Maintainer-email: Geir Arne Hjelle <geirarne@gmail.com>

{configaroo-0.4.0 → configaroo-0.4.2}/pyproject.toml

@@ -79,7 +79,7 @@ python_version = "3.11"
 strict = true
 
 [tool.bumpver]
-current_version = "v0.4.0"
+current_version = "v0.4.2"
 version_pattern = "vMAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"

{configaroo-0.4.0 → configaroo-0.4.2}/src/configaroo/__init__.py

@@ -1,6 +1,10 @@
 """Bouncy configuration handling."""
 
-from configaroo.configuration import Configuration, print_configuration
+from configaroo.configuration import (
+    Configuration,
+    find_pyproject_toml,
+    print_configuration,
+)
 from configaroo.exceptions import (
     ConfigarooError,
     MissingEnvironmentVariableError,
@@ -12,7 +16,8 @@ __all__ = [
     "Configuration",
     "MissingEnvironmentVariableError",
     "UnsupportedLoaderError",
+    "find_pyproject_toml",
     "print_configuration",
 ]
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

{configaroo-0.4.0 → configaroo-0.4.2}/src/configaroo/configuration.py

@@ -6,6 +6,7 @@ import re
 from collections import UserDict
 from collections.abc import Callable
 from pathlib import Path
+from types import UnionType
 from typing import Any, Self, TypeVar
 
 from pydantic import BaseModel
@@ -99,30 +100,6 @@ class Configuration(UserDict[str, Any]):
         cls = type(self)
         return self | {prefix: cls(self.setdefault(prefix, {})).add(rest, value)}
 
-    def add_envs(self, envs: dict[str, str] | None = None, prefix: str = "") -> Self:
-        """Add environment variables to configuration.
-
-        If you don't specify which environment variables to read, you'll
-        automatically add any that matches a top-level value of the
-        configuration.
-        """
-        if envs is None:
-            # Automatically add top-level configuration items
-            envs = {
-                re.sub(r"\W", "_", key).upper(): key
-                for key, value in self.data.items()
-                if isinstance(value, str | int | float)
-            }
-
-        # Read environment variables
-        for env, key in envs.items():
-            env_key = f"{prefix}{env}"
-            if env_value := os.getenv(env_key):
-                self = self.add(key, env_value)  # noqa: PLW0642
-            elif key not in self:
-                raise MissingEnvironmentVariableError(env_key)
-        return self
-
     def parse_dynamic(
         self, extra: dict[str, Any] | None = None, *, _include_self: bool = True
     ) -> Self:
@@ -150,6 +127,60 @@ class Configuration(UserDict[str, Any]):
         # Continue parsing until no more replacements are made.
         return parsed.parse_dynamic(extra=extra, _include_self=_include_self)
 
+    def add_envs(self, envs: dict[str, str] | None = None, prefix: str = "") -> Self:
+        """Add environment variables to configuration.
+
+        If you don't specify which environment variables to read, you'll
+        automatically add any that matches a simple top-level value of the
+        configuration.
+        """
+        if envs is None:
+            # Automatically add top-level configuration items
+            envs = {
+                re.sub(r"\W", "_", key).upper(): key
+                for key, value in self.data.items()
+                if isinstance(value, str | int | float)
+            }
+
+        # Read environment variables
+        for env, key in envs.items():
+            env_key = f"{prefix}{env}"
+            if env_value := os.getenv(env_key):
+                self = self.add(key, env_value)  # noqa: PLW0642
+            elif key not in self:
+                raise MissingEnvironmentVariableError(env_key)
+        return self
+
+    def add_envs_from_model(
+        self,
+        model: type[BaseModel],
+        prefix: str = "",
+        types: type | UnionType = str | bool | int | float,
+    ) -> Self:
+        """Add environment variables to configuration based on the given model.
+
+        Top level string, bool, integer, and float fields from the model are
+        looked for among environment variables.
+        """
+
+        def _get_class_from_annotation(annotation: type) -> type:
+            """Unpack generic annotations and return the underlying class."""
+            return (
+                _get_class_from_annotation(annotation.__origin__)
+                if hasattr(annotation, "__origin__")
+                else annotation
+            )
+
+        envs = {
+            re.sub(r"\W", "_", key).upper(): key
+            for key, field in model.model_fields.items()
+            if (
+                field.annotation is not None
+                and issubclass(_get_class_from_annotation(field.annotation), types)
+            )
+        }
+        return self.add_envs(envs, prefix=prefix)
+
     def validate_model(self, model: type[BaseModel]) -> Self:
         """Validate the configuration against the given model."""
         model.model_validate(self.data)

{configaroo-0.4.0 → configaroo-0.4.2/src/configaroo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: configaroo
-Version: 0.4.0
+Version: 0.4.2
 Summary: Bouncy handling of configuration files
 Author-email: Geir Arne Hjelle <geirarne@gmail.com>
 Maintainer-email: Geir Arne Hjelle <geirarne@gmail.com>

{configaroo-0.4.0 → configaroo-0.4.2}/tests/test_environment.py

@@ -1,6 +1,7 @@
 """Test handling of environment variables."""
 
 import pytest
+from pydantic import BaseModel, SecretStr
 
 from configaroo import Configuration, MissingEnvironmentVariableError
 
@@ -25,6 +26,7 @@ def test_several_envs(config: Configuration, monkeypatch: pytest.MonkeyPatch) ->
     """Test that we can read several environment variables."""
     monkeypatch.setenv("WORD", "platypus")
     monkeypatch.setenv("NEW_PATH", "files/config.json")
+
     config_w_env = config.add_envs({"WORD": "nested.word", "NEW_PATH": "path"})
     assert config_w_env.nested.word == "platypus"
     assert config_w_env.path == "files/config.json"
@@ -48,6 +50,7 @@ def test_env_prefix(config: Configuration, monkeypatch: pytest.MonkeyPatch) -> N
     """Test that a common prefix can be used for environment variables."""
     monkeypatch.setenv("EXAMPLE_NUMBER", "14")
     monkeypatch.setenv("EXAMPLE_WORD", "platypus")
+
     config_w_env = config.add_envs(
         {"NUMBER": "number", "WORD": "nested.word"}, prefix="EXAMPLE_"
     )
@@ -61,9 +64,65 @@ def test_env_automatic(config: Configuration, monkeypatch: pytest.MonkeyPatch) -
     monkeypatch.setenv("WORD", "kangaroo")
     monkeypatch.setenv("A_B_D_KEY_", "works")
     monkeypatch.setenv("NESTED", "should not be replaced")
-    config_w_env = (config | {"A b@d-key!": ""}).add_envs()
 
+    config_w_env = (config | {"A b@d-key!": ""}).add_envs()
     assert config_w_env.number == "28"
     assert config_w_env.word == "kangaroo"
     assert config_w_env["A b@d-key!"] == "works"
     assert config_w_env.nested != "should not be replaced"
+
+
+def test_env_from_model(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test that environment variables can be found and set based on a model."""
+
+    class TestModel(BaseModel):
+        first_name: str
+        age: int
+        check: bool
+        scores: dict[str, int]
+
+    monkeypatch.setenv("TEST_FIRST_NAME", "Michael J.")
+    monkeypatch.setenv("TEST_AGE", "47")
+    monkeypatch.setenv("TEST_CHECK", "true")
+    monkeypatch.setenv("TEST_SCORES", '{"England": 1, "Spain": 0}')
+    monkeypatch.setenv("TEST_UNKNOWN", "Will be ignored")
+
+    config_w_env = Configuration().add_envs_from_model(TestModel, prefix="TEST_")
+    assert config_w_env.first_name == "Michael J."
+    assert config_w_env.age == "47"
+    assert config_w_env.check == "true"
+    assert "scores" not in config_w_env.data  # Complex types are ignored
+    assert "unknown" not in config_w_env.data  # Unspecified fields are ignored
+
+
+def test_env_from_model_w_custom_types(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test that custom types can be used when discovering env variables from models."""
+
+    class TestModel(BaseModel):
+        first_name: str
+        age: int
+        hush: SecretStr
+        countries: list[str]
+
+    monkeypatch.setenv("TEST_FIRST_NAME", "Michael J.")
+    monkeypatch.setenv("TEST_AGE", "47")
+    monkeypatch.setenv("TEST_HUSH", "hush-hush")
+    monkeypatch.setenv("TEST_COUNTRIES", "England Australia Norway Spain")
+
+    config_w_env = Configuration().add_envs_from_model(
+        TestModel, prefix="TEST_", types=str | SecretStr | list
+    )
+    assert config_w_env.first_name == "Michael J."
+    assert config_w_env.hush == "hush-hush"
+    assert config_w_env.countries.split() == ["England", "Australia", "Norway", "Spain"]
+    assert "age" not in config_w_env  # int is not specified as a type to include
+
+
+def test_env_from_model_raises_if_missing() -> None:
+    """Test that missing environment variables defined in a model raises an error."""
+
+    class TestModel(BaseModel):
+        nonexistent_env: str
+
+    with pytest.raises(MissingEnvironmentVariableError):
+        Configuration().add_envs_from_model(TestModel)