Retrieves a Storage Object for the specified key in this bucket.

    The object need not exist.

    Args:
      key: the key of the object within the bucket.
    Returns:
      An Object instance representing the specified key.
8265
def object(self, key):
    
    return _object.Object(self._name, key, context=self._context)
1112258
def get(self, key):
    '''
    '''
    value = self.cache_datastore.get(key)
    return value if value is not None else self.child_datastore.get(key)
229024
def get(self, key, default=None):
        
        try:
            val = self[key]
        except KeyError:
            val = default
        return val
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
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
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]
242464
def get(self, key):
    '''
    '''
    path = self.object_path(key)
    return self._read_object(path)
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))
483096
def get(key)
      key = :root if key == ''
      key = key.to_sym
      return @store[key] if @store[key]
      return if @loaded_objects >= @available_objects

      # check disk
      return if @notfound[key]
      obj = @serializer.deserialize(key)
      if obj
        @loaded_objects += 1
        put(key, obj)
      else
        @notfound[key] = true
        nil
      end
    end
502512
def get_upload_key(self):
        

        if not hasattr(self, '_upload_key'):
            self._upload_key = self.get_storage().bucket.get_key(
                self.cleaned_data['key_name'])
        return self._upload_key
1273033
def get(self, key, default=_NoValue):
        
        self._checkType(key, "key")
        if default is _NoValue:
            return self._jconf.get(key)
        else:
            if default is not None:
                self._checkType(default, "default")
            return self._jconf.get(key, default)
137130
def get_item(self, key):
        
        result = self._db.search(self._urls.key == key)
        return result[0].get('url') if result else None
195429
async def create(cls, key: str):
        
        return cls._object(await cls._handler.create(key=key))
1165629
def load(self, key):
        

        # Turn the key into a BucketKey
        if isinstance(key, basestring):
            key = BucketKey.decode(key)

        # Make sure the uuids match
        if key.uuid != self.uuid:
            raise ValueError("%s is not a bucket corresponding to this limit" %
                             key)

        # If the key is a version 1 key, load it straight from the
        # database
        if key.version == 1:
            raw = self.db.get(str(key))
            if raw is None:
                return self.bucket_class(self.db, self, str(key))
            return self.bucket_class.hydrate(self.db, msgpack.loads(raw),
                                             self, str(key))

        # OK, use a BucketLoader
        records = self.db.lrange(str(key), 0, -1)
        loader = BucketLoader(self.bucket_class, self.db, self, str(key),
                              records)

        return loader.bucket
601136
def get(self, key):
    '''
    '''
    self.logger.info('%s: get %s' % (self, key))
    value = super(LoggingDatastore, self).get(key)
    self.logger.debug('%s: %s' % (self, value))
    return value
41063
def storage_uri_for_key(key):
    
    if not isinstance(key, boto.s3.key.Key):
        raise InvalidUriError('Requested key (%s) is not a subclass of '
                              'boto.s3.key.Key' % str(type(key)))
    prov_name = key.bucket.connection.provider.get_provider_name()
    uri_str = '%s://%s/%s' % (prov_name, key.bucket.name, key.name)
    return storage_uri(uri_str)
1191572
Bucket getBucketForKey(Object key)
    {
        int index = getBucketIndexForKey(key);

        Bucket bucket = buckets[index];
        if (bucket == null)
        {
            synchronized (bucketLock)
            {
                bucket = buckets[index];
            }
        }

        return bucket;
    }