dynaconf 3.3.2__tar.gz → 3.3.3__tar.gz

{dynaconf-3.3.2 → dynaconf-3.3.3}/CHANGELOG.md

@@ -2,6 +2,31 @@ Changelog
 =========
 
 <!-- insertion marker -->
+## [3.3.3](https://github.com/dynaconf/dynaconf/releases/tag/3.3.3) - 2026-07-22
+
+### Bug Fixes
+
+
+- Fixed regression on lazy evaluation when using dynaboxify=False (#1429). By @pedro-psb.
+
+
+### Docs
+
+
+- Clarify the values of True, False and None for must_exist check (#1416). By @pedro-psb.
+
+
+### Chore
+
+
+- Fix netlify deploy command on publish workflow (#1420). By @pedro-psb.
+
+
+- Consolidate docs-publishing workflow for rolling-release (#1417). By @pedro-psb.
+
+
+- Simplify docs-only skip and include backport branches on main CI (#1415). By @pedro-psb.
+
 ## [3.3.2](https://github.com/dynaconf/dynaconf/releases/tag/3.3.2) - 2026-06-29
 
 ### Bug Fixes

{dynaconf-3.3.2 → dynaconf-3.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynaconf
-Version: 3.3.2
+Version: 3.3.3
 Summary: The dynamic configurator for your Python Project
 Author-email: Bruno Rocha <rochacbruno@gmail.com>
 License: MIT

{dynaconf-3.3.2 → dynaconf-3.3.3}/RELEASING.md

@@ -60,6 +60,7 @@ To do so, run `Actions → Publish → Run workflow` with the tag.
 - The publication uses [Trusted Publishing](https://docs.pypi.org/trusted-publishers/), which must be configured in PyPI.
 - The release requires content write permissions (push tags). A [Github App](https://docs.github.com/en/apps/overview)
   (DynaconfBot) was created to enable emitting short-lived tokens with well-scoped permission.
+- Docs publish can be triggered separately via `publish-docs.yml` workflow if required.
 
 ### Glossary
 

dynaconf-3.3.3/dynaconf/VERSION

@@ -0,0 +1 @@
+3.3.3

{dynaconf-3.3.2 → dynaconf-3.3.3}/dynaconf/base.py

@@ -31,6 +31,7 @@ from dynaconf.loaders import yaml_loader
 from dynaconf.loaders.base import SourceMetadata
 from dynaconf.nodes import DataDict
 from dynaconf.nodes import DataList
+from dynaconf.nodes import recursively_evaluate_lazy_format
 from dynaconf.strategies.filtering import PrefixFilter
 from dynaconf.utils import BANNER
 from dynaconf.utils import ensure_a_list
@@ -641,6 +642,8 @@ class Settings:
             self.execute_loaders(key=key)
 
         data = _get_with_default(parent or core.store, key, default)
+        if config.dynaboxify is False:
+            data = recursively_evaluate_lazy_format(data, self)
         if cast:
             data = apply_converter(cast, data, box_settings=self)
         return data

{dynaconf-3.3.2 → dynaconf-3.3.3}/dynaconf/nodes.py

@@ -757,6 +757,12 @@ def recursively_evaluate_lazy_format(value, settings):
             ]
         )
 
+    elif type(value) is dict:
+        value = {
+            k: recursively_evaluate_lazy_format(v, settings)
+            for k, v in value.items()
+        }
+
     return value
 
 

{dynaconf-3.3.2 → dynaconf-3.3.3}/dynaconf/validator.py

@@ -89,9 +89,14 @@ class Validator:
         # When the very first thing to be performed when passed.
         # if no env is passed to `when` it is inherited
 
-    `must_exist` is alias to `required` requirement. (executed after when)::
+    `must_exist` controls existence checking (executed after when)::
 
-       settings.get(value, empty) returns non empty
+        must_exist=True  — variable must be present; raises if absent
+        must_exist=False — variable must be absent; raises if present
+        must_exist=None  — no existence rule (default); absent variables
+                           skip all further checks on that name
+
+    `required` is an alias for `must_exist`.
 
     condition is a callable to be executed and return boolean::
 
@@ -214,11 +219,11 @@ class Validator:
         return _repr
 
     @property
-    def required(self) -> bool:
-        return bool(self.must_exist)
+    def required(self) -> bool | None:
+        return self.must_exist
 
     @required.setter
-    def required(self, value: bool):
+    def required(self, value: bool | None):
         self.must_exist = value
 
     @property
@@ -387,21 +392,32 @@ class Validator:
             else:
                 value = settings.get(name, default_value)
 
-            # is name required but not exists?
-            if self.must_exist is True and value is empty:
-                _message = self.messages["must_exist_true"].format(
-                    name=name, env=env
-                )
-                raise ValidationError(_message, details=[(self, _message)])
-
-            if self.must_exist is False and value is not empty:
-                _message = self.messages["must_exist_false"].format(
-                    name=name, env=env
+            # Existence checks
+            if self.must_exist is None:  # must_exist is unset
+                if value is empty:
+                    continue  #  no further checks required, as there is nothing to check
+                else:
+                    pass  # proceed with further checks
+            elif self.must_exist is True:
+                if value is empty:
+                    _message = self.messages["must_exist_true"].format(
+                        name=name, env=env
+                    )
+                    raise ValidationError(_message, details=[(self, _message)])
+                else:
+                    pass
+            elif self.must_exist is False:
+                if value is empty:
+                    continue  # value absent as required — nothing further to check
+                else:
+                    _message = self.messages["must_exist_false"].format(
+                        name=name, env=env
+                    )
+                    raise ValidationError(_message, details=[(self, _message)])
+            else:
+                raise ValueError(
+                    f"must_exist must be True, False, or None, got {self.must_exist!r}"
                 )
-                raise ValidationError(_message, details=[(self, _message)])
-
-            if self.must_exist in (False, None) and value is empty:
-                continue
 
             # value or default value already set
             # by settings.setdefault above

{dynaconf-3.3.2 → dynaconf-3.3.3}/dynaconf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynaconf
-Version: 3.3.2
+Version: 3.3.3
 Summary: The dynamic configurator for your Python Project
 Author-email: Bruno Rocha <rochacbruno@gmail.com>
 License: MIT

{dynaconf-3.3.2 → dynaconf-3.3.3}/pyproject.toml

@@ -208,7 +208,7 @@ ignore_missing_imports = true
 # ===========
 
 [tool.bumpversion]
-current_version = "3.3.2"
+current_version = "3.3.3"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.

{dynaconf-3.3.2 → dynaconf-3.3.3}/tests/test_utils.py

@@ -455,85 +455,104 @@ def test_upperfy():
     assert upperfy("foo_BAR") == "FOO_BAR"
 
 
-def test_lazy_format_class():
-    value = Lazy("{this[FOO]}/bar")
-    settings = {"FOO": "foo"}
-    assert value(settings) == "foo/bar"
-    assert str(value) == value.value
-    assert repr(value) == f"'@{value.formatter} {value.value}'"
-
-
-def test_evaluate_lazy_format_decorator(settings):
-    class Settings:
-        FOO = "foo"
-        AUTO_CAST_FOR_DYNACONF = True
-
-        @evaluate_lazy_format
-        def get(self, key, default=None):
-            if key.endswith("_FOR_DYNACONF"):
-                return getattr(self, key)
-            return parse_conf_data("@format {this.FOO}/bar", box_settings=self)
+class TestLazyInternal:
+    def test_format_class(self):
+        value = Lazy("{this[FOO]}/bar")
+        settings = {"FOO": "foo"}
+        assert value(settings) == "foo/bar"
+        assert str(value) == value.value
+        assert repr(value) == f"'@{value.formatter} {value.value}'"
+
+    def test_format_class_jinja(self):
+        value = Lazy(
+            "{{this['FOO']}}/bar", formatter=Formatters.jinja_formatter
+        )
+        settings = {"FOO": "foo"}
+        assert value(settings) == "foo/bar"
 
-        def __contains__(self, key):
-            value = getattr(self, key, missing)
-            if value is missing:
-                return False
-            return True
+    def test_custom_function_formatter(self):
+        def custom_formatter(value, **context):
+            return f"custom:{value}"
 
-    settings = Settings()
-    assert settings.get("foo") == "foo/bar"
+        lazy_val = Lazy("test", formatter=custom_formatter)
+        assert lazy_val({}) == "custom:test"
 
+    def test_json_serializable(self):
+        value = Lazy("{this[FOO]}/bar")
+        assert (
+            json.dumps({"val": value}, cls=DynaconfEncoder)
+            == '{"val": "@format {this[FOO]}/bar"}'
+        )
 
-def test_lazy_format_on_settings(settings):
-    os.environ["ENV_THING"] = "LazyFormat"
-    settings.set("set_1", "really")
-    settings.set("lazy", "@format {env[ENV_THING]}/{this[set_1]}/{this.SET_2}")
-    settings.set("set_2", "works")
 
-    assert settings.LAZY == settings.get("lazy") == "LazyFormat/really/works"
+class TestLazyDecorator:
+    def _make_settings(self, template):
+        class Settings:
+            FOO = "foo"
+            AUTO_CAST_FOR_DYNACONF = True
 
+            @evaluate_lazy_format
+            def get(self, key, default=None):
+                if key.endswith("_FOR_DYNACONF"):
+                    return getattr(self, key)
+                return parse_conf_data(template, box_settings=self)
 
-def test_lazy_format_class_jinja():
-    value = Lazy("{{this['FOO']}}/bar", formatter=Formatters.jinja_formatter)
-    settings = {"FOO": "foo"}
-    assert value(settings) == "foo/bar"
+            def __contains__(self, key):
+                value = getattr(self, key, missing)
+                if value is missing:
+                    return False
+                return True
 
+        return Settings()
 
-def test_evaluate_lazy_format_decorator_jinja(settings):
-    class Settings:
-        FOO = "foo"
+    def test_format(self):
+        settings = self._make_settings("@format {this.FOO}/bar")
+        assert settings.get("foo") == "foo/bar"
 
-        AUTO_CAST_FOR_DYNACONF = True
+    def test_jinja(self):
+        settings = self._make_settings("@jinja {{this.FOO}}/bar")
+        assert settings.get("foo") == "foo/bar"
 
-        @evaluate_lazy_format
-        def get(self, key, default=None):
-            if key.endswith("_FOR_DYNACONF"):
-                return getattr(self, key)
-            return parse_conf_data(
-                "@jinja {{this.FOO}}/bar", box_settings=settings
-            )
 
-    settings = Settings()
-    assert settings.get("foo") == "foo/bar"
+class TestLazyUsage:
+    @pytest.fixture(params=[True, False], ids=["dynaboxify", "no_dynaboxify"])
+    def settings(self, request):
+        return Dynaconf(dynaboxify=request.param)
 
+    def test_format(self, settings):
+        os.environ["ENV_THING"] = "LazyFormat"
+        settings.set("set_1", "really")
+        settings.set(
+            "lazy", "@format {env[ENV_THING]}/{this[set_1]}/{this.SET_2}"
+        )
+        settings.set("set_2", "works")
 
-def test_lazy_format_on_settings_jinja(settings):
-    os.environ["ENV_THING"] = "LazyFormat"
-    settings.set("set_1", "really")
-    settings.set(
-        "lazy", "@jinja {{env.ENV_THING}}/{{this['set_1']}}/{{this.SET_2}}"
-    )
-    settings.set("set_2", "works")
+        assert (
+            settings.LAZY == settings.get("lazy") == "LazyFormat/really/works"
+        )
 
-    assert settings.LAZY == settings.get("lazy") == "LazyFormat/really/works"
+    def test_format_nested_dict(self, settings):
+        settings.set("BASE_VALUE", "hello")
+        settings.set("NESTED", {"inner": "@format {this[BASE_VALUE]}/world"})
+        assert settings.get("NESTED")["inner"] == "hello/world"
+
+    def test_jinja(self, settings):
+        os.environ["ENV_THING"] = "LazyFormat"
+        settings.set("set_1", "really")
+        settings.set(
+            "lazy",
+            "@jinja {{env.ENV_THING}}/{{this['set_1']}}/{{this.SET_2}}",
+        )
+        settings.set("set_2", "works")
 
+        assert (
+            settings.LAZY == settings.get("lazy") == "LazyFormat/really/works"
+        )
 
-def test_lazy_format_is_json_serializable():
-    value = Lazy("{this[FOO]}/bar")
-    assert (
-        json.dumps({"val": value}, cls=DynaconfEncoder)
-        == '{"val": "@format {this[FOO]}/bar"}'
-    )
+    def test_jinja_nested_dict(self, settings):
+        settings.set("BASE_VALUE", "hello")
+        settings.set("NESTED", {"inner": "@jinja {{this.BASE_VALUE}}/world"})
+        assert settings.get("NESTED")["inner"] == "hello/world"
 
 
 def test_try_to_encode():
@@ -1365,19 +1384,6 @@ def test_read_file_os_error(tmp_path, monkeypatch):
             settings.SECRET
 
 
-def test_lazy_with_custom_function_formatter():
-    """Test Lazy with custom function (not BaseFormatter)"""
-    from dynaconf.utils.parse_conf import Lazy
-
-    def custom_formatter(value, **context):
-        return f"custom:{value}"
-
-    lazy_val = Lazy("test", formatter=custom_formatter)
-    settings = {}
-    result = lazy_val(settings)
-    assert result == "custom:test"
-
-
 def test_safe_json_parse_extract_objects(settings):
     """Test _safe_json_parse with extract_json_objects"""
     # Test case where extract_json_objects finds valid JSON

dynaconf-3.3.2/dynaconf/VERSION

@@ -1 +0,0 @@
-3.3.2