Class Environment

invoke/env.py:21–123

class Environment:
    def __init__(self, config: "Config", prefix: str) -> None:
        self._config = config
        self._prefix = prefix
        self.data: Dict[str, Any] = {}  # Accumulator

    def load(self) -> Dict[str, Any]:
        """
        Return a nested dict containing values from `os.environ`.

        Specifically, values whose keys map to already-known configuration
        settings, allowing us to perform basic typecasting.

        See :ref:`env-vars` for details.
        """
        # Obtain allowed env var -> existing value map
        env_vars = self._crawl(key_path=[], env_vars={})
        m = "Scanning for env vars according to prefix: {!r}, mapping: {!r}"
        debug(m.format(self._prefix, env_vars))
        # Check for actual env var (honoring prefix) and try to set
        for env_var, key_path in env_vars.items():
            real_var = (self._prefix or "") + env_var
            if real_var in os.environ:
                self._path_set(key_path, os.environ[real_var])
        debug("Obtained env var config: {!r}".format(self.data))
        return self.data

    def _crawl(
        self, key_path: List[str], env_vars: Mapping[str, Sequence[str]]
    ) -> Dict[str, Any]:
        """
        Examine config at location ``key_path`` & return potential env vars.

        Uses ``env_vars`` dict to determine if a conflict exists, and raises an
        exception if so. This dict is of the following form::

            {
                'EXPECTED_ENV_VAR_HERE': ['actual', 'nested', 'key_path'],
                ...
            }

        Returns another dictionary of new keypairs as per above.
        """
        new_vars: Dict[str, List[str]] = {}
        obj = self._path_get(key_path)
        # Sub-dict -> recurse
        if (
            hasattr(obj, "keys")
            and callable(obj.keys)
            and hasattr(obj, "__getitem__")
        ):
            for key in obj.keys():
                merged_vars = dict(env_vars, **new_vars)
                merged_path = key_path + [key]
                crawled = self._crawl(merged_path, merged_vars)
                # Handle conflicts
                for key in crawled:
                    if key in new_vars: