from __future__ import annotations

import copy
import importlib
import inspect
import os
import warnings
from collections import defaultdict
from contextlib import contextmanager
from contextlib import suppress
from pathlib import Path
from typing import Any
from typing import Callable

from dynaconf import default_settings
from dynaconf.loaders import default_loader
from dynaconf.loaders import enable_external_loaders
from dynaconf.loaders import env_loader
from dynaconf.loaders import execute_instance_hooks
from dynaconf.loaders import execute_module_hooks
from dynaconf.loaders import py_loader
from dynaconf.loaders import settings_loader
from dynaconf.loaders import yaml_loader
from dynaconf.loaders.base import SourceMetadata
from dynaconf.utils import BANNER
from dynaconf.utils import compat_kwargs
from dynaconf.utils import ensure_a_list
from dynaconf.utils import missing
from dynaconf.utils import object_merge
from dynaconf.utils import recursively_evaluate_lazy_format
from dynaconf.utils import RENAMED_VARS
from dynaconf.utils import upperfy
from dynaconf.utils.boxing import DynaBox
from dynaconf.utils.files import find_file
from dynaconf.utils.files import glob
from dynaconf.utils.functional import empty
from dynaconf.utils.functional import LazyObject
from dynaconf.utils.parse_conf import apply_converter
from dynaconf.utils.parse_conf import boolean_fix
from dynaconf.utils.parse_conf import converters
from dynaconf.utils.parse_conf import Lazy
from dynaconf.utils.parse_conf import parse_conf_data
from dynaconf.utils.parse_conf import true_values
from dynaconf.validator import ValidationError
from dynaconf.validator import ValidatorList
from dynaconf.vendor.box.box_list import BoxList


class LazySettings(LazyObject):
    """Loads settings lazily from multiple sources:

        settings = Dynaconf(
            settings_files=["settings.toml"],  # path/glob
            environments=True,                 # activate layered environments
            envvar_prefix="MYAPP",             # `export MYAPP_FOO=bar`
            env_switcher="MYAPP_MODE",         # `export MYAPP_MODE=production`
            load_dotenv=True,                  # read a .env file
        )

    More options available on https://www.dynaconf.com/configuration/
    """

    def __init__(self, wrapped=None, **kwargs):
        """
        handle initialization for the customization cases

        :param wrapped: a deepcopy of this object will be wrapped (issue #596)
        :param kwargs: values that overrides default_settings
        """
        self._wrapper_class = kwargs.pop("_wrapper_class", Settings)
        self._warn_dynaconf_global_settings = kwargs.pop(
            "warn_dynaconf_global_settings", None
        )  # in 3.0.0 global settings is deprecated

        self.__resolve_config_aliases(kwargs)
        compat_kwargs(kwargs)
        self._kwargs = kwargs
        super().__init__()

        if wrapped:
            if self._django_override:
                # This fixes django issue #596
                self._wrapped = copy.deepcopy(wrapped)
            else:
                self._wrapped = wrapped

    def __resolve_config_aliases(self, kwargs):
        """takes aliases for _FOR_DYNACONF configurations

        e.g: ROOT_PATH='/' is transformed into `ROOT_PATH_FOR_DYNACONF`
        """

        misspells = {
            "settings_files": "settings_file",
            "SETTINGS_FILES": "SETTINGS_FILE",
            "environment": "environments",
            "ENVIRONMENT": "ENVIRONMENTS",
        }
        for misspell, correct in misspells.items():
            if misspell in kwargs:
                kwargs[correct] = kwargs.pop(misspell)

        for_dynaconf_keys = {
            key
            for key in UPPER_DEFAULT_SETTINGS
            if key.endswith("_FOR_DYNACONF")
        }
        aliases = {
            key.upper()
            for key in kwargs
            if f"{key.upper()}_FOR_DYNACONF" in for_dynaconf_keys
        }
        for alias in aliases:
            value = kwargs.pop(alias, empty)
            if value is empty:
                value = kwargs.pop(alias.lower())
            kwargs[f"{alias}_FOR_DYNACONF"] = value

    def __getattr__(self, name):
        """Allow getting keys from self.store using dot notation"""
        if self._wrapped is empty:
            self._setup()
        if name in self._wrapped._deleted:  # noqa
            raise AttributeError(
                f"Attribute {name} was deleted, " "or belongs to different env"
            )

        if name not in RESERVED_ATTRS:
            lowercase_mode = self._kwargs.get(
                "LOWERCASE_READ_FOR_DYNACONF",
                default_settings.LOWERCASE_READ_FOR_DYNACONF,
            )
            if lowercase_mode is True:
                name = name.upper()

        if (
            name.isupper()
            and (
                self._wrapped._fresh
                or name in self._wrapped.FRESH_VARS_FOR_DYNACONF
            )
            and name not in UPPER_DEFAULT_SETTINGS
        ):
            return self._wrapped.get_fresh(name)
        value = getattr(self._wrapped, name)
        if name not in RESERVED_ATTRS:
            return recursively_evaluate_lazy_format(value, self)
        return value

    def __call__(self, *args, **kwargs):
        """Allow direct call of settings('val')
        in place of settings.get('val')
        """
        return self.get(*args, **kwargs)

    @property
    def _should_load_dotenv(self):
        """Chicken and egg problem, we must manually check envvar
        before deciding if we are loading envvars :)"""
        _environ_load_dotenv = parse_conf_data(
            boolean_fix(os.environ.get("LOAD_DOTENV_FOR_DYNACONF")),
            tomlfy=True,
        )
        return self._kwargs.get("load_dotenv", _environ_load_dotenv)

    def _setup(self):
        """Initial setup, run once."""

        if self._warn_dynaconf_global_settings:
            warnings.warn(
                "Usage of `from dynaconf import settings` is now "
                "DEPRECATED in 3.0.0+. You are encouraged to change it to "
                "your own instance e.g: `settings = Dynaconf(*options)`",
                DeprecationWarning,
            )
            self._wrapper_class = Settings  # Force unhooked for this

        default_settings.reload(self._should_load_dotenv)
        environment_variable = self._kwargs.get(
            "ENVVAR_FOR_DYNACONF", default_settings.ENVVAR_FOR_DYNACONF
        )
        settings_module = os.environ.get(environment_variable)
        self._wrapped = self._wrapper_class(
            settings_module=settings_module, **self._kwargs
        )

    def configure(self, settings_module=None, **kwargs):
        """
        Allows user to reconfigure settings object passing a new settings
        module or separated kwargs

        :param settings_module: defines the settings file
        :param kwargs:  override default settings
        """
        default_settings.reload(self._should_load_dotenv)
        environment_var = self._kwargs.get(
            "ENVVAR_FOR_DYNACONF", default_settings.ENVVAR_FOR_DYNACONF
        )
        settings_module = settings_module or os.environ.get(environment_var)
        compat_kwargs(kwargs)
        kwargs.update(self._kwargs)
        self._wrapped = self._wrapper_class(
            settings_module=settings_module, **kwargs
        )

    @property
    def configured(self):
        """If wrapped is configured"""
        return self._wrapped is not empty


class Settings:
    """
    Common logic for settings whether set by a module or by the user.
    """

    dynaconf_banner = BANNER
    _store = DynaBox()

    def __init__(self, settings_module=None, **kwargs):  # pragma: no cover
        """Execute loaders and custom initialization

        :param settings_module: defines the settings file
        :param kwargs:  override default settings
        """
        self._fresh = False
        self._loaded_envs = []
        self._loaded_hooks = defaultdict(dict)
        self._loaded_py_modules = []
        self._loaded_files = []
        self._deleted = set()
        self._store = kwargs.pop("_store", DynaBox(box_settings=self))
        self._env_cache = {}
        self._loaded_by_loaders: dict[SourceMetadata | str, Any] = {}
        self._loaders = []
        self._defaults = DynaBox(box_settings=self)
        self.environ = os.environ
        self.SETTINGS_MODULE = None
        self.filter_strategy = kwargs.get("filter_strategy", None)
        self._not_installed_warnings = []
        self._validate_only = kwargs.pop("validate_only", None)
        self._validate_exclude = kwargs.pop("validate_exclude", None)
        self._validate_only_current_env = kwargs.pop(
            "validate_only_current_env", False
        )

        self.validators = ValidatorList(
            self, validators=kwargs.pop("validators", None)
        )
        self._post_hooks: list[Callable] = ensure_a_list(
            kwargs.get("post_hooks", [])
        )

        compat_kwargs(kwargs)
        if settings_module:
            self.set(
                "SETTINGS_FILE_FOR_DYNACONF",
                settings_module,
                loader_identifier="init_settings_module",
            )
        for key, value in kwargs.items():
            self.set(
                key, value, loader_identifier="init_kwargs", validate=False
            )
        # execute loaders only after setting defaults got from kwargs
        self._defaults = kwargs

        # The following flags are used for when copying of settings is done
        skip_loaders = kwargs.get("dynaconf_skip_loaders", False)
        skip_validators = kwargs.get("dynaconf_skip_validators", False)

        if not skip_loaders:
            self.execute_loaders()

        if not skip_validators:
            self.validators.validate(
                only=self._validate_only,
                exclude=self._validate_exclude,
                only_current_env=self._validate_only_current_env,
            )

    def __call__(self, *args, **kwargs):
        """Allow direct call of `settings('val')`
        in place of `settings.get('val')`
        """
        return self.get(*args, **kwargs)

    def __setattr__(self, name, value):
        """Allow `settings.FOO = 'value'` while keeping internal attrs."""

        if name in RESERVED_ATTRS:
            super().__setattr__(name, value)
        else:
            self.set(name, value)

    def __delattr__(self, name):
        """stores reference in `_deleted` for proper error management"""
        self._deleted.add(name)
        if hasattr(self, name):
            super().__delattr__(name)

    def __contains__(self, item):
        """Respond to `item in settings`"""
        return item.upper() in self.store or item.lower() in self.store

    def __getattribute__(self, name):
        if (
            name.startswith("__")
            or name in RESERVED_ATTRS + UPPER_DEFAULT_SETTINGS
        ):
            return super().__getattribute__(name)

        # This is to keep the only upper case mode working
        # self._store has Lazy values already evaluated
        if (
            name.islower()
            and self._store.get("LOWERCASE_READ_FOR_DYNACONF", empty) is False
        ):
            try:
                # only matches exact casing, first levels always upper
                return self._store.__getattribute__(name)
            except KeyError:
                return super().__getattribute__(name)

        # then go to the regular .get which triggers hooks among other things
        value = self.get(name, default=empty)
        if value is empty:
            return super().__getattribute__(name)

        return value

    def __getitem__(self, item):
        """Allow getting variables as dict keys `settings['KEY']`"""
        value = self.get(item, default=empty)
        if value is empty:
            raise KeyError(f"{item} does not exist")
        return value

    def __setitem__(self, key, value):
        """Allow `settings['KEY'] = 'value'`"""
        self.set(key, value)

    @property
    def store(self):
        """Gets internal storage"""
        return self._store

    def __dir__(self):
        """Enable auto-complete for code editors"""
        return (
            RESERVED_ATTRS
            + [k.lower() for k in self.keys()]
            + list(self.keys())
        )

    def __iter__(self):
        """Redirects to store object"""
        yield from self._store

    def items(self):
        """Redirects to store object"""
        return self._store.items()

    def keys(self):
        """Redirects to store object"""
        return self.store.keys()

    def values(self):
        """Redirects to store object"""
        return self.store.values()

    def setdefault(
        self, item, default, apply_default_on_none=False, env: str = "unknown"
    ):
        """Returns value if exists or set it as the given default

        apply_default_on_none: if True, default is set when value is None
        env: used to create the source identifier
        """
        value = self.get(item, empty)

        # Yaml loader reads empty values as None, would we apply defaults?
        global_apply_default = (
            self.get("APPLY_DEFAULT_ON_NONE_FOR_DYNACONF") is not None
        )
        apply_default = default is not empty and (
            value is empty
            or (
                value is None
                and (
                    apply_default_on_none is True
                    or global_apply_default is True
                )
            )
        )
        loader_identifier = SourceMetadata("setdefault", "unique", env.lower())

        if apply_default:
            self.set(
                item,
                default,
                loader_identifier=loader_identifier,
                tomlfy=True,
            )
            return default

        return value

    def as_dict(self, env=None, internal=False):
        """Returns a dictionary with set key and values.

        :param env: Str env name, default self.current_env `DEVELOPMENT`
        :param internal: bool - should include dynaconf internal vars?
        """
        ctx_mgr = suppress() if env is None else self.using_env(env)
        with ctx_mgr:
            data = self.store.to_dict().copy()
            # if not internal remove internal settings
            if not internal:
                for name in UPPER_DEFAULT_SETTINGS:
                    data.pop(name, None)
            return data

    to_dict = as_dict  # backwards compatibility

    def _dotted_get(
        self, dotted_key, default=None, parent=None, cast=None, **kwargs
    ):
        """
        Perform dotted key lookups and keep track of where we are.
        :param key: The name of the setting value, will always be upper case
        :param default: In case of not found it will be returned
        :param parent: Is there a pre-loaded parent in a nested data?
        """
        # if parent is not traverseable raise error
        if parent and not hasattr(parent, "get"):
            raise AttributeError(
                f"cannot lookup {dotted_key!r} from {type(parent).__name__!r}"
            )

        split_key = dotted_key.split(".")
        name, keys = split_key[0], split_key[1:]
        result = self.get(name, default=default, parent=parent, **kwargs)

        # If we've reached the end, or parent key not found, then return result
        if not keys or result == default:
            if cast and cast in converters:
                return apply_converter(cast, result, box_settings=self)
            elif cast is True:
                return parse_conf_data(result, tomlfy=True, box_settings=self)
            return result

        # If we've still got key elements to traverse, let's do that.
        return self._dotted_get(
            ".".join(keys), default=default, parent=result, cast=cast, **kwargs
        )

    def get(
        self,
        key,
        default=None,
        cast=None,
        fresh=False,
        dotted_lookup=empty,
        parent=None,
        sysenv_fallback=None,
    ):
        """
        Get a value from settings store, this is the preferred way to access::

            >>> from dynaconf import settings
            >>> settings.get('KEY')

        :param key: The name of the setting value, will always be upper case
        :param default: In case of not found it will be returned
        :param cast: Should cast in to @int, @float, @bool or @json ?
        :param fresh: Should reload from loaders store before access?
        :param dotted_lookup: Should perform dotted-path lookup?
        :param parent: Is there a pre-loaded parent in a nested data?
        :param sysenv_fallback: Should fallback to system environ if not found?
        :return: The value if found, default or None
        """
        if sysenv_fallback is None:
            sysenv_fallback = self._store.get("SYSENV_FALLBACK_FOR_DYNACONF")

        nested_sep = self._store.get("NESTED_SEPARATOR_FOR_DYNACONF")
        if isinstance(key, str):
            if nested_sep and nested_sep in key:
                # turn FOO__bar__ZAZ in `FOO.bar.ZAZ`
                key = key.replace(nested_sep, ".")

            if dotted_lookup is empty:
                dotted_lookup = self._store.get("DOTTED_LOOKUP_FOR_DYNACONF")

            if "." in key and dotted_lookup:
                return self._dotted_get(
                    dotted_key=key,
                    default=default,
                    cast=cast,
                    fresh=fresh,
                    parent=parent,
                )

            key = upperfy(key)

        # handles system environment fallback
        if default is None:
            key_in_sysenv_fallback_list = isinstance(
                sysenv_fallback, list
            ) and key in [upperfy(k) for k in sysenv_fallback]
            if sysenv_fallback is True or key_in_sysenv_fallback_list:
                default = self.get_environ(key, cast=True)

        # default values should behave exactly Dynaconf parsed values
        if default is not None:
            if isinstance(default, list):
                default = BoxList(default)
            elif isinstance(default, dict):
                default = DynaBox(default)

        if key in self._deleted:
            return default

        if (
            fresh
            or self._fresh
            or key in getattr(self, "FRESH_VARS_FOR_DYNACONF", ())
        ) and key not in UPPER_DEFAULT_SETTINGS:
            self.unset(key)
            self.execute_loaders(key=key)

        data = (parent or self.store).get(key, default)
        if cast:
            data = apply_converter(cast, data, box_settings=self)
        return data

    def exists(self, key, fresh=False):
        """Check if key exists

        :param key: the name of setting variable
        :param fresh: if key should be taken from source directly
        :return: Boolean
        """
        key = upperfy(key)
        if key in self._deleted:
            return False
        return self.get(key, fresh=fresh, default=missing) is not missing

    def get_fresh(self, key, default=None, cast=None):
        """This is a shortcut to `get(key, fresh=True)`. always reload from
        loaders store before getting the var.

        :param key: The name of the setting value, will always be upper case
        :param default: In case of not found it will be returned
        :param cast: Should cast in to @int, @float, @bool or @json ?
        :return: The value if found, default or None
        """
        return self.get(key, default=default, cast=cast, fresh=True)

    def get_environ(self, key, default=None, cast=None):
        """Get value from environment variable using os.environ.get

        :param key: The name of the setting value, will always be upper case
        :param default: In case of not found it will be returned
        :param cast: Should cast in to @int, @float, @bool or @json ?
         or cast must be true to use cast inference
        :return: The value if found, default or None
        """
        key = upperfy(key)
        data = self.environ.get(key, default)
        if data:
            if cast in converters:
                data = apply_converter(cast, data, box_settings=self)
            elif cast is True:
                data = parse_conf_data(
                    boolean_fix(data), tomlfy=True, box_settings=self
                )
        return data

    def exists_in_environ(self, key):
        """Return True if env variable is exported"""
        return upperfy(key) in self.environ

    def as_bool(self, key):
        """Partial method for get with bool cast"""
        return self.get(key, cast="@bool")

    def as_int(self, key):
        """Partial method for get with int cast"""
        return self.get(key, cast="@int")

    def as_float(self, key):
        """Partial method for get with float cast"""
        return self.get(key, cast="@float")

    def as_json(self, key):
        """Partial method for get with json cast"""
        return self.get(key, cast="@json")

    @property
    def loaded_envs(self):
        """Get or create internal loaded envs list"""
        if not self._loaded_envs:
            self._loaded_envs = []
        return self._loaded_envs

    @loaded_envs.setter
    def loaded_envs(self, value):
        """Setter for env list"""
        self._loaded_envs = value

    # compat
    loaded_namespaces = loaded_envs

    @property
    def loaded_by_loaders(self):  # pragma: no cover
        """Gets the internal mapping of LOADER -> values"""
        return self._loaded_by_loaders

    def from_env(self, env="", keep=False, **kwargs):
        """Return a new isolated settings object pointing to specified env.

        Example of settings.toml::

            [development]
            message = 'This is in dev'
            [other]
            message = 'this is in other env'

        Program::

            >>> from dynaconf import settings
            >>> print(settings.MESSAGE)
            'This is in dev'
            >>> print(settings.from_env('other').MESSAGE)
            'This is in other env'
            # The existing settings object remains the same.
            >>> print(settings.MESSAGE)
            'This is in dev'

        Arguments:
            env {str} -- Env to load (development, production, custom)

        Keyword Arguments:
            keep {bool} -- Keep pre-existing values (default: {False})
            kwargs {dict} -- Passed directly to new instance.
        """
        cache_key = f"{env}_{keep}_{kwargs}"
        if cache_key in self._env_cache:
            return self._env_cache[cache_key]

        new_data = {
            key: self.get(key)
            for key in UPPER_DEFAULT_SETTINGS
            if key not in RENAMED_VARS
        }

        if self.filter_strategy:
            # Retain the filtering strategy when switching environments
            new_data["filter_strategy"] = self.filter_strategy

        # This is here for backwards compatibility
        # To be removed on 4.x.x
        default_settings_paths = self.get("default_settings_paths")
        if default_settings_paths:  # pragma: no cover
            new_data["default_settings_paths"] = default_settings_paths

        if keep:
            # keep existing values from current env
            new_data.update(
                {
                    key: value
                    for key, value in self.store.to_dict().copy().items()
                    if key.isupper() and key not in RENAMED_VARS
                }
            )

        new_data.update(kwargs)
        new_data["FORCE_ENV_FOR_DYNACONF"] = env
        new_settings = LazySettings(**new_data)
        self._env_cache[cache_key] = new_settings

        # update source metadata for inspecting
        self._loaded_by_loaders.update(new_settings._loaded_by_loaders)

        return new_settings

    @contextmanager
    def using_env(self, env, clean=True, silent=True, filename=None):
        """
        This context manager allows the contextual use of a different env
        Example of settings.toml::

            [development]
            message = 'This is in dev'
            [other]
            message = 'this is in other env'

        Program::

            >>> from dynaconf import settings
            >>> print settings.MESSAGE
            'This is in dev'
            >>> with settings.using_env('OTHER'):
            ...    print settings.MESSAGE
            'this is in other env'

        :param env: Upper case name of env without any _
        :param clean: If preloaded vars should be cleaned
        :param silent: Silence errors
        :param filename: Custom filename to load (optional)
        :return: context
        """
        try:
            self.setenv(env, clean=clean, silent=silent, filename=filename)
            yield
        finally:
            if env.lower() != self.ENV_FOR_DYNACONF.lower():
                del self.loaded_envs[-1]
            self.setenv(self.current_env, clean=clean, filename=filename)

    # compat
    using_namespace = using_env

    @contextmanager
    def fresh(self):
        """
        this context manager force the load of a key direct from the store::

            $ export DYNACONF_VALUE='Original'
            >>> from dynaconf import settings
            >>> print settings.VALUE
            'Original'
            $ export DYNACONF_VALUE='Changed Value'
            >>> print settings.VALUE  # will not be reloaded from env vars
            'Original
            >>> with settings.fresh(): # inside this context all is reloaded
            ...    print settings.VALUE
            'Changed Value'

        an alternative is using `settings.get_fresh(key)`

        :return: context
        """

        self._fresh = True
        yield
        self._fresh = False

    @property
    def current_env(self):
        """Return the current active env"""

        if self.ENVIRONMENTS_FOR_DYNACONF is False:
            return self.MAIN_ENV_FOR_DYNACONF.lower()

        if self.FORCE_ENV_FOR_DYNACONF is not None:
            self.ENV_FOR_DYNACONF = self.FORCE_ENV_FOR_DYNACONF
            return self.FORCE_ENV_FOR_DYNACONF

        try:
            return self.loaded_envs[-1]
        except IndexError:
            return self.ENV_FOR_DYNACONF

    # compat
    current_namespace = current_env

    @property
    def settings_module(self):
        """Gets SETTINGS_MODULE variable"""
        settings_module = parse_conf_data(
            os.environ.get(
                self.ENVVAR_FOR_DYNACONF, self.SETTINGS_FILE_FOR_DYNACONF
            ),
            tomlfy=True,
            box_settings=self,
        )
        if settings_module != getattr(self, "SETTINGS_MODULE", None):
            self.set(
                "SETTINGS_MODULE",
                settings_module,
                loader_identifier="settings_module_method",
            )

        # This is for backewards compatibility, to be removed on 4.x.x
        if not self.SETTINGS_MODULE and self.get("default_settings_paths"):
            self.SETTINGS_MODULE = self.get("default_settings_paths")

        return self.SETTINGS_MODULE

    # Backwards compatibility see #169
    settings_file = settings_module

    def setenv(self, env=None, clean=True, silent=True, filename=None):
        """Used to interactively change the env
        Example of settings.toml::

            [development]
            message = 'This is in dev'
            [other]
            message = 'this is in other env'

        Program::

            >>> from dynaconf import settings
            >>> print settings.MESSAGE
            'This is in dev'
            >>> with settings.using_env('OTHER'):
            ...    print settings.MESSAGE
            'this is in other env'

        :param env: Upper case name of env without any _
        :param clean: If preloaded vars should be cleaned
        :param silent: Silence errors
        :param filename: Custom filename to load (optional)
        :return: context
        """
        env = env or self.ENV_FOR_DYNACONF

        if not isinstance(env, str) or " " in env:
            raise ValueError("env should be a string without spaces")

        env = env.upper()

        if env != self.ENV_FOR_DYNACONF:
            self.loaded_envs.append(env)
        else:
            self.loaded_envs = []

        if clean:
            self.clean(env=env)
        self.execute_loaders(env=env, silent=silent, filename=filename)

    # compat
    namespace = setenv

    def clean(self, *args, **kwargs):
        """Clean all loaded values to reload when switching envs"""
        for key in list(self.store.keys()):
            self.unset(key)

    def unset(self, key, force=False):
        """Unset on all references

        :param key: The key to be unset
        :param force: Bypass default checks and force unset
        """
        key = upperfy(key.strip())
        if (
            key not in UPPER_DEFAULT_SETTINGS
            and key not in self._defaults
            or force
        ):
            with suppress(KeyError, AttributeError):
                # AttributeError can happen when a LazyValue consumes
                # a previously deleted key
                delattr(self, key)
                del self.store[key]

    def unset_all(self, keys, force=False):  # pragma: no cover
        """Unset based on a list of keys

        :param keys: a list of keys
        :param force: Bypass default checks and force unset
        """
        for key in keys:
            self.unset(key, force=force)

    def _dotted_set(
        self, dotted_key, value, tomlfy=False, validate=empty, **kwargs
    ):
        """Sets dotted keys as nested dictionaries.

        Dotted set will always reassign the value, to merge use `@merge` token

        Arguments:
            dotted_key {str} -- A traversal name e.g: foo.bar.zaz
            value {Any} -- The value to set to the nested value.

        Keyword Arguments:
            tomlfy {bool} -- Perform toml parsing (default: {False})
            validate {bool} --
        """
        if validate is empty:
            validate = self.get(
                "VALIDATE_ON_UPDATE_FOR_DYNACONF"
            )  # pragma: nocover

        split_keys = dotted_key.split(".")
        existing_data = self.get(split_keys[0], {})
        new_data = tree = DynaBox(box_settings=self)

        for k in split_keys[:-1]:
            tree = tree.setdefault(k, {})

        value = parse_conf_data(value, tomlfy=tomlfy, box_settings=self)
        tree[split_keys[-1]] = value

        if existing_data:
            old_data = DynaBox(
                {split_keys[0]: existing_data}, box_settings=self
            )
            new_data = object_merge(
                old=old_data,
                new=new_data,
                full_path=split_keys,
            )
        self.update(data=new_data, tomlfy=tomlfy, validate=validate, **kwargs)

    def set(
        self,
        key,
        value,
        loader_identifier: SourceMetadata | str | None = None,
        tomlfy=False,
        dotted_lookup=empty,
        is_secret="DeprecatedArgument",  # noqa
        validate=empty,
        merge=empty,
    ):
        """Set a value storing references for the loader

        :param key: The key to store. Can be of any type.
        :param value: The raw value to parse and store
        :param loader_identifier: Optional loader name e.g: toml, yaml etc.
                                  Or instance of SourceMetadata
        :param tomlfy: Bool define if value is parsed by toml (defaults False)
        :param merge: Bool define if existing nested data will be merged.
        :param validate: Bool define if validation will be triggered
        """

        # Ensure source_metadata always is set even if set is called
        # without a loader_identifier
        if isinstance(loader_identifier, str) or loader_identifier is None:
            source_metadata = SourceMetadata(
                loader="set_method",
                identifier=loader_identifier or "undefined",
                merged=merge is True,
            )
        else:  # loader identifier must be a SourceMetadata instance
            source_metadata = loader_identifier

        if validate is empty:
            validate = self.get("VALIDATE_ON_UPDATE_FOR_DYNACONF")
        if dotted_lookup is empty:
            dotted_lookup = self.get("DOTTED_LOOKUP_FOR_DYNACONF")
        nested_sep = self.get("NESTED_SEPARATOR_FOR_DYNACONF")

        if isinstance(key, str):
            if nested_sep and nested_sep in key:
                key = key.replace(nested_sep, ".")  # FOO__bar -> FOO.bar

            if "." in key and dotted_lookup is True:
                return self._dotted_set(
                    key,
                    value,
                    loader_identifier=source_metadata,
                    tomlfy=tomlfy,
                    validate=validate,
                )
            key = upperfy(key.strip())

        parsed = parse_conf_data(value, tomlfy=tomlfy, box_settings=self)

        # Fix for #869 - The call to getattr trigger early evaluation
        existing = (
            self.store.get(key, None) if not isinstance(parsed, Lazy) else None
        )

        if getattr(parsed, "_dynaconf_del", None):
            self.unset(key, force=True)  # `@del` in a first level var.
            return

        if getattr(parsed, "_dynaconf_reset", False):  # pragma: no cover
            parsed = parsed.unwrap()  # `@reset` in a first level var.

        if getattr(parsed, "_dynaconf_merge_unique", False):
            # `@merge_unique` in a first level var
            if existing:
                # update SourceMetadata (for inspecting purposes)
                source_metadata = source_metadata._replace(merged=True)
                parsed = object_merge(existing, parsed.unwrap(), unique=True)
            else:
                parsed = parsed.unwrap()

        if getattr(parsed, "_dynaconf_merge", False):
            # `@merge` in a first level var
            if existing:
                # update SourceMetadata (for inspecting purposes)
                source_metadata = source_metadata._replace(merged=True)
                parsed = object_merge(existing, parsed.unwrap())
            else:
                parsed = parsed.unwrap()

        should_merge = existing is not None and existing != parsed
        if should_merge:
            # `dynaconf_merge` used in file root `merge=True`
            if merge and merge is not empty:
                source_metadata = source_metadata._replace(merged=True)
                parsed = object_merge(existing, parsed)
            else:
                # `dynaconf_merge` may be used within the key structure
                # Or merge_enabled is set to True
                parsed, source_metadata = self._merge_before_set(
                    existing, parsed, source_metadata, context_merge=merge
                )

        if isinstance(parsed, dict) and not isinstance(parsed, DynaBox):
            parsed = DynaBox(parsed, box_settings=self)

        # Set the parsed value
        self.store[key] = parsed
        self._deleted.discard(key)

        # check if str because we can't directly set/get non-str with obj. e.g.
        #     setting.1
        #     settings.(1,2)
        if isinstance(key, str):
            super().__setattr__(key, parsed)

        # Track history for inspect, store the raw_value
        if source_metadata in self._loaded_by_loaders:
            self._loaded_by_loaders[source_metadata][key] = value
        else:
            self._loaded_by_loaders[source_metadata] = {key: value}

        if loader_identifier is None:
            # if .set is called without loader identifier it becomes
            # a default value and goes away only when explicitly unset
            self._defaults[key] = parsed

        if validate is True:
            self.validators.validate()

    def update(
        self,
        data=None,
        loader_identifier=None,
        tomlfy=False,
        merge=empty,
        is_secret="DeprecatedArgument",  # noqa
        dotted_lookup=empty,
        validate=empty,
        **kwargs,
    ):
        """
        Update values in the current settings object without saving in stores::

            >>> from dynaconf import settings
            >>> print settings.NAME
            'Bruno'
            >>> settings.update({'NAME': 'John'}, other_value=1)
            >>> print settings.NAME
            'John'
            >>> print settings.OTHER_VALUE
            1

        :param data: Data to be updated
        :param loader_identifier: Only to be used by custom loaders
        :param tomlfy: Bool define if value is parsed by toml (defaults False)
        :param merge: Bool define if existing nested data will be merged.
        :param validate: Bool define if validators will trigger automatically
        :param kwargs: extra values to update
        :return: None
        """

        if validate is empty:
            validate = self.get("VALIDATE_ON_UPDATE_FOR_DYNACONF")

        data = data or {}
        data.update(kwargs)
        for key, value in data.items():
            # update() will handle validation later
            with suppress(ValidationError):
                self.set(
                    key,
                    value,
                    loader_identifier=loader_identifier,
                    tomlfy=tomlfy,
                    merge=merge,
                    dotted_lookup=dotted_lookup,
                    validate=validate,
                )

        # handle param `validate`
        if validate is True:
            self.validators.validate()
        elif validate == "all":
            self.validators.validate_all()

    def _merge_before_set(
        self,
        existing,
        value,
        identifier: SourceMetadata | None = None,
        context_merge=empty,
    ):
        """
        Merge the new value being set with the existing value before set
        Returns the merged value and the updated identifier (for inspecting).
        """
        # context_merge may come from file_scope or env_scope
        if context_merge is empty:
            context_merge = self.get("MERGE_ENABLED_FOR_DYNACONF")

        if isinstance(value, dict):
            local_merge = value.pop(
                "dynaconf_merge", value.pop("dynaconf_merge_unique", None)
            )
            if local_merge not in (True, False, None) and not value:
                # In case `dynaconf_merge:` holds value not boolean - ref #241
                value = local_merge

            if local_merge or (context_merge and local_merge is not False):
                identifier = (
                    identifier._replace(merged=True) if identifier else None
                )
                value = object_merge(existing, value)

        if isinstance(value, (list, tuple)):
            value = list(value)
            local_merge = None
            unique = False
            if "dynaconf_merge" in value:
                value.remove("dynaconf_merge")
                local_merge = True
            elif "dynaconf_merge_unique" in value:
                value.remove("dynaconf_merge_unique")
                local_merge = True
                unique = True

            if local_merge or (context_merge and local_merge is not False):
                identifier = (
                    identifier._replace(merged=True) if identifier else None
                )
                value = object_merge(existing, value, unique=unique)
        return value, identifier

    @property
    def loaders(self):  # pragma: no cover
        """Return available loaders"""
        if self.LOADERS_FOR_DYNACONF in (None, 0, "0", "false", False):
            return []

        if not self._loaders:
            self._loaders = self.LOADERS_FOR_DYNACONF

        return [importlib.import_module(loader) for loader in self._loaders]

    def reload(self, env=None, silent=None):  # pragma: no cover
        """Clean end Execute all loaders"""
        self.clean()
        self._loaded_hooks.clear()
        self.execute_loaders(env, silent)

    def execute_loaders(
        self, env=None, silent=None, key=None, filename=None, loaders=None
    ):
        """Execute all internal and registered loaders

        :param env: The environment to load
        :param silent: If loading errors is silenced
        :param key: if provided load a single key
        :param filename: optional custom filename to load
        :param loaders: optional list of loader modules
        """
        if key is None:
            default_loader(self, self._defaults)

        env = (env or self.current_env).upper()
        silent = silent or self.SILENT_ERRORS_FOR_DYNACONF

        if loaders is None:
            self.pre_load(env, silent=silent, key=key)
            settings_loader(
                self, env=env, silent=silent, key=key, filename=filename
            )
            self.load_extra_yaml(env, silent, key)  # DEPRECATED
            enable_external_loaders(self)

            loaders = self.loaders
        # non setting_file or py_module loaders
        for core_loader in loaders:
            core_loader.load(self, env, silent=silent, key=key)

        self.load_includes(env, silent=silent, key=key)

        # execute hooks
        execute_module_hooks("post", self, env, silent=silent, key=key)
        execute_instance_hooks(self, "post", self._post_hooks)

    def pre_load(self, env, silent, key):
        """Do we have any file to pre-load before main settings file?"""
        preloads = self.get("PRELOAD_FOR_DYNACONF", [])
        if preloads:
            self.load_file(path=preloads, env=env, silent=silent, key=key)

    def load_includes(self, env, silent, key):
        """Do we have any nested includes we need to process?"""
        includes = ensure_a_list(self.get("DYNACONF_INCLUDE"))
        includes.extend(ensure_a_list(self.get("INCLUDES_FOR_DYNACONF")))
        if includes:
            self.load_file(path=includes, env=env, silent=silent, key=key)
            # ensure env vars are the last thing loaded after all includes
            last_loader = self.loaders and self.loaders[-1]
            if last_loader and last_loader == env_loader:
                last_loader.load(self, env, silent, key)

    def load_file(
        self, path=None, env=None, silent=True, key=None, validate=empty
    ):
        """Programmatically load files from ``path``.

        When using relative paths, the basedir fallbacks in this order:
        - ROOT_PATH_FOR_DYNACONF
        - Directory of the last loaded file
        - CWD

        :param path: A single filename 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?
        """
        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:
            already_loaded = set()
            for _filename in files:
                # load_file() will handle validation later
                with suppress(ValidationError):
                    if py_loader.try_to_load_from_py_module_name(
                        obj=self, name=_filename, silent=True
                    ):
                        # 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):
                        settings_loader(
                            obj=self,
                            env=env,
                            silent=silent,
                            key=key,
                            filename=path,
                            validate=validate,
                        )
                        already_loaded.add(path)

        # handle param `validate`
        if validate is True:
            self.validators.validate()
        elif validate == "all":
            self.validators.validate_all()

    @property
    def _root_path(self):
        """ROOT_PATH_FOR_DYNACONF or the path of first loaded file or '.'"""

        if self.ROOT_PATH_FOR_DYNACONF is not None:
            return self.ROOT_PATH_FOR_DYNACONF

        if self._loaded_files:  # called once
            root_path = os.path.dirname(self._loaded_files[0])
            self.set(
                "ROOT_PATH_FOR_DYNACONF",
                root_path,
                loader_identifier="_root_path",
            )
            return root_path

    def load_extra_yaml(self, env, silent, key):
        """This is deprecated, kept for compat

        .. deprecated:: 1.0.0
            Use multiple settings or INCLUDES_FOR_DYNACONF files instead.
        """
        if self.get("YAML") is not None:
            warnings.warn(
                "The use of YAML var is deprecated, please define multiple "
                "filepaths instead: "
                "e.g: SETTINGS_FILE_FOR_DYNACONF = "
                "'settings.py,settings.yaml,settings.toml' or "
                "INCLUDES_FOR_DYNACONF=['path.toml', 'folder/*']"
            )
            yaml_loader.load(
                self,
                env=env,
                filename=self.find_file(self.get("YAML")),
                silent=silent,
                key=key,
            )

    def path_for(self, *args):
        """Path containing _root_path"""
        if args and args[0].startswith(os.path.sep):
            return os.path.join(*args)
        return os.path.join(self._root_path or os.getcwd(), *args)

    def find_file(self, *args, **kwargs):
        kwargs.setdefault("project_root", self._root_path)
        kwargs.setdefault(
            "skip_files", self.get("SKIP_FILES_FOR_DYNACONF", [])
        )
        return find_file(*args, **kwargs)

    def flag(self, key, env=None):
        """Feature flagging system
        write flags to redis
        $ dynaconf write redis -s DASHBOARD=1 -e premiumuser
        meaning: Any premium user has DASHBOARD feature enabled

        In your program do::

            # premium user has access to dashboard?
            >>> if settings.flag('dashboard', 'premiumuser'):
            ...     activate_dashboard()

        The value is ensured to be loaded fresh from redis server

        It also works with file settings but the recommended is redis
        as the data can be loaded once it is updated.

        :param key: The flag name
        :param env: The env to look for
        """
        env = env or self.ENVVAR_PREFIX_FOR_DYNACONF or "DYNACONF"
        with self.using_env(env):
            value = self.get_fresh(key)
            return value is True or value in true_values

    def populate_obj(self, obj, keys=None, ignore=None):
        """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.
        """
        keys = keys or self.keys()
        for key in keys:
            key = upperfy(key)
            if ignore and key in ignore:
                continue
            value = self.get(key, empty)
            if value is not empty:
                setattr(obj, key, value)

    def dynaconf_clone(self):
        """Clone the current settings object."""
        try:
            return copy.deepcopy(self)
        except (TypeError, copy.Error):
            # can't deepcopy settings object because of module object
            # being set as value in the settings dict
            new_data = self.to_dict(internal=True)
            new_data["dynaconf_skip_loaders"] = True
            new_data["dynaconf_skip_validators"] = True
            new_data["_registered_hooks"] = {}
            new_data["_REGISTERED_HOOKS"] = {}
            return self.__class__(**new_data)

    @property
    def dynaconf(self):
        """A proxy to access internal methods and attributes

        Starting in 3.0.0 Dynaconf now allows first level lower case
        keys that are not reserved keyword, so this is a proxy to
        internal methods and attrs.
        """

        class AttrProxy:
            def __init__(self, obj):
                self.obj = obj

            def __getattr__(self, name):
                return getattr(self.obj, f"dynaconf_{name}")

        return AttrProxy(self)

    @property
    def logger(self):  # pragma: no cover
        """backwards compatibility with pre 3.0 loaders
        In dynaconf 3.0.0 logger and debug messages has been removed.
        """
        warnings.warn(
            "logger and DEBUG messages has been removed on dynaconf 3.0.0"
        )
        import logging  # noqa

        return logging.getLogger("dynaconf")

    def is_overridden(self, setting):  # noqa
        """This is to provide Django DJDT support: issue 382"""
        return False


"""Upper case default settings"""
UPPER_DEFAULT_SETTINGS = [k for k in dir(default_settings) if k.isupper()]

"""Attributes created on Settings before 3.0.0"""
RESERVED_ATTRS = (
    [
        item[0]
        for item in inspect.getmembers(LazySettings)
        if not item[0].startswith("__")
    ]
    + [
        item[0]
        for item in inspect.getmembers(Settings)
        if not item[0].startswith("__")
    ]
    + [
        "_defaults",
        "_deleted",
        "_env_cache",
        "_fresh",
        "_kwargs",
        "_loaded_by_loaders",
        "_loaded_envs",
        "_loaded_hooks",
        "_loaded_py_modules",
        "_loaded_files",
        "_loaders",
        "_not_installed_warnings",
        "_store",
        "_warn_dynaconf_global_settings",
        "_should_load_dotenv",
        "environ",
        "SETTINGS_MODULE",
        "filter_strategy",
        "validators",
        "_validate_only",
        "_validate_exclude",
        "_validate_only_current_env",
        "_post_hooks",
        "_registered_hooks",
        "_REGISTERED_HOOKS",
    ]
)
