Gets the metadata for the url.

        return: (osid.Metadata) - metadata for the url
        *compliance: mandatory -- This method must be implemented.*
546147
def get_url_metadata(self):
        
        # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template
        metadata = dict(self._mdata['url'])
        metadata.update({'existing_string_values': self._my_map['url']})
        return Metadata(**metadata)
523760
def get_metadata_or_fail(metadata_key):
  
  try:
    return http_get_metadata(metadata_key)
  except IOError as error:
    fail("Exception in http_get_metadata {} {}".format(metadata_key, repr(error)))
459905
def get_asset_metadata(self, did):
        
        response = self.requests_session.get(f'{self._base_url}/metadata/{did}').content
        if not response:
            return {}
        try:
            parsed_response = json.loads(response)
        except TypeError:
            parsed_response = None
        except ValueError:
            raise ValueError(response.decode('UTF-8'))
        if parsed_response is None:
            return {}
        return parsed_response['metadata']
293407
def get_metadata():
    
    misc_path = pkg_resources.resource_filename('hwrt', 'misc/')
    wm_symbols = os.path.join(misc_path, 'wm_symbols.csv')
    wm_tags = os.path.join(misc_path, 'wm_tags.csv')
    wm_tags2symbols = os.path.join(misc_path, 'wm_tags2symbols.csv')
    return {'symbols': read_csv(wm_symbols),
            'tags': read_csv(wm_tags),
            'tags2symbols': read_csv(wm_tags2symbols)}
645985
def get_urls(self):
        
        parts = []
        seen = set()

        # Process item views in order
        for v in list(self._meta.item_views)+list(self._meta.action_views):
            if not v in seen:
                view, name = self.get_view_and_name(v)
                if view and name:
                    parts.append(self.get_url(name, view, v))
                seen.add(v)

        # Process everything else that we have not seen
        for v in set(self._views).difference(seen):
            # Get the url name
            view, name = self.get_view_and_name(v)
            if view and name:
                parts.append(self.get_url(name, view, v))

        return parts
69848
def get_metadata(self, loadbalancer, node=None, raw=False):
        
        if node:
            uri = "/loadbalancers/%s/nodes/%s/metadata" % (
                    utils.get_id(loadbalancer), utils.get_id(node))
        else:
            uri = "/loadbalancers/%s/metadata" % utils.get_id(loadbalancer)
        resp, body = self.api.method_get(uri)
        meta = body.get("metadata", [])
        if raw:
            return meta
        ret = dict([(itm["key"], itm["value"]) for itm in meta])
        return ret
644876
def get_text_metadata(self):
        
        # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template
        metadata = dict(self._mdata['text'])
        metadata.update({'existing_string_values': self._my_map['text']})
        return Metadata(**metadata)
765636
def wsfed_metadata(self):
        

        url = 'https://{}/wsfed/FederationMetadata' \
              '/2007-06/FederationMetadata.xml'

        return self.get(url=url.format(self.domain))
995223
def get_provider_links_metadata(self):
        
        # Implemented from template for osid.learning.ActivityForm.get_assets_metadata_template
        metadata = dict(self._mdata['provider_links'])
        metadata.update({'existing_provider_links_values': self._my_map['providerLinkIds']})
        return Metadata(**metadata)
246001
def get_license_metadata(self):
        
        metadata = dict(self._license_metadata)
        metadata.update({'existing_string_values': self.my_osid_object_form._my_map['license']})
        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)
1149855
def request_metadata
      {
        uuid: request.uuid,
        url: request.original_url,
        headers: request.env.select { |key, _v| key =~ /^HTTP_/ },
        ip: request.remote_ip
      }
    end
166073
def get_temp_url_key(self, cached=True):
        
        meta = self._cached_temp_url_key
        if not cached or not meta:
            key = "temp_url_key"
            meta = self.get_account_metadata().get(key)
            self._cached_temp_url_key = meta
        return meta
899028
def _get_metadata(cls, request, response, head=None):
        
        head = response.get('head_id', head)
        metadata = {'link': cls._build_url(request, head=head)}

        if head is not None:
            metadata['head'] = head
        return metadata
538073
def metadata(self):
        
        resp = self.r_session.get(self.server_url)
        resp.raise_for_status()
        return response_to_json_dict(resp)
231831
def get(self, url):
        
        return requests.get(url, params=self.data, headers=self.config.HEADERS)
871913
def get_metadata(self, key) -> str:
        
        return self.metadata[key] if key in self.metadata else None