dynaconf 3.2.7__tar.gz → 3.2.8__tar.gz

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

@@ -2,6 +2,20 @@ Changelog
 =========
 
 <!-- insertion marker -->
+## [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.8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: dynaconf
-Version: 3.2.7
+Version: 3.2.8
 Summary: The dynamic configurator for your Python Project
 Home-page: https://github.com/dynaconf/dynaconf
 Author: Bruno Rocha
@@ -26,14 +26,6 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: redis
-Provides-Extra: vault
-Provides-Extra: yaml
-Provides-Extra: toml
-Provides-Extra: ini
-Provides-Extra: configobj
-Provides-Extra: all
-Provides-Extra: test
 License-File: LICENSE
 License-File: vendor_licenses/box-LICENSE.txt
 License-File: vendor_licenses/click-LICENSE.rst
@@ -43,6 +35,47 @@ License-File: vendor_licenses/ruamel.yaml-LICENSE.txt
 License-File: vendor_licenses/toml-LICENSE.txt
 License-File: vendor_licenses/tomli-LICENSE.txt
 License-File: vendor_licenses/vendor_versions.txt
+Provides-Extra: redis
+Requires-Dist: redis; extra == "redis"
+Provides-Extra: vault
+Requires-Dist: hvac; extra == "vault"
+Provides-Extra: yaml
+Requires-Dist: ruamel.yaml; extra == "yaml"
+Provides-Extra: toml
+Requires-Dist: toml; extra == "toml"
+Provides-Extra: ini
+Requires-Dist: configobj; extra == "ini"
+Provides-Extra: configobj
+Requires-Dist: configobj; extra == "configobj"
+Provides-Extra: all
+Requires-Dist: redis; extra == "all"
+Requires-Dist: ruamel.yaml; extra == "all"
+Requires-Dist: configobj; extra == "all"
+Requires-Dist: hvac; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: radon; extra == "test"
+Requires-Dist: flask>=0.12; extra == "test"
+Requires-Dist: django; extra == "test"
+Requires-Dist: python-dotenv; extra == "test"
+Requires-Dist: toml; extra == "test"
+Requires-Dist: redis; extra == "test"
+Requires-Dist: hvac>=1.1.0; extra == "test"
+Requires-Dist: configobj; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: platform
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
 
 <!-- [![Dynaconf](docs/img/logo_400.svg?sanitize=true)](http://dynaconf.com) -->
 

dynaconf-3.2.8/dynaconf/VERSION

@@ -0,0 +1 @@
+3.2.8

{dynaconf-3.2.7 → dynaconf-3.2.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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?"