docs: def Get(self, name, default=utils.NotAValue, context=None):
      """Get the value contained  by the named parameter.
  
      This method applies interpolation/escaping of the named parameter and
      retrieves the interpolated value.
  
      Args:
        name: The name of the parameter to retrieve. This should be in the format
          of "Section.name"
        default: If retrieving the value results in an error, return this default.
        context: A list of context strings to resolve the configuration. This is a
          set of roles the caller is current executing with. For example (client,
          windows). If not specified we take the context from the current thread's
          TLS stack.
  
      Returns:
        The value of the parameter.
      Raises:
        ConfigFormatError: if verify=True and the config doesn't validate.
        RuntimeError: if a value is retrieved before the config is initialized.
        ValueError: if a bad context is passed.
      """
      if not self.initialized:
        if name not in self.constants:
          raise RuntimeError("Error while retrieving %s: "
                             "Configuration hasn't been initialized yet." % name)
      if context:
        # Make sure it's not just a string and is iterable.
        if (isinstance(context, string_types) or
            not isinstance(context, collections.Iterable)):
          raise ValueError("context should be a list, got %r" % context)
  
      calc_context = context
  
      # Only use the cache if possible.
      cache_key = (name, tuple(context or ()))
      if default is utils.NotAValue and cache_key in self.cache:
        return self.cache[cache_key]
  
      # Use a default global context if context is not provided.
      if context is None:
        calc_context = self.context
  
      type_info_obj = self.FindTypeInfo(name)
      _, return_value = self._GetValue(
          name, context=calc_context, default=default)
  
      # If we returned the specified default, we just return it here.
      if return_value is default:
        return default
  
      try:
        return_value = self.InterpolateValue(
            return_value,
            default_section=name.split(".")[0],
            type_info_obj=type_info_obj,
            context=calc_context)
      except (lexer.ParseError, ValueError) as e:
        # We failed to parse the value, but a default was specified, so we just
        # return that.
        if default is not utils.NotAValue:
          return default
  
        raise ConfigFormatError("While parsing %s: %s" % (name, e))
  
      try:
        new_value = type_info_obj.Validate(return_value)
        if new_value is not None:
          # Update the stored value with the valid data.
          return_value = new_value
      except ValueError:
        if default is not utils.NotAValue:
          return default
  
        raise
  
      # Cache the value for next time.
      if default is utils.NotAValue:
        self.cache[cache_key] = return_value
  
      return return_value