Set metadata for photo. (flickr.photos.setMeta)
185929
def editMeta(self, title=None, description=None):
        """"""
        method = 'flickr.photosets.editMeta'

        if title is None:
            title = self.title
        if description is None:
            description = self.description
            
        _dopost(method, auth=True, title=title, \
               description=description, photoset_id=self.id)
        
        self.__title = title
        self.__description = description
        return True
701331
protected function setup_metadata() {
		if ( ! $this->meta_type ) {
			return;
		}

		$metadata = $this->get_metadata();
		foreach ( $this->get_mapping() as $attribute => $meta ) {
			if ( isset( $metadata[ $meta ] ) ) {
				$this->set_attribute( $attribute, $metadata[ $meta ] );
			}
		}
	}
63173
public void setMetadata(com.google.api.ads.admanager.axis.v201805.VideoMetadata metadata) {
        this.metadata = metadata;
    }
1048923
def setTags(self, tags):
        
        method = 'flickr.photos.setTags'
        tags = uniq(tags)
        _dopost(method, auth=True, photo_id=self.id, tags=tags)
        self._load_properties()
35513
def set_file_metadata(ase, metadata, timeout=None):
    # type: (blobxfer.models.azure.StorageEntity, dict, int) -> None
    
    dir, fpath, _ = parse_file_path(ase.name)
    ase.client.set_file_metadata(
        share_name=ase.container,
        directory_name=dir,
        file_name=fpath,
        metadata=metadata,
        timeout=timeout)
1064026
def set_meta(self, _props):
        """"""
        if self.is_fake:
            return

        props = {}
        for key, value in _props.items():
            key, value = self.meta_mappings.map_set(key, value)
            props[key] = value

        # Pop out tag which we don't want
        props.pop("tag", None)

        self.journal.update_info({})
        self.journal.update_info(props)
        self.journal.save()
623931
def metadata(self):
        """"""
        auto = {u'records': self.size}
        auto.update(self.meta)
        return auto
418547
def _load_metadata(self):
        """"""
        if self._schema is None:
            self._schema = self._get_schema()
            self.datashape = self._schema.datashape
            self.dtype = self._schema.dtype
            self.shape = self._schema.shape
            self.npartitions = self._schema.npartitions
            self.metadata.update(self._schema.extra_metadata)
1206263
def set_meta(self, name, format, *args):
        
        return lib.zcert_set_meta(self._as_parameter_, name, format, *args)
317131
def _update_metadata(self, data, ds_info):
        """"""
        # Metadata from the dataset definition
        data.attrs.update(ds_info)

        # If the file_type attribute is a list and the data is xarray
        # the concat of the dataset will not work. As the file_type is
        # not needed this will be popped here.
        if 'file_type' in data.attrs:
            data.attrs.pop('file_type')

        # Metadata discovered from the file
        data.attrs.update(
            {'platform_name': self.platform_name,
             'sensor': self.sensor,
             'sector': self.sector,
             'yaw_flip': self.meta['yaw_flip']}
        )
        if self.meta['lon0'] is not None:
            # Attributes only available for full disc images. YAML reader
            # doesn't like it if satellite_* is present but None
            data.attrs.update(
                {'satellite_longitude': self.meta['lon0'],
                 'satellite_latitude': self.meta['lat0'],
                 'satellite_altitude': ALTITUDE,
                 'nadir_row': self.meta['nadir_row'],
                 'nadir_col': self.meta['nadir_col'],
                 'area_def_uniform_sampling': self.meta['area_def_uni']}
            )
1109240
public function metaData()
    {
        Meta::setTitle($this->title)
            ->set("description", $this->content())
            ->set("author", ($this->user ? $this->user->firstName." ".$this->user->lastName : null))
            ->set("og:type", "article", "property")
            ->set("og:title", $this->title, "property")
            ->set("og:description", $this->content(), "property")
            ->set("og:url", $this->href, "property")
            ->setImageOG(($this->hasFeaturedImage() ? $this->featuredImage : null))
            ->setArticleOG($this)
            ->setHrefLangData($this)
            ->setCanonical($this->href)
            ->setWildcards(
                [
                '{{categoryTitle}}'=>($this->hasCategory() ? $this->category->title :  null),
                '{{title}}' => $this->title,
                '{{sitename}}' => settings('siteTitle')
                ]
            );

        return;
    }
824679
def copy_metadata(self, other):
        
        logging.info("Copying metadata")
        # copy attributes
        for key in self.attrs.keys():
            other.attrs[key] = self.attrs[key]
1147994
def set_tag(self, namespace, repository, tag, image_id):
        """"""
        return self._http_call(self.TAGS + '/' + tag, put, data=image_id,
                               namespace=namespace, repository=repository)
1324138
private static Set<String> imageOrientationsOf(ImageMetadata metadata) {

    String exifIFD0DirName = new ExifIFD0Directory().getName();

    Tag[] tags = Arrays.stream(metadata.getDirectories())
            .filter(dir -> dir.getName().equals(exifIFD0DirName))
            .findFirst()
            .map(Directory::getTags)
            .orElseGet(() -> new Tag[0]);

    return Arrays.stream(tags)
            .filter(tag -> tag.getType() == 274)
            .map(Tag::getRawValue)
            .collect(Collectors.toSet());
  }
880503
def set_metadata(self, queue, metadata, clear=False):
        
        return self._manager.set_metadata(queue, metadata, clear=clear)
741691
def _set_blob_metadata(self, sd, metadata):
        # type: (SyncCopy, blobxfer.models.synccopy.Descriptor, dict) -> None
        
        blobxfer.operations.azure.blob.set_blob_metadata(
            sd.dst_entity, metadata)
        if blobxfer.util.is_not_empty(sd.dst_entity.replica_targets):
            for ase in sd.dst_entity.replica_targets:
                blobxfer.operations.azure.blob.set_blob_metadata(ase, metadata)
896227
def set_metadata(self, metadata_dict):
        
        if metadata_dict is None:
            return

        existing_metadata = []
        for m in self.metadata:
            existing_metadata.append(m.key)
            if m.key in metadata_dict:
                if m.value != metadata_dict[m.key]:
                    m.value = metadata_dict[m.key]


        for k, v in metadata_dict.items():
            if k not in existing_metadata:
                m_i = Metadata(key=str(k),value=str(v))
                self.metadata.append(m_i)

        metadata_to_delete =  set(existing_metadata).difference(set(metadata_dict.keys()))
        for m in self.metadata:
            if m.key in metadata_to_delete:
                get_session().delete(m)