dynaconf 3.2.7__tar.gz → 3.2.9__tar.gz

{dynaconf-3.2.7 → dynaconf-3.2.9}/CHANGELOG.md

@@ -2,6 +2,22 @@ Changelog
 =========
 
 <!-- insertion marker -->
+## [3.2.9](https://github.com/dynaconf/dynaconf/releases/tag/3.2.9) - 2025-02-16
+
+## [3.2.8](https://github.com/dynaconf/dynaconf/releases/tag/3.2.8) - 2025-02-16
+
+### Bug Fixes
+
+- Parse data type on merge with comma separated value. *By Bruno Rocha*.
+
+### Features
+
+- Add CLI command `debug-info` (#1251). *By Bruno Rocha*.
+- Add support for decorated hooks on settings files (#1246). *By Bruno Rocha*.
+- Add VAULT_TOKEN_RENEW_FOR_DYNACONF config/code (#1094) (#1242). *By Pedro Brochado*.
+- populate_obj takes convert_to_dict (#1237). *By Bruno Rocha*.
+- add VAULT_TOKEN_RENEW. *By Bruno Rocha*.
+
 ## [3.2.7](https://github.com/dynaconf/dynaconf/releases/tag/3.2.7) - 2025-01-21
 
 ### Bug Fixes

{dynaconf-3.2.7 → dynaconf-3.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dynaconf
-Version: 3.2.7
+Version: 3.2.9
 Summary: The dynamic configurator for your Python Project
 Home-page: https://github.com/dynaconf/dynaconf
 Author: Bruno Rocha

dynaconf-3.2.9/dynaconf/VERSION

@@ -0,0 +1 @@
+3.2.9

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/__init__.py

@@ -4,6 +4,7 @@ from dynaconf.base import LazySettings
 from dynaconf.constants import DEFAULT_SETTINGS_FILES
 from dynaconf.contrib import DjangoDynaconf
 from dynaconf.contrib import FlaskDynaconf
+from dynaconf.hooking import post_hook
 from dynaconf.utils.inspect import get_history
 from dynaconf.utils.inspect import inspect_settings
 from dynaconf.utils.parse_conf import add_converter
@@ -39,4 +40,5 @@ __all__ = [
     "get_history",
     "DynaconfFormatError",
     "DynaconfParseError",
+    "post_hook",
 ]

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/base.py

@@ -1161,6 +1161,10 @@ class Settings:
         """Clean end Execute all loaders"""
         self.clean()
         self._loaded_hooks.clear()
+        for hook in self._post_hooks:
+            with suppress(AttributeError, TypeError):
+                hook._called = False
+
         self.execute_loaders(env, silent)
 
     def execute_loaders(
@@ -1217,7 +1221,13 @@ class Settings:
                 last_loader.load(self, env, silent, key)
 
     def load_file(
-        self, path=None, env=None, silent=True, key=None, validate=empty
+        self,
+        path=None,
+        env=None,
+        silent=True,
+        key=None,
+        validate=empty,
+        run_hooks=True,
     ):
         """Programmatically load files from ``path``.
 
@@ -1226,82 +1236,95 @@ class Settings:
         - Directory of the last loaded file
         - CWD
 
-        :param path: A single filename or a file list
+        :param path: A single filename, a glob or a file list
         :param env: Which env to load from file (default current_env)
         :param silent: Should raise errors?
         :param key: Load a single key?
         :param validate: Should trigger validation?
+        :param run_hooks: Should run collected hooks?
         """
+        files = ensure_a_list(path)
+        if not files:  # a glob pattern may return empty
+            return
+
         if validate is empty:
             validate = self.get("VALIDATE_ON_UPDATE_FOR_DYNACONF")
 
         env = (env or self.current_env).upper()
 
-        files = ensure_a_list(path)
-        if files:
-            # Using inspect take the filename and line number of the caller
-            # to be used in the source_metadata
-            frame = inspect.currentframe()
-            caller = inspect.getouterframes(frame)[1]
-            already_loaded = set()
-            for _filename in files:
+        # Using inspect take the filename and line number of the caller
+        # to be used in the source_metadata
+        frame = inspect.currentframe()
+        caller = inspect.getouterframes(frame)[1]
+
+        already_loaded = set()
+        for _filename in files:
+            # load_file() will handle validation later
+            with suppress(ValidationError):
+                source_metadata = SourceMetadata(
+                    loader=f"load_file@{caller.filename}:{caller.lineno}",
+                    identifier=_filename,
+                    env=env,
+                )
+                if py_loader.try_to_load_from_py_module_name(
+                    obj=self,
+                    name=_filename,
+                    silent=True,
+                    identifier=source_metadata,
+                ):
+                    # if it was possible to load from module name
+                    # continue the loop.
+                    continue
+
+            root_dir = str(self._root_path or os.getcwd())
+
+            # Issue #494
+            if (
+                isinstance(_filename, Path)
+                and str(_filename.parent) in root_dir
+            ):  # pragma: no cover
+                filepath = str(_filename)
+            else:
+                filepath = os.path.join(root_dir, str(_filename))
+
+            paths = [p for p in sorted(glob(filepath)) if ".local." not in p]
+            local_paths = [p for p in sorted(glob(filepath)) if ".local." in p]
+
+            # Handle possible *.globs sorted alphanumeric
+            for path in paths + local_paths:
+                if path in already_loaded:  # pragma: no cover
+                    continue
+
                 # load_file() will handle validation later
                 with suppress(ValidationError):
                     source_metadata = SourceMetadata(
                         loader=f"load_file@{caller.filename}:{caller.lineno}",
-                        identifier=_filename,
+                        identifier=path,
                         env=env,
                     )
-                    if py_loader.try_to_load_from_py_module_name(
+                    settings_loader(
                         obj=self,
-                        name=_filename,
-                        silent=True,
+                        env=env,
+                        silent=silent,
+                        key=key,
+                        filename=path,
+                        validate=validate,
                         identifier=source_metadata,
-                    ):
-                        # if it was possible to load from module name
-                        # continue the loop.
-                        continue
-
-                root_dir = str(self._root_path or os.getcwd())
-
-                # Issue #494
-                if (
-                    isinstance(_filename, Path)
-                    and str(_filename.parent) in root_dir
-                ):  # pragma: no cover
-                    filepath = str(_filename)
-                else:
-                    filepath = os.path.join(root_dir, str(_filename))
-
-                paths = [
-                    p for p in sorted(glob(filepath)) if ".local." not in p
-                ]
-                local_paths = [
-                    p for p in sorted(glob(filepath)) if ".local." in p
-                ]
-
-                # Handle possible *.globs sorted alphanumeric
-                for path in paths + local_paths:
-                    if path in already_loaded:  # pragma: no cover
-                        continue
-
-                    # load_file() will handle validation later
-                    with suppress(ValidationError):
-                        source_metadata = SourceMetadata(
-                            loader=f"load_file@{caller.filename}:{caller.lineno}",
-                            identifier=path,
-                            env=env,
-                        )
-                        settings_loader(
-                            obj=self,
-                            env=env,
-                            silent=silent,
-                            key=key,
-                            filename=path,
-                            validate=validate,
-                            identifier=source_metadata,
-                        )
-                        already_loaded.add(path)
+                    )
+                    already_loaded.add(path)
+
+        if run_hooks:
+            # this will call any collected hook that was not called yet
+            execute_instance_hooks(
+                self,
+                "post",
+                [
+                    _hook
+                    for _hook in self._post_hooks
+                    if getattr(_hook, "_dynaconf_hook", False) is True
+                    and not getattr(_hook, "_called", False)
+                ],
+            )
 
         # handle param `validate`
         if validate is True:
@@ -1385,22 +1408,33 @@ class Settings:
             value = self.get_fresh(key)
             return value is True or value in true_values
 
-    def populate_obj(self, obj, keys=None, ignore=None, internal=False):
+    def populate_obj(
+        self,
+        obj,
+        keys=None,
+        ignore=None,
+        internal=False,
+        convert_to_dict=False,
+    ):
         """Given the `obj` populate it using self.store items.
 
         :param obj: An object to be populated, a class instance.
         :param keys: A list of keys to be included.
         :param ignore: A list of keys to be excluded.
+        :param internal: Include internal keys.
+        :param convert_to_dict: Convert the settings to a pure dict (no Box)
+         before populating.
         """
+        data = self.to_dict(internal=internal) if convert_to_dict else self
         keys = keys or self.keys()
         for key in keys:
+            key = upperfy(key)
             if not internal:
                 if key in UPPER_DEFAULT_SETTINGS:
                     continue
-            key = upperfy(key)
             if ignore and key in ignore:
                 continue
-            value = self.get(key, empty)
+            value = data.get(key, empty)
             if value is not empty:
                 setattr(obj, key, value)
 

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/cli.py

@@ -28,6 +28,7 @@ from dynaconf.utils.inspect import EnvNotFoundError
 from dynaconf.utils.inspect import inspect_settings
 from dynaconf.utils.inspect import KeyNotFoundError
 from dynaconf.utils.inspect import OutputFormatError
+from dynaconf.utils.inspect import print_debug_info
 from dynaconf.utils.parse_conf import parse_conf_data
 from dynaconf.utils.parse_conf import unparse_conf_data
 from dynaconf.validator import ValidationError
@@ -54,7 +55,12 @@ def set_settings(ctx, instance=None):
 
     settings = None
 
-    _echo_enabled = ctx.invoked_subcommand not in ["get", "inspect", None]
+    _echo_enabled = ctx.invoked_subcommand not in [
+        "get",
+        "inspect",
+        "debug-info",
+        None,
+    ]
     if "--json" in click.get_os_args():
         _echo_enabled = False
 
@@ -857,7 +863,10 @@ INSPECT_FORMATS = list(builtin_dumpers.keys())
 @main.command()
 @click.option("--key", "-k", help="Filters result by key.")
 @click.option(
-    "--env", "-e", help="Filters result by environment.", default=None
+    "--env",
+    "-e",
+    help="Filters result by environment on --report-mode=inspect.",
+    default=None,
 )
 @click.option(
     "--format",
@@ -870,7 +879,7 @@ INSPECT_FORMATS = list(builtin_dumpers.keys())
     "--old-first",
     "new_first",
     "-s",
-    help="Invert history sorting to 'old-first'",
+    help="Invert history sorting to 'old-first' on --report-mode=inspect.",
     default=True,
     is_flag=True,
 )
@@ -880,7 +889,7 @@ INSPECT_FORMATS = list(builtin_dumpers.keys())
     "-n",
     default=None,
     type=int,
-    help="Limits how many history entries are shown.",
+    help="Limits how many history entries are shown on --report-mode=inspect.",
 )
 @click.option(
     "--all",
@@ -890,28 +899,54 @@ INSPECT_FORMATS = list(builtin_dumpers.keys())
     is_flag=True,
     help="Show dynaconf internal settings?",
 )
+@click.option(
+    "--report-mode",
+    "report_mode",
+    "-m",
+    default="inspect",
+    type=click.Choice(["inspect", "debug"]),
+)
+@click.option(
+    "-v",
+    "--verbose",
+    count=True,
+    help="Increase verbosity of the output on --report-mode=debug.",
+)
 def inspect(
-    key, env, format, new_first, history_limit, _all
+    key, env, format, new_first, history_limit, _all, report_mode, verbose
 ):  # pragma: no cover
     """
     Inspect the loading history of the given settings instance.
 
     Filters by key and environment, otherwise shows all.
     """
-    try:
-        inspect_settings(
+
+    if report_mode == "debug":
+        print_debug_info(
             settings,
-            key=key,
-            env=env or None,
             dumper=format,
-            new_first=new_first,
-            include_internal=_all,
-            history_limit=history_limit,
-            print_report=True,
+            verbosity=verbose,
+            key=key,
         )
         click.echo()
-    except (KeyNotFoundError, EnvNotFoundError, OutputFormatError) as err:
-        click.echo(err)
+    elif report_mode == "inspect":
+        try:
+            inspect_settings(
+                settings,
+                key=key,
+                env=env or None,
+                dumper=format,
+                new_first=new_first,
+                include_internal=_all,
+                history_limit=history_limit,
+                print_report=True,
+            )
+            click.echo()
+        except (KeyNotFoundError, EnvNotFoundError, OutputFormatError) as err:
+            click.echo(err)
+            sys.exit(1)
+    else:
+        click.echo("Invalid report mode")
         sys.exit(1)
 
 

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/default_settings.py

@@ -191,6 +191,7 @@ VAULT_ROLE_ID_FOR_DYNACONF = get("VAULT_ROLE_ID_FOR_DYNACONF", None)
 VAULT_SECRET_ID_FOR_DYNACONF = get("VAULT_SECRET_ID_FOR_DYNACONF", None)
 VAULT_USERNAME_FOR_DYNACONF = get("VAULT_USERNAME_FOR_DYNACONF", None)
 VAULT_PASSWORD_FOR_DYNACONF = get("VAULT_PASSWORD_FOR_DYNACONF", None)
+VAULT_TOKEN_RENEW_FOR_DYNACONF = get("VAULT_TOKEN_RENEW_FOR_DYNACONF", False)
 
 # Only core loaders defined on this list will be invoked
 core_loaders = ["YAML", "TOML", "INI", "JSON", "PY"]

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/hooking.py

@@ -18,6 +18,7 @@ __all__ = [
     "MethodValue",
     "Action",
     "HookableSettings",
+    "post_hook",
 ]
 
 
@@ -341,3 +342,34 @@ class TempSettingsHolder:
         else:
             self._initialize()
             setattr(self._settings, attr, value)
+
+
+def post_hook(function: Callable) -> Callable:
+    """This decorator marks a function as a post hook.
+    This works by adding the _dynaconf_hook attribute to the function,
+    then the python loader, when reading the module, will look for
+    this attribute and register the function as a post_hook for the settings.
+
+    e.g: On a settings file with .py extension:
+
+    from dynaconf import post_hook
+    @post_hook
+    def set_log_handlers(settings) -> dict:
+        data = {}  # data to be merged into settings
+
+        # conditionals
+        if (logging := settings.get('LOGGING')) is not None:
+            # do something with logging
+            # add it back to data
+            data['LOGGING'] = logging
+        return data
+    """
+    try:
+        function._dynaconf_hook = True  # type: ignore
+        function._called = False  # type: ignore
+        function._dynaconf_hook_source = function.__module__  # type: ignore
+    except (AttributeError, TypeError):
+        raise TypeError(
+            "post_hook decorator must be applied to a function or method."
+        )
+    return function

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/loaders/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import importlib
 import os
+from contextlib import suppress
 from typing import Callable
 from typing import TYPE_CHECKING
 
@@ -146,6 +147,22 @@ def execute_module_hooks(
 execute_hooks = execute_module_hooks
 
 
+def _get_unique_hook_id(hook_func, hook_source):
+    """get unique identifier for a hook function.
+    in most of cases this will be the function name@source_file
+    however, if the function is a lambda, it will be a hash of the code object.
+    because lambda functions are not hashable itself and we can't rely on its id.
+    """
+    hook_unique_id = hook_func.__name__
+    if hook_unique_id == "<lambda>":
+        frame_info = getattr(hook_func, "__code__", None)
+        if frame_info:
+            hook_unique_id = f"lambda_{hash(frame_info.co_code)}"
+        else:
+            hook_unique_id = f"lambda_{id(hook_func)}"
+    return f"{hook_unique_id}@{hook_source}"
+
+
 def _run_hook_module(hook_type, hook_module, obj, key=""):
     """
     Run a hook function from hook_module.
@@ -153,11 +170,6 @@ def _run_hook_module(hook_type, hook_module, obj, key=""):
     Given a @hook_type, a @hook_module and a settings @obj, load the function
     and execute it if found.
     """
-    hook_source = hook_module.__file__
-
-    # check if already loaded
-    if hook_type in obj._loaded_hooks.get(hook_source, {}):
-        return
 
     # check errors
     if hook_module and getattr(hook_module, "_error", False):
@@ -165,9 +177,12 @@ def _run_hook_module(hook_type, hook_module, obj, key=""):
             raise hook_module._error
 
     # execute hook
+    hook_source = hook_module.__file__
     hook_func = getattr(hook_module, hook_type, None)
     if hook_func:
-        _run_hook_function(obj, hook_type, hook_func, hook_source, key)
+        identifier = _get_unique_hook_id(hook_func, hook_source)
+        if hook_type not in obj._loaded_hooks.get(identifier, {}):
+            _run_hook_function(obj, hook_type, hook_func, hook_source, key)
 
 
 def _run_hook_function(
@@ -183,15 +198,27 @@ def _run_hook_function(
     It execute @hook_func, update the results into settings @obj and
     add it to _loaded_hook registry ([@hook_source][@hook_type])
     """
+    # if the function has a _dynaconf_hook_source attribute set
+    # hook_source to it
+    hook_source = getattr(hook_func, "_dynaconf_hook_source", hook_source)
+
     # optional settings argument
     try:
         hook_dict = hook_func(obj.dynaconf.clone())
     except TypeError:
         hook_dict = hook_func()
 
-    # update obj settings
+    # mark as called so executors such as `load_file` can avoid calling it again
+    with suppress(AttributeError, TypeError):
+        # callable may not be writable, the caveat is that it will be called again in case of reload
+        # however, this must not be a problem since the function should be idempotent
+        # and documentation warns about this behavior.
+        hook_func._called = True
+
+    identifier = _get_unique_hook_id(hook_func, hook_source)
+
     if hook_dict:
-        identifier = f"{hook_func.__name__}@{hook_source}"
+        # update obj settings
         merge = hook_dict.pop(
             "dynaconf_merge", hook_dict.pop("DYNACONF_MERGE", False)
         )
@@ -212,7 +239,7 @@ def _run_hook_function(
             )
 
     # add to registry
-    obj._loaded_hooks[hook_source][hook_type] = hook_dict
+    obj._loaded_hooks[identifier][hook_type] = hook_dict
 
 
 def settings_loader(

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/loaders/py_loader.py

@@ -57,13 +57,13 @@ def load_from_python_object(
         file_merge = getattr(mod, "DYNACONF_MERGE", empty)
 
     for setting in dir(mod):
+        setting_value = getattr(mod, setting)
         # A setting var in a Python file should start with upper case
         # valid: A_value=1, ABC_value=3 A_BBB__default=1
         # invalid: a_value=1, MyValue=3
         # This is to avoid loading functions, classes and built-ins
         if setting.split("__")[0].isupper():
             if key is None or key == setting:
-                setting_value = getattr(mod, setting)
                 obj.set(
                     setting,
                     setting_value,
@@ -71,6 +71,14 @@ def load_from_python_object(
                     merge=file_merge,
                     validate=validate,
                 )
+        # if setting is a post_hook function it will be a callable with
+        # the _dynaconf_hook attribute set to True
+        # then we want to add it to the post_hooks list on the obj.
+        elif callable(setting_value) and getattr(
+            setting_value, "_dynaconf_hook", False
+        ):
+            if setting_value not in obj._post_hooks:
+                obj._post_hooks.append(setting_value)
 
     obj._loaded_py_modules.append(mod.__name__)
     obj._loaded_files.append(mod.__file__)

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/loaders/vault_loader.py

@@ -62,6 +62,10 @@ def get_client(obj):
             credentials.token,
             role=obj.VAULT_AUTH_ROLE_FOR_DYNACONF,
         )
+
+    if obj.VAULT_TOKEN_RENEW_FOR_DYNACONF:
+        client.auth.token.renew_self()
+
     assert client.is_authenticated(), (
         "Vault authentication error: is VAULT_TOKEN_FOR_DYNACONF or "
         "VAULT_ROLE_ID_FOR_DYNACONF defined?"

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/utils/inspect.py

@@ -4,7 +4,10 @@ from __future__ import annotations
 
 import json
 import sys
+from contextlib import suppress
 from functools import partial
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version
 from pathlib import PosixPath
 from typing import Any
 from typing import Callable
@@ -28,11 +31,21 @@ if TYPE_CHECKING:  # pragma: no cover
 
 # Dumpers config
 
-json_pretty = partial(json.dump, indent=2)
-json_compact = json.dump
+json_pretty = partial(json.dump, indent=2, default=str)
+json_compact = partial(json.dump, default=str)
+
+
+def yaml_dumper_with_defaults(data: dict, text_stream: TextIO) -> None:
+    """Easier way to get YAML dumper to handle unseralizable types"""
+    yaml = YAML()
+    # let JSON handle unserializable types and then load it back
+    data = json.loads(json.dumps(data, default=str))
+    yaml.default_flow_style = False
+    yaml.dump(data, text_stream)
+
 
 builtin_dumpers = {
-    "yaml": YAML().dump,
+    "yaml": yaml_dumper_with_defaults,
     "json": json_pretty,
     "json-compact": json_compact,
 }
@@ -312,7 +325,7 @@ def _get_data_by_key(
     key_dotted_path: str,
     default: Any = None,
     sep="__",
-):
+) -> Any:
     """
     Returns value found in data[key] using dot-path str (e.g, "path.to.key").
     Raises KeyError if not found
@@ -344,3 +357,127 @@ def _get_data_by_key(
         if not default:
             raise KeyError(f"Path not found in data: {key_dotted_path!r}")
         return default
+
+
+def get_debug_info(
+    settings: Settings | LazySettings,
+    verbosity: int = 0,
+    key: str | None = None,
+) -> dict:
+    """Returns a dict with debug info about the settings object"""
+
+    if key:
+        verbosity = 2
+
+    def filter_by_key(data: dict) -> dict:
+        """If key is not None, filter dict keeping only the key"""
+        if key:
+            try:
+                return {key: _get_data_by_key(data, key)}
+            except KeyError:
+                return {}
+        return data
+
+    def build_loading_history() -> list[dict]:
+        _data = []
+        for (
+            source_metadata,
+            source_data,
+        ) in settings._loaded_by_loaders.items():
+            _real_data = filter_by_key(source_data)
+            if verbosity == 0:
+                _data.append(
+                    {
+                        "loader": source_metadata.loader,
+                        "identifier": source_metadata.identifier,
+                        "data": len(_real_data),
+                    }
+                )
+            elif verbosity == 1:
+                _data.append(
+                    {
+                        "loader": source_metadata.loader,
+                        "identifier": source_metadata.identifier,
+                        "data": list(_real_data.keys()),
+                    }
+                )
+            else:
+                _data.append(
+                    {
+                        "loader": source_metadata.loader,
+                        "identifier": source_metadata.identifier,
+                        "data": _real_data,
+                    }
+                )
+        return _data
+
+    def build_loaded_hooks():
+        _data = []
+        for hook, hook_data in settings._loaded_hooks.items():
+            _real_data = filter_by_key(hook_data.get("post", {}))
+            if verbosity == 0:
+                _data.append(
+                    {
+                        "hook": str(hook),
+                        "data": len(_real_data),
+                    }
+                )
+            elif verbosity == 1:
+                _data.append(
+                    {
+                        "hook": str(hook),
+                        "data": list(_real_data.keys()),
+                    }
+                )
+            else:
+                _data.append(
+                    {
+                        "hook": str(hook),
+                        "data": _real_data,
+                    }
+                )
+        return _data
+
+    data = {
+        "versions": {
+            "dynaconf": version("dynaconf"),
+        },
+        "root_path": settings._root_path,
+        "validators": [str(v) for v in settings.validators],
+        "core_loaders": settings._loaders,
+        "loaded_files": settings._loaded_files,
+        "history": build_loading_history(),
+        "post_hooks": [str(h) for h in settings._post_hooks],
+        "loaded_hooks": build_loaded_hooks(),
+    }
+    for name in ["django", "flask", "fastapi", "starlette"]:
+        with suppress(PackageNotFoundError):
+            data["versions"][name] = version(name)
+
+    if settings.get("ENVIRONMENTS_FOR_DYNACONF"):
+        data["environments"] = list(settings.get("ENVIRONMENTS_FOR_DYNACONF"))
+        data["loaded_envs"] = settings._loaded_envs
+
+    if key:
+        data["current"] = {key: settings.get(key)}
+    return data
+
+
+def print_debug_info(
+    settings: Settings | LazySettings,
+    *,
+    dumper: DumperPreset | DumperType | None = None,
+    verbosity: int = 0,
+    key: str | None = None,
+):
+    """Calls dumper with settings debug info"""
+    dumper = dumper or "yaml"
+    if isinstance(dumper, str):
+        dumper = builtin_dumpers.get(dumper)
+        if dumper is None:
+            raise OutputFormatError(
+                f"The desired format is not available: {dumper!r}"
+            )
+
+    data = get_debug_info(settings, verbosity, key)
+    dumper(data, sys.stdout)

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf/utils/parse_conf.py

@@ -133,7 +133,12 @@ class Merge(MetaValue):
                     }
                 elif "," in self.value:
                     # @merge foo,bar
-                    self.value = self.value.split(",")
+                    self.value = [
+                        parse_conf_data(
+                            v, tomlfy=True, box_settings=box_settings
+                        )
+                        for v in self.value.split(",")
+                    ]
                 else:
                     # @merge foo
                     self.value = [self.value]

{dynaconf-3.2.7 → dynaconf-3.2.9}/dynaconf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dynaconf
-Version: 3.2.7
+Version: 3.2.9
 Summary: The dynamic configurator for your Python Project
 Home-page: https://github.com/dynaconf/dynaconf
 Author: Bruno Rocha

dynaconf-3.2.7/dynaconf/VERSION

@@ -1 +0,0 @@
-3.2.7