Adds the given metadata dict to the existing metadata for the specified
        webhook.
961174
def update_webhook_metadata(self, policy, webhook, metadata):
        
        return self.manager.update_webhook_metadata(self, policy, webhook,
                metadata)
1047993
public T addMetaTag(String key, String value) {
    checkValidKey(key);
    checkNotEmpty(value, "value must not be empty");
    meta_tags.add("-metadata");
    meta_tags.add(key + "=" + value);
    return getThis();
  }
936666
def append(self, meta):
        
        assert isinstance(meta, BasicPlayMeta)
        self._metas.append(meta)
797418
def add_webhook(self, name, metadata=None):
        
        return self.manager.add_webhook(self.scaling_group, self, name,
                metadata=metadata)
154050
private void addMetadataFromIFD(IFD ifd, String key, boolean exif) {
    metadata.add(key, ifd);
    for (TagValue tag : ifd.getMetadata().getTags()) {
      if (tag.getCardinality() == 1) {
        abstractTiffType t = tag.getValue().get(0);
        if (t.isIFD()) {
          addMetadataFromIFD((IFD) t, key, true);
        } else if (t.containsMetadata()) {
          try {
            Metadata meta = t.createMetadata();
            metadata.addMetadata(meta);
          } catch (Exception ex) {
            // TODO: What?
          }
        } else {
          if (exif)
            t.setContainer("EXIF");
          metadata.add(tag.getName(), t);
        }
      } else {
        if (exif)
          tag.setContainer("EXIF");
        metadata.add(tag.getName(), tag);
      }
    }
    if (ifd.hasNextIFD()) {
      addMetadataFromIFD(ifd.getNextIFD(), key, false);
    }
  }
1335300
public ServiceResult<T> addMetadata(String key, Metadata metadata) {
        this.getMetadata().put(key, metadata);
        return this;
    }
807684
def add_meta_line(self, key, value):
        
        meta_line = '##{0}={1}'.format(
            key, value
        )
        logger.info("Adding meta line to vcf: {0}".format(meta_line))
        self.parse_meta_data(meta_line)
        return
87359
def add_hook(self, key_name, hook_name, hook_dict):
        """"""
        kf = self.dct[key_name]
        if 'hooks' not in kf:
            kf['hooks'] = {}
        kf['hooks'][str(hook_name)] = hook_dict
1327225
def add_webhook(self, scaling_group, policy, name, metadata=None):
        
        uri = "/%s/%s/policies/%s/webhooks" % (self.uri_base,
                utils.get_id(scaling_group), utils.get_id(policy))
        body = self._create_webhook_body(name, metadata=metadata)
        # "body" needs to be a list
        body = [body]
        resp, resp_body = self.api.method_post(uri, body=body)
        data = resp_body.get("webhooks")[0]
        return AutoScaleWebhook(self, data, policy, scaling_group)
165099
def add_key(self, key, metadata=""):
        
        data = {
            'key': key,
            'metadata': metadata
        }

        return self.post('createKey', data)
197449
def add_metadata(self, operands):
        
        if not isinstance(operands, (list, tuple)):
            raise TypeError("expected a list or tuple of metadata values, "
                            "got %r" % (operands,))
        operands = self._fix_metadata_operands(operands)
        key = tuple(operands)
        if key not in self._metadatacache:
            n = len(self.metadata)
            md = values.MDValue(self, operands, name=str(n))
            self._metadatacache[key] = md
        else:
            md = self._metadatacache[key]
        return md
507702
public AnnotatedTextBuilder addGlobalMetaData(AnnotatedText.MetaDataKey key, String value) {
    metaData.put(key, value);
    return this;
  }
339554
def add_metaclass(metaclass):
    
    vars_to_skip = ('__dict__', '__weakref__')

    def wrapper(cls):
        copied_dict = {
            key: value
            for key, value in cls.__dict__.items()
            if key not in vars_to_skip
        }
        return metaclass(cls.__name__, cls.__bases__, copied_dict)
    return wrapper
564254
public void addMetadata(final RuleMetadata metadata) {

        final RuleMetadata[] newList = new RuleMetadata[this.metadataList.length + 1];

        for (int i = 0; i < this.metadataList.length; i++) {
            newList[i] = this.metadataList[i];
        }
        newList[this.metadataList.length] = metadata;

        this.metadataList = newList;
    }
525903
def add_custom_metadata(self, key, value, meta_type=None):
        
        self.metadata.append({'key': key, 'value': value, 'type': meta_type})
314597
def update_metadata_for_node(self, node, metadata):
        
        return self.manager.update_metadata(self, metadata, node=node)
346471
def add_synonym(self, syn):
        
        n = self.node(syn.class_id)
        if 'meta' not in n:
            n['meta'] = {}
        meta = n['meta']
        if 'synonyms' not in meta:
            meta['synonyms'] = []
        meta['synonyms'].append(syn.as_dict())