Gets the metadata for all alt_texts.

        return: (osid.Metadata) - metadata for the alt_texts
        *compliance: mandatory -- This method must be implemented.*
547398
def get_alt_texts_metadata(self):
        
        metadata = dict(self._alt_texts_metadata)
        metadata.update({'existing_string_values': [t['text'] for t in self.my_osid_object_form._my_map['altTexts']]})
        return Metadata(**metadata)
1221709
def get_metadata(self):
        
        metadata_path = "{}/{}/{}".format(self.url,
                                          self.metadata_dir,
                                          self.metadata_file)
        metadata_sig_path = "{}/{}/{}.sig".format(self.url.rstrip('/'),
                                                  self.metadata_dir,
                                                  self.metadata_file)
        # load metadata
        req = requests.get(metadata_path)
        if req.status_code is 200:
            raw_metadata = req.content
        else:
            raise RepositoryError(metadata_path, ("status code not 200: "
                                                  "{}".format(req.status_code)))

        if self.gpg_verify:
            self.verify_data_signature(metadata_sig_path, metadata_path,
                                       raw_metadata)

        return self.parse_metadata(raw_metadata)
484199
def _get_metadata(self):
        """"""
        self.metadata = self.fetch_header()
        self.variables = {g.name for g in self.metadata.grids}
462708
def get_metadata(self):
        
        if self._metadata is None:
            self._metadata = ImageMetadata()
        inspect_to_metadata(self._metadata, self.inspect(refresh=True))
        return self._metadata
551195
def get_metadata():
    
    motifs = _load_motifs()

    motif_names = sorted(list(motifs.keys()))
    df = pd.Series(motif_names).str.split(expand=True)
    df.rename(columns={0: "PWM_id", 1: "info1", 2: "info2"}, inplace=True)

    # compute the consensus
    consensus = pd.Series([PWM(motifs[m]).get_consensus() for m in motif_names])
    df["consensus"] = consensus
    return df
1099236
def metadata(self):
        """"""
        md = self.xml(src="docProps/core.xml")
        if md is None:
            md = XML(root=etree.Element("{%(cp)s}metadata" % self.NS))
        return md.root
1136013
def get_description_metadata(self):
        """"""
        metadata = dict(self.my_osid_object_form._description_metadata)
        metadata.update({'read_only': True})
        return Metadata(**metadata)
509258
def get_descriptions_metadata(self):
        
        metadata = dict(self._descriptions_metadata)
        metadata.update({'existing_string_values': [t['text'] for t in self.my_osid_object_form._my_map['descriptions']]})
        return Metadata(**metadata)
1003677
def metadata(self):
        """"""

        from sqlalchemy import MetaData

        metadata = MetaData(bind=self.engine, schema=self._schema)

        metadata.reflect(self.engine)

        return metadata
843336
def get_display_names_metadata(self):
        
        metadata = dict(self._display_names_metadata)
        metadata.update({'existing_string_values': [t['text'] for t in self.my_osid_object_form._my_map['displayNames']]})
        return Metadata(**metadata)
922190
def get_license_metadata(self):
        
        metadata = dict(self._mdata['license'])
        metadata.update({'existing_string_values': self._my_map['license']})
        return Metadata(**metadata)
1300794
def parse_metadata(self):
        """"""

        all_models = defaultdict(list)

        with open(self.metadata_index_json) as f:
            loaded = json.load(f)

        for m in loaded['index']:
            all_models[m['uniprot_ac']].append(m)

        self.all_models = dict(all_models)
406190
def get_provider_metadata(self):
        
        metadata = dict(self._mdata['provider'])
        metadata.update({'existing_id_values': self._my_map['providerId']})
        return Metadata(**metadata)
204609
def metadata(access_token, text): # (Legacy)
    '''
	
	'''

    headers = {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer ' + str(access_token)
	}

    payload = {'text': text}
    request = requests.post(metadata_url, json=payload, headers=headers)
    if request.status_code == 201:
        metadata = request.json()
        return metadata

    return {'status': request.status_code, "message": request.text}
863226
def get_composition_metadata(self):
        
        # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template
        metadata = dict(self._mdata['composition'])
        metadata.update({'existing_id_values': self._my_map['compositionId']})
        return Metadata(**metadata)
1338962
def get_group_metadata(self):
        
        # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template
        metadata = dict(self._mdata['group'])
        metadata.update({'existing_boolean_values': self._my_map['group']})
        return Metadata(**metadata)
1280882
def get_meta(self):
        
        rdf = self.get_meta_rdf(fmt='n3')
        return ThingMeta(self, rdf, self._client.default_lang, fmt='n3')