Get a ConfigMap object from the server

        Raises exception on error

        :param name: str, name of configMap to get from the server
        :returns: ConfigMapResponse containing the ConfigMap with the requested name
327453
def get_config_map(self, name):
        
        response = self.os.get_config_map(name)
        config_map_response = ConfigMapResponse(response.json())
        return config_map_response
504772
def get_aliyun_config(name, default=None):
    '''
    
    '''
    config = os.environ.get(name, getattr(settings, name, default))
    if config is not None:
        if isinstance(config, str):
            return config.strip()
        else:
            return config
    else:
        raise ImproperlyConfigured(
            'Can not get config for {} either in environment'
            'variable or in settings.py'.format(name))
567540
def do_get_config(self, line):
        

        def f(p, args):
            try:
                source = args[0]
            except:
                print("argument error")
                return
            print(p.get_config(source))

        self._request(line, f)
430990
public static policystringmap get(nitro_service service, String name) throws Exception{
		policystringmap obj = new policystringmap();
		obj.set_name(name);
		policystringmap response = (policystringmap) obj.get_resource(service);
		return response;
	}
162749
@Override
    public Object getValue(String name)
    {
        Object value = super.getValue(name);
        if (value != null)
        {
            return value;
        }
        else
        {
            return configMap.get(name);
        }
    }
1282334
def fetch(name, adapter_name = :default)
      adapter(adapter_name)[name] || adapter(:default)[name] ||
        raise(UnknownPluginError, name)
    end
1148965
def get_config_value(self, name, defaultValue):
    
    self.send_get_config_value(name, defaultValue)
    return self.recv_get_config_value()
463100
def _load_get_attr(self, name):
        ''
        if self._mode in _allowed_read and self._N is None:
            self._read_header()
        return getattr(self, name)
1298875
def get(self, name: str):
        
        dep = None
        try:
            dep = self._registry[name]
        except KeyError:
            raise DependencyNotFoundError(name) from None
        value = self.cached(dep)
        if value is None:
            value = dep.factory()
            self.cache(dep, value)
        return value
535715
def get(self, name, **kwargs):
        
        name = self._prefix + name
        if name not in self._params:
            self._params[name] = symbol.Variable(name, **kwargs)
        return self._params[name]
304867
def getattr(self, name, context=None):
        
        if name in self.instance_attrs:
            return self.instance_attrs[name]
        if name in self.special_attributes:
            return [self.special_attributes.lookup(name)]
        raise exceptions.AttributeInferenceError(target=self, attribute=name)
641249
def get_parameter(self, name):
        
        name = adapt_name_for_rest(name)
        url = '/mdb/{}/parameters{}'.format(self._instance, name)
        response = self._client.get_proto(url)
        message = mdb_pb2.ParameterInfo()
        message.ParseFromString(response.content)
        return Parameter(message)
1082744
def getp(self, name):
        
        name = self._mapping.get(name,name)
        return self.params[name]
730707
def get_attr(self, name, default=None, fail_silently=True):
        
        try:
            return getattr(self, name)
        except KeyError:
            extra_context = getattr(self, "extra_context")

            if name in extra_context:
                value = extra_context[name]

                if callable(value):
                    return value(request=None)

            return default
829080
def get_config(name, expand=False):
    
    cfg = Config.instance()
    only_section = "." not in name

    # when only the section is given, print all keys
    if only_section:
        return "\n".join(cfg.keys(name))

    else:
        section, option = name.split(".", 1)
        func = cfg.get_expanded if expand else cfg.get
        return func(section, option)
1269054
def GetFlag(self, name):
    """"""
    res = self.FlagDict().get(name)
    if res is None:
      raise exceptions.UnrecognizedFlagError(name)
    return res
1031006
function getConfigElement(name) {
    checkIsString('name', name);
    if (config.has(name)) {
        return config.get(name);
    }
}