Get a setting.

        `name` should be the name of the setting to look for.  If the
        optional argument `function` is passed, this will look for a
        value local to the function before retrieving the global
        value.
554584
def get(name, function=None):
        
        if function is not None:
            if hasattr(function, Settings.FUNCTION_SETTINGS_NAME):
                if name in getattr(function, Settings.FUNCTION_SETTINGS_NAME):
                    return getattr(function, Settings.FUNCTION_SETTINGS_NAME)[name]
        return Settings.__global_setting_values[name]
378174
def local_method(f):
    '''
    '''
    name = f.__name__

    def _(self, *args):
        local = self.local
        if name not in local:
            setattr(local, name, f(self, *args))
        return getattr(local, name)
    return _
276567
def get_django_settings(cls, name, default=None):
        # pylint: disable=access-member-before-definition
        
        if hasattr(cls, '__django_settings__'):
            return getattr(cls.__django_settings__, name, default)
        from django.conf import settings
        cls.__django_settings__ = settings
        return cls.get_django_settings(name)
425248
function getSettings (def) {
  var settings = {}
  for (var s in def) {
    if (def.hasOwnProperty(s)) {
      if (s !== 'name' || s !== 'properties') {
        settings[ s ] = def[ s ]
      }
    }
  }
  return settings
}
1234777
def get_parameter(self, name, default=None):
        '''
        
        '''
        if hasattr(self, name):
            item = getattr(self, name)
            if isinstance(item, Parameter):
                return item
        return default
544836
def get_local(self, name, recurse=True):
        
        self._dlog("getting local '{}'".format(name))
        return self._search("vars", name, recurse)
901760
public String getGlobalSetting(GlobalSettingKey key) {
        if (globalSettings.containsKey(key.toString()))
            return globalSettings.get(key.toString());
        return key.getDefault();
    }
1111790
def get_function(fn_name):
    
    module_name, callable_name = fn_name.split(':')
    current = globals()
    if not callable_name:
        callable_name = module_name
    else:
        import importlib
        try:
            module = importlib.import_module(module_name)
        except ImportError:
            log.error("failed to import %s", module_name)
            raise
        current = module
    for level in callable_name.split('.'):
        current = getattr(current, level)
    code = current.__code__
    if code.co_argcount != 2:
        raise ValueError('function should take 2 arguments: lines, file_name')
    return current
57941
def cached_property(func):
    
    name = func.__name__
    doc = func.__doc__

    def getter(self, name=name):
        try:
            return self.__dict__[name]
        except KeyError:
            self.__dict__[name] = value = func(self)
            return value

    getter.func_name = name
    return property(getter, doc=doc)
943833
def get_setting(self, key, default):
        
        gkey = "ensime_{}".format(key)
        return self._vim.vars.get(gkey, default)
47879
def setting(self, setting_name, default=None):  # type: (str) -> Any
        
        keys = setting_name.split(".")

        config = self._content
        for key in keys:
            if key not in config:
                return default

            config = config[key]

        return config
1088164
def get_setting(key, **kwargs):
    
    has_default = 'default' in kwargs
    default_val = kwargs.get('default')

    try:
        if has_default:
            return getattr(settings, key, default_val)
        else:
            return getattr(settings, key)
    except Exception as e:
        raise ImproperlyConfigured(
            _('"{0}" setting has not been properly set. {1}').format(key, e)
        )
755890
def var(name)
      s = Setting.where(:name => name).first
      return "" if s.nil?    
      return s.value
    end
275160
def get_parent_var(name, global_ok=False, default=None, skip_frames=0):
    

    scope = get_parent_scope_from_var(name, global_ok=global_ok, skip_frames=skip_frames + 1)

    if not scope:
        return default

    if name in scope.locals:
        return scope.locals.get(name, default)

    return scope.globals.get(name, default)
151481
def get_function(self, name: str) -> AbiFunction or None:
        
        for func in self.functions:
            if func['name'] == name:
                return AbiFunction(func['name'], func['parameters'], func.get('returntype', ''))
        return None
1142452
def __get_function_or_ex_function(self, func_name):
        
        # try function name as given
        try:
            return getattr(self.driver, func_name)
        except AttributeError:
            pass
        # try prefixing name with `ex_`
        try:
            return getattr(self.driver, 'ex_' + func_name)
        except AttributeError:
            pass
        # no such function
        raise AttributeError(
            "No function named `{0}` or `{1}` in class `{2}`"
            .format(func_name, 'ex_'+func_name, self.__class__.__name__))
432770
public Object getFunctionWithNamedValues(Object coll, Key key, Object[] args, Object defaultValue) {
	return variableUtil.callFunctionWithNamedValues(this, coll, key, args, false, defaultValue);
    }