:meth:`WCacheStorage.put` method implementation
554986
def put(self, result, decorated_function, *args, **kwargs):
		
		self._storage[decorated_function] = result
744687
def do_lzop_put(creds, url, local_path, gpg_key):
    
    assert url.endswith('.lzo')
    blobstore = get_blobstore(storage.StorageLayout(url))

    with tempfile.NamedTemporaryFile(
            mode='r+b', buffering=pipebuf.PIPE_BUF_BYTES) as tf:
        with pipeline.get_upload_pipeline(
                open(local_path, 'rb'), tf, gpg_key=gpg_key):
            pass

        tf.flush()

        clock_start = time.time()
        tf.seek(0)
        k = blobstore.uri_put_file(creds, url, tf)
        clock_finish = time.time()

        kib_per_second = format_kib_per_second(
            clock_start, clock_finish, k.size)

        return kib_per_second
1356417
def put_files(self, files, content_type=None, compress=None, cache_control=None, block=True):
    
    for path, content in tqdm(files, disable=(not self.progress), desc="Uploading"):
      content = compression.compress(content, method=compress)
      self._interface.put_file(path, content, content_type, compress, cache_control=cache_control)
    return self
813087
def put(self, item, block=True, timeout=None, dup_callback=None):
        
        if not self.is_duplicated(item):
            super(CachedQueue, self).put(item, block, timeout)
        else:
            if dup_callback:
                dup_callback(item)
1024729
def put(key, data)
      queue = queues(key)
      return nil unless queue

      @stats[:current_bytes] += data.size
      @stats[:total_items] += 1

      queue.push(data)

      return true
    end
1128241
def put(self, path, data, **options):
        
        data, options = self._update_request(data, options)
        return self.request('put', path, data=data, **options)
513311
def _put_request(self, url, headers, data=None):
        
        return self._session.put(url, headers=headers, data=data)
901120
public synchronized ValT put(KeyT key, ValT value) {
        if (isDiskCacheEnabled) {
            cacheToDisk(key, value);
        }

        return cache.put(key, value);
    }
19201
def _http_put(self, url, data, **kwargs):
        

        kwargs.update({'data': json.dumps(data)})

        return self._http_request('put', url, kwargs)
949206
def put(key, item)
      if @items.include?(key)
        delete(key)
      end
      if @list.size == @max_count
        delete(@list.first)
      end
      @items[key] = item
      @list.push(key)
      item
    end
44657
def put(self, endpoint, **kwargs):
        
        return self._request(requests.put, endpoint, **kwargs)
785367
protected void putToCache(String cacheName, String key, Object value,
            long expireAfterWriteSeconds, long expireAfterAccessSeconds) {
        try {
            ICache cache = getCache(cacheName);
            if (value != null && cache != null) {
                cache.set(key, value, expireAfterWriteSeconds, expireAfterAccessSeconds);
            }
        } catch (CacheException e) {
            LOGGER.warn(e.getMessage(), e);
        }
    }
639314
def set(self, key: str, value: Any) -> None:
        
        wc = self._write_cache()
        if key in wc:
            s = wc[key]
        else:
            s = self._type(object=self._obj, key=key)
        s.value = self._serialize(value)
        s.save()
        self._cache()[key] = s.value
        wc[key] = s
        self._flush_external_cache()
232630
def put(path, options = {}, headers = {}, raw = false)
      request(:put, path, options, headers, raw)
    end
1341210
def put(path, options={}, raw=false, unformatted=true)
      request(:put, path, options, raw, unformatted)
    end
1085290
def put_files(self, files, content_type=None, compress=None, cache_control=None, block=True):
    
    def base_uploadfn(path, content, interface):
      interface.put_file(path, content, content_type, compress, cache_control=cache_control)

    for path, content in files:
      content = compression.compress(content, method=compress)
      uploadfn = partial(base_uploadfn, path, content)

      if len(self._threads):
        self.put(uploadfn)
      else:
        uploadfn(self._interface)

    if block:
      desc = 'Uploading' if self.progress else None
      self.wait(desc)

    return self
889854
def put(self, url, data):
        
        response = self._run_method('PUT', url, data=data)
        log.debug("OUTPUT: %s" % response.content)
        return self._handle_response(url, response)