docs: def _find(self, key):
          """Given a key, find the value
          Vyper will check in the following order:
          override, arg, env, config file, key/value store, default
          Vyper will check to see if an alias exists first.
          """
          key = self._real_key(key)
  
          # OVERRIDES
          val = self._override.get(key)
          if val is not None:
              log.debug("{0} found in override: {1}".format(key, val))
              return val
  
          # ARGS
          val = self._args.get(key)
          if val is not None:
              log.debug("{0} found in args: {1}".format(key, val))
              return val
  
          # ENVIRONMENT VARIABLES
          if self._automatic_env_applied:
              # even if it hasn't been registered, if `automatic_env` is used,
              # check any `get` request
              val = self._get_env(self._merge_with_env_prefix(key))
              if val is not None:
                  log.debug("{0} found in environment: {1}".format(key, val))
                  return val
  
          env_key = self._find_insensitive(key, self._env)
          log.debug("Looking for {0} in env".format(key))
          if isinstance(env_key, list):
              parent = self._find_insensitive(key, self._config)
              found_in_env = False
              log.debug("Found env key parent {0}: {1}".format(key, parent))
  
              for item in env_key:
                  log.debug("{0} registered as env var parent {1}:".format(
                      key, item["env_key"]))
                  val = self._get_env(item["env_key"])
  
                  if val is not None:
                      log.debug("{0} found in environment: {1}".format(
                          item["env_key"], val))
                      temp = parent
                      for path in item["path"]:
                          real_key = self._find_real_key(path, temp)
                          temp = temp[real_key]
  
                      self._set_insensitive(item["final_key"], val, temp)
                      found_in_env = True
                  else:
                      log.debug("{0} env value unset".format(item["env_key"]))
  
              if found_in_env:
                  return parent
  
          elif env_key is not None:
              log.debug("{0} registered as env var: {1}".format(key, env_key))
              val = self._get_env(env_key)
              if val is not None:
                  log.debug("{0} found in environment: {1}".format(env_key, val))
                  return val
              else:
                  log.debug("{0} env value unset".format(env_key))
  
          # CONFIG FILE
          val = self._find_insensitive(key, self._config)
          if val is not None:
              log.debug("{0} found in config: {1}".format(key, val))
              return val
  
          # Test for nested config parameter
          if self._key_delimiter in key:
              path = key.split(self._key_delimiter)
  
              source = self._find(path[0])
              if source is not None and isinstance(source, dict):
                  val = self._search_dict(source, path[1::])
                  if val is not None:
                      log.debug("{0} found in nested config: {1}".format(
                          key, val))
                      return val
  
          # KEY/VALUE STORE
          val = self._kvstore.get(key)
          if val is not None:
              log.debug("{0} found in key/value store: {1}".format(key, val))
              return val
  
          # DEFAULTS
          val = self._defaults.get(key)
          if val is not None:
              log.debug("{0} found in defaults: {1}".format(key, val))
              return val
  
          return None