Metadata key/value.
498406
async def on_raw_761(self, message):
        
        target, targetmeta = self._parse_user(message.params[0])
        key, visibility = message.params[1:3]
        value = message.params[3] if len(message.params) > 3 else None

        if target not in self._pending['metadata']:
            return
        if target in self.users:
            self._sync_user(target, targetmeta)

        self._metadata_info[target][key] = value
529690
def remove_metadata_key(self, container, key):
        
        meta_dict = {key: ""}
        return self.set_metadata(container, meta_dict)
978365
public function setMetadata($key, $value)
    {
        if (is_null($this->metadataCache))
        {
            $this->metadataCache = [];
        }

        $this->metadataCache[$key] = $value;
    }
1335300
public ServiceResult<T> addMetadata(String key, Metadata metadata) {
        this.getMetadata().put(key, metadata);
        return this;
    }
1079326
def visit_Metadata(self, metadata, *args, **kwargs):
        """"""
        result = OrderedDict()
        put_scalar = lambda name, json_name=None: self.optional_attribute_scalar(result, metadata, name, json_name)
        put_list = lambda name, json_name=None: self.optional_attribute_list(result, metadata, name, json_name)

        put_scalar('name')
        put_scalar('description')
        put_scalar('author')
        put_scalar('copyright')
        put_list('links')
        put_scalar('time')
        put_scalar('keywords')
        put_scalar('bounds')
        put_list('extensions')

        return result
637629
def meta_set(self, key, metafield, value):
        '''  '''
        self._meta.setdefault(key, {})[metafield] = value
        if key in self:
            self[key] = self[key]
1331653
def get_metadata(bind):
    """"""
    if bind == '':
        bind = None
    m = MetaData()
    for t in target_metadata.tables.values():
        if t.info.get('bind_key') == bind:
            t.tometadata(m)
    return m
347897
def meta(self):
        """"""
        if not self._pv.meta_data_property or not self._meta_target:
            return {}

        return getattr(self._meta_target, self._pv.meta_data_property)
484199
def _get_metadata(self):
        """"""
        self.metadata = self.fetch_header()
        self.variables = {g.name for g in self.metadata.grids}
924890
def add_metadata(self, key, value):
        
        self._metadata[key] = value

        # write the current metadata to file
        json.dump(self._metadata, open(self.metadata_filename, 'w'),
                  indent=JSON_INDENT,
                  sort_keys=True)
1236086
def metadata=(metadata)
      @metadata = metadata.map { |k, str| [k, str.to_s] }.to_h
    end
1045098
def _get_metadata_as_string(self):
        """"""
        metalist = []
        for metaname, meta in iteritems(self.metadata):
            message = "Single value in metadata dictionary should be a list!"
            assert isinstance(meta, list), message
            for data in meta:
                if data:
                    metalist.append("!%s_%s = %s" % (self.geotype.capitalize(),
                                                     metaname, data))
        return "\n".join(metalist)
198904
def update_metadata(self, key, value):
        
        old_value = self.contents['metadata'].get(key)
        self.contents['metadata'][key] = value
        self._log('Updated metadata: %s=%s' % (key, value))
        return old_value
75655
public void clearMetaData(Object key) {        if (key == this.key) {
            key = null;
            wmmd = null;
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "MetaData was removed.");
            }
        } else {
        }
    }
704140
def remove_metadata_key(self, obj, key):
        
        meta_dict = {key: ""}
        return self.set_metadata(obj, meta_dict)
745972
function metaData() {
            const meta = {};

            Object.keys(schema.paths).forEach((k) => {
                switch (schema.paths[k].type) {
                    case 'geoPoint':
                        // This allows us to automatically convert valid lng/lat objects
                        // to Datastore.geoPoints
                        meta.geoPointsProps = meta.geoPointsProps || [];
                        meta.geoPointsProps.push(k);
                        break;
                    case 'entityKey':
                        meta.refProps = meta.refProps || {};
                        meta.refProps[k] = true;
                        break;
                    default:
                }
            });

            return meta;
        }
779642
public void addMetadata(Metadata meta) {
    for (String k : meta.keySet()) {
      for (TiffObject to : meta.getList(k)) {
        add(k, to, meta.getMetadataObject(k).isDublinCore(), meta.getMetadataObject(k).getPath());
      }
    }
  }