Gets a value by a key.

    Args:
      key (str): Key to retrieve the value.

    Returns: Retrieved value.
768019
def get(self, key):
    
    self._create_file_if_none_exists()
    with open(self.filename, 'rb') as file_object:
      cache_pickle = pickle.load(file_object)
      val = cache_pickle.get(key, None)
      return val
170851
def get(self, key):
        
        data = self._store.get(key)
        if not data:
            return None
        value, expire = data
        if expire and time.time() > expire:
            del self._store[key]
            return None
        return value
282005
public Object get(Object key)
    {
        if (key==null)
            return _nullValue;
        if (key instanceof String)
            return get((String)key);
        return get(key.toString());
    }
343076
def get(self, key):
        
        if key == None or key == '':
            return None
        elif key.find('.') > 0:
            return RecursiveObjectReader.get_property(self, key)
        else:
            return super(Parameters, self).get(key)
1251477
def get(self, key):
        
        if not self.servers:
            return self.miss

        key = self._qualified_key(key)
        hashed_key = self.key_hasher(key)
        entry = self.client.get(hashed_key)

        if isinstance(entry, tuple) and len(entry) == 2:
            key_, result = entry
            if key_ == key:
                self.logger("HIT: %s", key)
                return result

        self.logger("MISS: %s", key)
        return self.miss
82566
def get(self, key):
        

        if not self.is_loaded:
            self.retrieve()

            self.is_loaded = True

        if self.has(key=key):
            return self.data[key]
        else:
            return None
189989
def get(self, key, default_val=None, require_value=False):
        
        val = dict.get(self, key, default_val)
        if val is None and require_value:
            raise KeyError('key "%s" not found' % key)
        if isinstance(val, dict):
            return AttributeDict(val)
        return val
972368
def get(self, key, default=None):
        
        val = self._store.get(key)

        if val is None:
            return value(default)

        return val
179780
def get(self, key, default=None, type_=None):
        
        try:
            rv = self[key]
        except KeyError:
            return default
        if type_ is not None:
            try:
                rv = type_(rv)
            except ValueError:
                rv = default
        return rv
1205662
def key(self, key=""):
    
    params = join_params(self.parameters, {"key": key})

    return self.__class__(**params)
2548
def get(self, key):
        
        return self._object_class(json.loads(self._db[key]))
803835
def get(self, key, default=None):
        
        if hasattr(self.obj, key):
            return getattr(self.obj, key)
        return self.data.get(key, default)
655370
def check_key(self, key: str) -> bool:
        
        keys = self.get_keys()
        return key in keys
218473
def _get_by_key(self, key, handle_not_found=True):
        
        resolution = self._get_item_or_section(key, handle_not_found=handle_not_found)
        if self.settings.key_getter:
            return self.settings.key_getter(parent=self, subject=resolution)
        else:
            return resolution
201453
def get(self, key):
        """"""
        try:
            data = self._data[key]
        except KeyError:
            raise StoreKeyNotFound(key)
        return data
915785
def value(self, key, default=None):
        
        curr = self._stack[-1]
        return curr.get(key, default)
728174
def get(self, key, default=None, msg_if_none=None):
        
        out = getattr(self, key, default)

        if (out is None) and (msg_if_none is not None):
            raise ValueError(msg_if_none)

        return out