Get key from Rinda server.
976923
def get_unit(key)
    @prior_values[key] ||= 0.0
    begin
      key, value = @space.take([key, Float], @timeout)
      @prior_values[key] = value
    rescue Rinda::RequestExpiredError => exception
      if source_factories.empty?
        value = @prior_values[key]
      else
        value = super
      end
    end
    value
  end
623278
def get_pubkey(self):
        '''
        
        '''
        if '__master_opts__' in self.opts and \
                self.opts['__master_opts__'].get('ssh_use_home_key') and \
                os.path.isfile(os.path.expanduser('~/.ssh/id_rsa')):
            priv = os.path.expanduser('~/.ssh/id_rsa')
        else:
            priv = self.opts.get(
                    'ssh_priv',
                    os.path.join(
                        self.opts['pki_dir'],
                        'ssh',
                        'salt-ssh.rsa'
                        )
                    )
        pub = '{0}.pub'.format(priv)
        with salt.utils.files.fopen(pub, 'r') as fp_:
            return '{0} rsa root@master'.format(fp_.read().split()[1])
451572
def key(self, att=None):
        """"""
        if att is not None:
            return self._key[self.id][att]
        else:
            return self._key[self.id]
1246109
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return RouterAlert(key)
        if key not in RouterAlert._member_map_:
            extend_enum(RouterAlert, key, default)
        return RouterAlert[key]
234197
def hgetall(key, host=None, port=None, db=None, password=None):
    '''
    
    '''
    server = _connect(host, port, db, password)
    return server.hgetall(key)
871363
def get_key(cls, key):
        ""
        return cls.get().get(key, cls.DEFAULT_CONFIG.get(key,None))
107536
def get(self, key, recursive=False, sorted=False, quorum=False,
            wait=False, wait_index=None, timeout=None):
        """"""
        url = self.make_key_url(key)
        params = self.build_args({
            'recursive': (bool, recursive or None),
            'sorted': (bool, sorted or None),
            'quorum': (bool, quorum or None),
            'wait': (bool, wait or None),
            'waitIndex': (int, wait_index),
        })
        if timeout is None:
            # Try again when :exc:`TimedOut` thrown.
            while True:
                try:
                    try:
                        res = self.session.get(url, params=params)
                    except:
                        self.erred()
                except (TimedOut, ChunkedEncodingError):
                    continue
                else:
                    break
        else:
            try:
                res = self.session.get(url, params=params, timeout=timeout)
            except ChunkedEncodingError:
                raise TimedOut
            except:
                self.erred()
        return self.wrap_response(res)
379153
def get(self, key, *, encoding=_NOTSET):
        """"""
        return self.execute(b'GET', key, encoding=encoding)
894273
def get_resource_key(self):
        """"""
        model = self.get_model()
        if model:
            return get_model_table(model)
        else:
            return self.get_name()
966165
def get(key, opts = {})
      response = api_execute(key_endpoint + key, :get, params: opts)
      Response.from_http_response(response)
    end
129956
def get(self, key, default=None):
        """"""
        if key not in self.table:
            return default

        return self[key]
51464
def get(self, key, default=None):
        
        try:
            result = self._loads(self._client.hget(self.key_prefix, key))
            assert result is not None
            return result
        except (AssertionError, KeyError):
            return default or self._default
1118057
def key_from_req(req):
    """"""
    if hasattr(req, "key"):
        # from pkg_resources, such as installed dists for pip-sync
        key = req.key
    else:
        # from packaging, such as install requirements from requirements.txt
        key = req.name

    key = key.replace("_", "-").lower()
    return key
1203653
def get(self, key):
        
        data = r_kv.get(key)
        # data = json.dumps(data) if isinstance(data, str) else data
        # data = json.loads(data) if data else {}

        return build_response(dict(data=data, code=200))
1039641
def keys_info(cls, fqdn, key):
        """"""
        return cls.json_get('%s/domains/%s/keys/%s' %
                            (cls.api_url, fqdn, key))
1083064
def get(self, key, transaction=None):
    """"""
    return self._client.get(key, transaction=transaction)
201453
def get(self, key):
        """"""
        try:
            data = self._data[key]
        except KeyError:
            raise StoreKeyNotFound(key)
        return data