For the given client_id return what is
        cached.
338837
def _get_client_from_cache(self, client_id):
        
        data = self._read_uaa_cache()

        # Only if we've cached any for this issuer
        if self.uri not in data:
            return

        for client in data[self.uri]:
            if client['id'] == client_id:
                return client
316765
public static function getUidByClientId($client_id)
    {
        $data = static::select(array('uid'), array('client_id'=>array($client_id)));
        foreach ($data as $local_ip => $buffer_array) {
            foreach ($buffer_array as $local_port => $items) {
                //$items = ['connection_id'=>['uid'=>x, 'group'=>[x,x..], 'session'=>[..]], 'client_id'=>[..], ..];
                foreach ($items as $info) {
                    return $info['uid'];
                }
            }
        }
    }
1140860
def get(self, id):
        
        url = self._url('%s' % (id))
        return self.client.get(url)
1330990
def get(cls, id):
        

        # cached?
        if CACHE:
            if id in _cache['VRF']:
                log.debug('cache hit for VRF %d' % id)
                return _cache['VRF'][id]
            log.debug('cache miss for VRF %d' % id)

        try:
            vrf = VRF.list({ 'id': id })[0]
        except IndexError:
            raise NipapNonExistentError('no VRF with ID ' + str(id) + ' found')

        _cache['VRF'][id] = vrf
        return vrf
695516
def cache_id(self) -> str:
        

        if self._cache_id:
            return self._cache_id

        with open(join(expanduser('~'), '.indy_client', 'pool', self.name, '{}.txn'.format(self.name))) as fh_genesis:
            genesis = [json.loads(line) for line in fh_genesis.readlines() if line]

        hps = []
        for gen_txn in genesis:
            hps.append(self.protocol.genesis_host_port(gen_txn))
        hps.sort()  # canonicalize to make order irrelevant
        self._cache_id = ':'.join('{}:{}'.format(hp[0], hp[1]) for hp in hps)

        return self._cache_id
1259487
def init_client(client_id):
    
    if client_id not in drivers:
        drivers[client_id] = init_driver(client_id)
    return drivers[client_id]
52884
public function getClientDetails($client_id)
    {
        $result = $this->collection('client_table')->findOne(array('client_id' => $client_id));
        return is_null($result) ? false : $result;
    }
1133991
def get(cls, user_id, client_id):
        
        return cls.query.filter_by(
            user_id=user_id,
            client_id=client_id,
        ).first()
473045
def client(self, id):
    """"""

    return self.query(Client).filter(Client.id==id).one()
917880
def get_cached(self):
        '''
        
        '''
        msg = self.serial.dumps('minions')
        self.creq_out.send(msg)
        min_list = self.serial.loads(self.creq_out.recv())
        return min_list
773698
def get_client_profile(self, client_id):
        
        try:
            response = self._table.get_item(Key={'client_id': client_id})
            compressed_bytes = response['Item']['json_payload'].value
            json_byte_data = zlib.decompress(compressed_bytes)
            json_str_data = json_byte_data.decode('utf8')
            return json.loads(json_str_data)
        except KeyError:
            # No client ID found - not really an error
            return None
        except Exception as e:
            # Return None on error.  The caller in ProfileFetcher will
            # handle error logging
            msg = "Error loading client data for {}.  Error: {}"
            self.logger.debug(msg.format(client_id, str(e)))
            return None
581591
def MultiReadClientMetadata(self, client_ids):
    """"""
    res = {}
    for client_id in client_ids:
      md = self.metadatas.get(client_id, None)
      if md is None:
        continue

      res[client_id] = rdf_objects.ClientMetadata(
          certificate=md.get("certificate"),
          fleetspeak_enabled=md.get("fleetspeak_enabled"),
          first_seen=md.get("first_seen"),
          ping=md.get("ping"),
          clock=md.get("clock"),
          ip=md.get("ip"),
          last_foreman_time=md.get("last_foreman_time"),
          last_crash_timestamp=md.get("last_crash_timestamp"),
          startup_info_timestamp=md.get("startup_info_timestamp"))

    return res
914607
def search_client_by_id(self, clientID) -> Client:
        
        for c in self.clients:
            if c.id == clientID:
                return c
        return None
1051364
public function getClientDetails($client_id)
    {
        if (!isset($this->clientCredentials[$client_id])) {
            return false;
        }

        $clientDetails = array_merge(array(
            'client_id'     => $client_id,
            'client_secret' => null,
            'redirect_uri'  => null,
            'scope'         => null,
        ), $this->clientCredentials[$client_id]);

        return $clientDetails;
    }
236394
def _cached_by_domain(api_name):
    

    def wrapped(func):
        def decorated(self, domains):
            if not self._cache:
                return func(self, domains)

            all_responses = self._cache.bulk_lookup(api_name, domains)
            domains = list(set(domains) - set(all_responses))

            if domains:
                response = func(self, domains)

                if not response:
                    raise ResponseError("No response for uncached domains")

                for domain in response:
                    self._cache.cache_value(api_name, domain, response[domain])
                    all_responses[domain] = response[domain]

            return all_responses
        return decorated
    return wrapped
940112
public CachedDbEntity getCachedEntity(Class<?> type, String id) {
    Class<?> cacheKey = cacheKeyMapping.getEntityCacheKey(type);
    Map<String, CachedDbEntity> entitiesByType = cachedEntites.get(cacheKey);
    if(entitiesByType != null) {
      return entitiesByType.get(id);
    } else {
      return null;
    }
  }
207227
def get_cached_response(self, key):
        
        cached_value = self.data.get(key, _CACHE_MISS)
        is_found = cached_value is not _CACHE_MISS
        return CachedResponse(is_found, key, cached_value)