Query widget option.

        :param key: option name
        :type key: str
        :return: value of the option

        To get the list of options for this widget, call the method :meth:`~LinkLabel.keys`.
268
def cget(self, key):
        
        if key is "link":
            return self._link
        elif key is "hover_color":
            return self._hover_color
        elif key is "normal_color":
            return self._normal_color
        elif key is "clicked_color":
            return self._clicked_color
        else:
            return ttk.Label.cget(self, key)
1060402
def get(self, key, *val):
        
        data = self.get_data()
        if data is not None:
            return data.get(key, *val)
        if val:
            return val[0]
        raise KeyError(key)
170743
def get_options(self):
        
        query = 'SET'
        return dict(row[:2] for row in self.con.fetchall(query))
1114064
def show_key(self, value):
        
        keys = self.get_keys()
        keys = [x for x in keys if x['label'] == value]
        if len(keys) == 0:
            raise Exception("Unknown key")
        else:
            return keys[0]
882303
def get_item(self, key):
        
        keys = list(self.keys())

        # make sure it exists
        if not key in keys:
            self.print_message("ERROR: '"+str(key)+"' not found.")
            return None

        try:
            x = eval(self.get_value(1,keys.index(key)))
            return x

        except:
            self.print_message("ERROR: '"+str(self.get_value(1,keys.index(key)))+"' cannot be evaluated.")
            return None
1101392
function getOptionLabel(option, labelKey) {
  let optionLabel;

  if (typeof option === 'string') {
    optionLabel = option;
  }

  if (isPlainObject(option)) {
    if (typeof labelKey === 'string') {
      optionLabel = option[labelKey];
    } else if (isFunction(labelKey)) {
      optionLabel = labelKey(option);
    }
  }

  invariant(
    typeof optionLabel === 'string',
    'One or more options does not have a valid label string. Check the ' +
    '`labelKey` prop to ensure that it matches the correct option key and ' +
    'provides a string for filtering and display.'
  );

  return optionLabel;
}
561482
def get_key(self, key):
        
        return self.__mapping.get(self.type(key), self.__getitem__)(key)
384262
def list_keys(self, label=None):
        
        _filter = utils.NestedDict({})
        if label:
            _filter['sshKeys']['label'] = utils.query_filter(label)

        return self.client['Account'].getSshKeys(filter=_filter.to_dict())
735472
def get(self, key):
        
        keystr = str(key)
        res = None

        try:
            res = self.ctx[keystr]
        except KeyError:
            for k, v in self.ctx.items():
                if "name" in v and v["name"].lower() == keystr.lower():
                    res = v
                    break

        return res
74419
def _get_option(target_obj, key):
    
    getter_name = 'get_{key}'.format(**locals())
    by_attribute = functools.partial(getattr, target_obj, key)
    getter = getattr(target_obj, getter_name, by_attribute)
    return getter()
1164658
def get(self, key):
    ''''''
    value = super(SymlinkDatastore, self).get(key)
    return self._follow_link(value)
992154
def get(self, key, default=None):
        
        if key in self:
            return self.items_dict[self.__dict__[str(type(key))][key]]
        else:
            return default
1227577
def append_query_param(self, key, value):
        
        values = self.query_param(key, as_list=True, default=[])
        values.append(value)
        return self.query_param(key, values)
401010
def get_label(key):
    
    if key in rel:
        if mpl.rcParams['text.usetex']:
            return rel[key]['label_latex']
        else:
            return rel[key]['label_mpl']
    else:
        return key
349934
def get_api_key(key, request_options = {})
      client.get(Protocol.index_key_uri(name, key), :read, request_options)
    end
1372868
def key(self, key, strictkey=None):
        
        return self._select(self._pointer.key(key, strictkey))
34366
def get(self, key: str) -> Optional[str]:
        
        return get_config(self.full_key(key))