PUT /machines/:id/metadata/:key.:format
436038
def update(params={})
      machine.request_options = machine.request_options.merge(body: parse_params(params, :metadata).to_json)
      Zcloudjp::Client.put("/machines/#{machine.id}/metadata", machine.request_options)
    end
487267
def put_info(self, key, value):
        
        return self.instance.put_task_info(self.name, key, value)
1158463
def populate_metadata(id)
      extract_metadata(id).each do |k, v|
        send("#{k}=".to_sym, v) # set each property
      end
    end
223170
function(data, done) {
      if(!this._key) {
        done('no key found for metadata');
        return;
      }
      var key = data[this._key.getName()];
      var ix = -1;
      for(var i = 0; i < this._data.length; i++) {
        if(this._data[i][this._key.getName()] === key) {
          ix = i;
          break;
        }
      }
      if(ix === -1) {
        this._data.push(this._clone(data));
      } else {
        this._data[ix] = this._clone(data);
      }
      done(null);
    }
525903
def add_custom_metadata(self, key, value, meta_type=None):
        
        self.metadata.append({'key': key, 'value': value, 'type': meta_type})
880503
def set_metadata(self, queue, metadata, clear=False):
        
        return self._manager.set_metadata(queue, metadata, clear=clear)
253794
def update(key, definition, options = {})
      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
      ret = send_put_request(@conn, ["/v1/query/#{key}"], options, definition, custom_params)
      ret.status == 200
    end
732009
def put!(translations)
      Scope.flatten(translations).each do |key, value|
        storage.write(key, value)
      end
    end
1174719
def put(self, request, bot_id, id, format=None):
              
        return super(HandlerDetail, self).put(request, bot_id, id, format)
34822
def set_(key, value, profile=None):
    '''
    
    '''
    db = _get_db(profile)
    return db.save({'_id': uuid4().hex, key: value})
1134892
def cli(ctx, id_number, new_key, metadata=""):
    
    return ctx.gi.cannedkeys.update_key(id_number, new_key, metadata=metadata)
260253
def push(str, filename = "anomymous", type = :file, content_type = nil)
      metadata = { "filename" => filename, "type" => type.to_s}

      @content_object.meta_headers = metadata
      @content_object.data = str
      @content_object.put
    end
359199
def set_key(key: str, value: typing.List[str], persists: bool = True):
    

    if key.endswith('_path') or key.endswith('_paths'):
        for index in range(len(value)):
            value[index] = environ.paths.clean(value[index])

    if len(value) == 1:
        value = value[0]

    environ.configs.put(**{key: value}, persists=persists)
    environ.configs.save()
    environ.log('[SET]: "{}" to "{}"'.format(key, value))
566950
def put(self, key, value, overwrite=True):
        
        self._get_table()
        s = self.to_string(value)
        log.debug("Storing in key '%s' the object: '%s'" % (key, s))
        self.table.put_item(
            data={
                'key': key,
                'value': s,
            },
            overwrite=overwrite
        )
465935
def cli(ctx, key, metadata=""):
    
    return ctx.gi.cannedkeys.add_key(key, metadata=metadata)
73118
def _put_metadata(self, fs_remote, ds):
        """"""

        from six import text_type
        from fs.errors import ResourceNotFoundError


        identity = ds.identity
        d = identity.dict

        d['summary'] = ds.config.metadata.about.summary
        d['title'] = ds.config.metadata.about.title

        meta_stack = self._meta_infos(ds)

        def do_metadata():
            for path, ident in meta_stack:
                fs_remote.setcontents(path, ident)


        try:
            # Assume the directories already exist
            do_metadata()
        except ResourceNotFoundError:
            # Nope, make them and try again.
            parts = ['vid', 'id', 'vname', 'name']
            for p in parts:
                dirname = os.path.join('_meta', p)
                fs_remote.makedir(dirname, allow_recreate=True, recursive=True)

            do_metadata()
904043
def set_metadata(self, key: str, value: str):
        
        if not isinstance(key, str) or not isinstance(value, str):
            raise TypeError("'key' and 'value' of metadata MUST be strings")
        self.metadata[key] = value