Collect meta data (eg. from page via stdwrap)
504549
protected function collectMetaDataFromPage()
    {
        // #################
        // Page meta
        // #################

        // description
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['description_page'],
            $this->tsSetupSeo['conf.']['description_page.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['description'] = $tmp;
        }

        // keywords
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['keywords_page'],
            $this->tsSetupSeo['conf.']['keywords_page.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['keywords'] = $tmp;
        }

        // title
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['title_page'],
            $this->tsSetupSeo['conf.']['title_page.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['title'] = $tmp;
        }

        // author
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['author_page'],
            $this->tsSetupSeo['conf.']['author_page.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['author'] = $tmp;
        }

        // email
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['email_page'],
            $this->tsSetupSeo['conf.']['email_page.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['email'] = $tmp;
        }

        // last-update
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['lastUpdate_page'],
            $this->tsSetupSeo['conf.']['lastUpdate_page.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['lastUpdate'] = $tmp;
        }

        // #################
        // Geo
        // #################

        // tx_metaseo_geo_lat
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['tx_metaseo_geo_lat'],
            $this->tsSetupSeo['conf.']['tx_metaseo_geo_lat.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['geoPositionLatitude'] = $tmp;
        }

        // tx_metaseo_geo_long
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['tx_metaseo_geo_long'],
            $this->tsSetupSeo['conf.']['tx_metaseo_geo_long.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['geoPositionLongitude'] = $tmp;
        }

        // tx_metaseo_geo_place
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['tx_metaseo_geo_place'],
            $this->tsSetupSeo['conf.']['tx_metaseo_geo_place.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['geoPlacename'] = $tmp;
        }

        // tx_metaseo_geo_region
        $tmp = $this->cObj->stdWrap(
            $this->tsSetupSeo['conf.']['tx_metaseo_geo_region'],
            $this->tsSetupSeo['conf.']['tx_metaseo_geo_region.']
        );
        if (!empty($tmp)) {
            $this->pageMeta['geoRegion'] = $tmp;
        }

        // #################
        // Process meta tags
        // #################

        // process page meta data
        foreach ($this->pageMeta as $metaKey => $metaValue) {
            $metaValue = trim($metaValue);

            if (!empty($metaValue)) {
                $this->tsSetupSeo[$metaKey] = $metaValue;
            }
        }
    }
262107
def _GetNestedDict(self, value):
    """"""
    row = {}
    for type_info in value.__class__.type_infos:
      # We only expect the metadata proto to be included as ProtoEmbedded.
      if type_info.__class__.__name__ == "ProtoEmbedded":
        row[type_info.name] = self._GetNestedDict(value.Get(type_info.name))
      else:
        row[type_info.name] = utils.SmartStr(value.Get(type_info.name))

    return row
80343
function () {
				var oView = this.getView(),
					// Collect all possible items from all lists
					aItems = [].concat(
						oView.byId("allList").getItems(),
						oView.byId("apiList").getItems(),
						oView.byId("documentationList").getItems(),
						oView.byId("samplesList").getItems()
					),
					iLen = aItems.length,
					oItem;

				while (iLen--) {
					oItem = aItems[iLen];
					// Access control lazy loading method if available
					if (oItem._getLinkSender) {
						// Set link href to allow open in new window functionality
						oItem._getLinkSender().setHref("#/" + oItem.getCustomData()[0].getValue());
					}
				}
			}
234152
def _getMetadata(self, key):
        """"""
        if self.isClosed:
            raise ValueError("operation illegal for closed doc")

        return _fitz.Document__getMetadata(self, key)
345898
def imagej_metadata(self):
        """"""
        if not self.is_imagej:
            return None
        page = self.pages[0]
        result = imagej_description_metadata(page.is_imagej)
        if 'IJMetadata' in page.tags:
            try:
                result.update(page.tags['IJMetadata'].value)
            except Exception:
                pass
        return result
191363
function mapItem (item) {
  const title = item.pagemap.metatags[0]['og:title'] ||
                item.pagemap.metatags[0]['dc.title'] ||
                item.title

  return {
    title,
    link: item.link,
    date: item.pagemap.metatags[0].date,
    image: item.pagemap.cse_image[0].src,
    author: item.pagemap.metatags[0].author
  }
}
1029329
def _parse_metadata(self, meta):
        
        output = {}
        for name, value in meta.items():
            name = name.lower()
            if name == "summary":
                value = textile(value)
            output[name] = self.process_metadata(name, value)
        return output
289221
def _GetMetadataForClients(self, client_urns):
    """"""

    result = {}
    metadata_to_fetch = set()

    for urn in client_urns:
      try:
        result[urn] = self._cached_metadata[urn]
      except KeyError:
        metadata_to_fetch.add(urn)

    if metadata_to_fetch:
      if data_store.RelationalDBEnabled():
        client_ids = set(urn.Basename() for urn in metadata_to_fetch)
        infos = data_store.REL_DB.MultiReadClientFullInfo(client_ids)

        fetched_metadata = [
            export.GetMetadata(client_id, info)
            for client_id, info in infos.items()
        ]
      else:
        client_fds = aff4.FACTORY.MultiOpen(
            metadata_to_fetch, mode="r", token=self.token)

        fetched_metadata = [
            export.GetMetadataLegacy(client_fd, token=self.token)
            for client_fd in client_fds
        ]

      for metadata in fetched_metadata:
        metadata.source_urn = self.source_urn

        self._cached_metadata[metadata.client_urn] = metadata
        result[metadata.client_urn] = metadata
        metadata_to_fetch.remove(metadata.client_urn)

      for urn in metadata_to_fetch:
        default_mdata = export.ExportedMetadata(source_urn=self.source_urn)
        result[urn] = default_mdata
        self._cached_metadata[urn] = default_mdata

    return [result[urn] for urn in client_urns]
1186279
function getMeta(object) {
  assertObject(object);

  let data = {};
  if (hasOwnSymbol(object, metaSymbol)) {
    Object.assign(data, object[metaSymbol] || {});
  }
  Object.assign(data, metadata.get(object) || {});

  if (data['~inheritsMeta']) {
    return Object.assign({}, getMeta(data['~inheritsMeta']()), data);
  } else {
    return data;
  }
}
308948
def copy_meta_from(self, ido):
        """"""
        self._active_scalar_info = ido.active_scalar_info
        self._active_vectors_info = ido.active_vectors_info
        if hasattr(ido, '_textures'):
            self._textures = ido._textures
728384
def _get_pasteas_data(self, dim, obj):
        

        if dim == 0:
            return [[repr(obj)]]
        elif dim == 1:
            return [[repr(o)] for o in obj]
        elif dim == 2:
            return [map(repr, o) for o in obj]
1032234
def get_template(template_name, data_dir=None, url=None, resume=True, verbose=1):
    """"""
    warn(DEPRECATION_MSG)
    if template_name.startswith('tpl-'):
        template_name = template_name[4:]

    # An aliasing mechanism. Please avoid
    template_name = TEMPLATE_ALIASES.get(template_name, template_name)
    return get_dataset(template_name, dataset_prefix='tpl-', data_dir=data_dir,
                       url=url, resume=resume, verbose=verbose)
323776
def stk_metadata(self):
        """"""
        if not self.is_stk:
            return None
        page = self.pages[0]
        tags = page.tags
        result = {}
        result['NumberPlanes'] = tags['UIC2tag'].count
        if page.description:
            result['PlaneDescriptions'] = page.description.split('\0')
            # result['plane_descriptions'] = stk_description_metadata(
            #    page.image_description)
        if 'UIC1tag' in tags:
            result.update(tags['UIC1tag'].value)
        if 'UIC3tag' in tags:
            result.update(tags['UIC3tag'].value)  # wavelengths
        if 'UIC4tag' in tags:
            result.update(tags['UIC4tag'].value)  # override uic1 tags
        uic2tag = tags['UIC2tag'].value
        result['ZDistance'] = uic2tag['ZDistance']
        result['TimeCreated'] = uic2tag['TimeCreated']
        result['TimeModified'] = uic2tag['TimeModified']
        try:
            result['DatetimeCreated'] = numpy.array(
                [julian_datetime(*dt) for dt in
                 zip(uic2tag['DateCreated'], uic2tag['TimeCreated'])],
                dtype='datetime64[ns]')
            result['DatetimeModified'] = numpy.array(
                [julian_datetime(*dt) for dt in
                 zip(uic2tag['DateModified'], uic2tag['TimeModified'])],
                dtype='datetime64[ns]')
        except ValueError as exc:
            log.warning('STK metadata: %s: %s', exc.__class__.__name__, exc)
        return result
101844
def read(self):
        """"""
        self.convertRSTmetaToMD()
        self._md = Markdown(extensions=['meta', 'codehilite(linenums=True)'])
        content = self._md.convert(self.source)
        metadata = self._parse_metadata(self._md.Meta)
        return content, metadata
654227
protected function collectMetaDataFromConnector()
    {
        $ret = array();

        $storeMeta = $this->getStoreMeta();

        // Std meta tags
        foreach ($storeMeta['meta'] as $metaKey => $metaValue) {
            if ($metaValue === null) {
                // Remove meta
                unset($this->tsSetupSeo[$metaKey]);
            } elseif (!empty($metaValue)) {
                $this->tsSetupSeo[$metaKey] = trim($metaValue);
            }
        }

        // Custom meta tags
        foreach ($storeMeta['custom'] as $metaKey => $metaValue) {
            if ($metaValue === null) {
                // Remove meta
                unset($ret[$metaKey]);
            } elseif (!empty($metaValue)) {
                $ret[$metaKey] = trim($metaValue);
            }
        }

        return $ret;
    }
552403
def get_metadata(session, games):
    """"""
    for data in games.values():
        parsed = make_scrape_request(session, data['url'])
    return {
        'ladders': get_ladders_metadata(session, parsed)
    }
1018334
private void returnMetadata(Buffer buffer) {
        Callback<SketchMetadata> callback = getFirstCallback(BeanMessageID.BL_GET_META);
        if (callback != null) {
            callback.onResult(SketchMetadata.fromPayload(buffer));
        }
    }