Retrieves a CachedResponse for the provided key.

        Args:
            key (string)

        Returns:
            A CachedResponse with is_found status and value.
516815
def get_cached_response(cls, key):
        
        request_cached_response = DEFAULT_REQUEST_CACHE.get_cached_response(key)
        if not request_cached_response.is_found:
            django_cached_response = cls._get_cached_response_from_django_cache(key)
            cls._set_request_cache_if_django_cache_hit(key, django_cached_response)
            return django_cached_response

        return request_cached_response
914861
def get(self, key):
        

        if not key in self._actions:
            return None
        if not key in self._cache:
            self._cache[key] = self._actions[key]()

        return self._cache[key]
1310210
def get(self, key: Any, default: Any = None) -> Any:
        
        return self._req_cookies.get(key, default)
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
284220
def get(self, key):  
        
        res = self.connection.get(key)
        print(res)
        return res
268986
def get(key, profile=None):
    '''
    
    '''
    conn = salt.utils.memcached.get_conn(profile)
    return salt.utils.memcached.get(conn, key)
289105
def retrieve(self, key):
        """"""
        column_file = os.path.join(self._hash_dir, '%s.json' % key)
        cache_file = os.path.join(self._hash_dir, '%s.npy' % key)

        if os.path.exists(cache_file):
            data = np.load(cache_file)
            if os.path.exists(column_file):
                with open(column_file, 'r') as json_file:
                    columns = json.load(json_file)
                data = pd.DataFrame(data, columns=columns)
        else:
            return None

        return data
26384
def get(self, key):
        '''
        
        '''
        if key in self._data_fields:
            return self._data_fields[key]
        if key in self._sub_reports:
            return self._sub_reports[key]
        return None
927746
function cacheGet(key, options) {
    if (shouldCache(options)) {
      return;
    }

    if (self.options.cache === 'memory') {
      return self.cache[key];
    }

    return self.options.cache.get(key);
  }
449320
def get(self, key) -> str:
        
        # TODO: get is creating files when a key is given which is more than
        # the store size
        chunk_no, offset = self._get_key_location(key)
        with self._openChunk(chunk_no) as chunk:
            return chunk.get(str(offset))
34366
def get(self, key: str) -> Optional[str]:
        
        return get_config(self.full_key(key))
690387
def get(key, service=None, profile=None):  # pylint: disable=W0613
    '''
    
    '''
    client = _get_conn(profile)
    result = client.get(key)
    return result.value
624674
def _make_cache_key(key_prefix):
    
    if callable(key_prefix):
        cache_key = key_prefix()
    elif '%s' in key_prefix:
        cache_key = key_prefix % request.path
    else:
        cache_key = key_prefix

    cache_key = cache_key.encode('utf-8')

    return cache_key
137130
def get_item(self, key):
        
        result = self._db.search(self._urls.key == key)
        return result[0].get('url') if result else None
15251
def _find_matching_instance(cache_key):
  
  infos = get_all()
  candidates = [info for info in infos if info.cache_key == cache_key]
  for candidate in sorted(candidates, key=lambda x: x.port):
    # TODO(@wchargin): Check here that the provided port is still live.
    return candidate
  return None
1112258
def get(self, key):
    '''
    '''
    value = self.cache_datastore.get(key)
    return value if value is not None else self.child_datastore.get(key)
716787
def getCachedOrUpdatedValue(self, key):
        
        try:
            return self._VALUES[key]
        except KeyError:
            return self.getValue(key)