Returns the WS-Federation Metadata.
765636
def wsfed_metadata(self):
        

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

        return self.get(url=url.format(self.domain))
1299864
def metadata(
        self, output_format=None, feature_name_callback=None, **kwargs
    ):
        
        callback = feature_name_callback or str
        if output_format is None:
            output_format = (
                'text/xml; subtype="sensorML/1.0.1/profiles/ioos_sos/1.0"'
            )

        responses = []
        if self.features is not None:
            for feature in self.features:
                ds_kwargs = kwargs.copy()
                ds_kwargs.update(
                    {
                        "outputFormat": output_format,
                        "procedure": callback(feature),
                    }
                )

                responses.append(
                    SensorML(self.server.describe_sensor(**ds_kwargs))
                )

        return responses
1259149
def awsReadMetadataKey():
  """"""
  parser = argparse.ArgumentParser()

  parser.add_argument("--key",
                      dest="keyname",
                      help="Which metadata key to read")

  cli = parser.parse_args()

  print getMetadataKey(name=cli.keyname)
1251420
def saml_metadata(self, client_id):
        

        return self.get(url='https://{}/samlp/metadata/{}'.format(self.domain,
                                                                  client_id))
80515
def get_metadata(self, queue):
        
        uri = "/%s/%s/metadata" % (self.uri_base, utils.get_id(queue))
        resp, resp_body = self.api.method_get(uri)
        return resp_body
1177516
def GetMetricMetadata():
  """"""
  return [
      stats_utils.CreateCounterMetadata("grr_client_unknown"),
      stats_utils.CreateCounterMetadata("grr_decoding_error"),
      stats_utils.CreateCounterMetadata("grr_decryption_error"),
      stats_utils.CreateCounterMetadata("grr_authenticated_messages"),
      stats_utils.CreateCounterMetadata("grr_unauthenticated_messages"),
      stats_utils.CreateCounterMetadata("grr_rsa_operations"),
      stats_utils.CreateCounterMetadata(
          "grr_encrypted_cipher_cache", fields=[("type", str)]),
  ]
1139826
def metadata(self):
        
        # Check exceptional case: return none if no metadata
        if not self._operation.HasField('metadata'):
            return None

        # Return expected metadata
        return _from_any(self._metadata_type, self._operation.metadata)
896524
def _get_extended_metadata(h5group):
    
    meta = dict()

    # get PSD
    try:
        psd = h5group['psd']
    except KeyError:
        pass
    else:
        from gwpy.frequencyseries import FrequencySeries
        meta['psd'] = FrequencySeries(
            psd[:], f0=0, df=psd.attrs['delta_f'], name='pycbc_live')

    # get everything else
    for key in META_COLUMNS - {'psd'}:
        try:
            value = h5group[key][:]
        except KeyError:
            pass
        else:
            meta[key] = value

    return meta
482242
def metadata(self):
    
    if self._info is None:
      try:
        self._info = self._api.buckets_get(self._name)
      except Exception as e:
        raise e

    return BucketMetadata(self._info) if self._info else None
651797
def metadata():
    """"""
    with open(os.path.join(charm_dir(), 'metadata.yaml')) as md:
        return yaml.safe_load(md)
1335740
def _get_stream_metadata(self, use_cached):
        """"""
        if self._cached_data is None or not use_cached:
            try:
                self._cached_data = self._conn.get_json("/ws/DataStream/%s" % self._stream_id)["items"][0]
            except DeviceCloudHttpException as http_exception:
                if http_exception.response.status_code == 404:
                    raise NoSuchStreamException("Stream with id %r has not been created" % self._stream_id)
                raise http_exception
        return self._cached_data
901942
def get_tile_metadata_name(self):
        
        if self.safe_type == EsaSafeType.OLD_TYPE:
            name = _edit_name(self.tile_id, 'MTD', delete_end=True)
        else:
            name = 'MTD_TL'
        return '{}.xml'.format(name)
1165318
def get_k8s_metadata():
    """"""
    k8s_metadata = {}

    gcp_cluster = (gcp_metadata_config.GcpMetadataConfig
                   .get_attribute(gcp_metadata_config.CLUSTER_NAME_KEY))
    if gcp_cluster is not None:
        k8s_metadata[CLUSTER_NAME_KEY] = gcp_cluster

    for attribute_key, attribute_env in _K8S_ENV_ATTRIBUTES.items():
        attribute_value = os.environ.get(attribute_env)
        if attribute_value is not None:
            k8s_metadata[attribute_key] = attribute_value

    return k8s_metadata
621178
def _GetBindingNamespace(self):
    """"""
    return (list(self.zeep_client.wsdl.bindings.itervalues())[0]
            .port_name.namespace)
538073
def metadata(self):
        
        resp = self.r_session.get(self.server_url)
        resp.raise_for_status()
        return response_to_json_dict(resp)
556643
def get_efs_dict():
  """"""
  # there's no EC2 resource for EFS objects, so return EFS_ID instead
  # https://stackoverflow.com/questions/47870342/no-ec2-resource-for-efs-objects

  efs_client = get_efs_client()
  response = call_with_retries(efs_client.describe_file_systems,
                               'efs_client.describe_file_systems')
  assert is_good_response(response)
  result = OrderedDict()
  for efs_response in response['FileSystems']:
    fs_id = efs_response['FileSystemId']

    tag_response = call_with_retries(efs_client.describe_tags,
                                     "efs_client.describe_tags",
                                     FileSystemId=fs_id, retry_interval_sec=2)
    assert is_good_response(tag_response)
    key = get_name(tag_response['Tags'])
    if not key or key == EMPTY_NAME:  # skip EFS's without a name
      continue
    assert key not in result
    result[key] = fs_id

  return result
1003677
def metadata(self):
        """"""

        from sqlalchemy import MetaData

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

        metadata.reflect(self.engine)

        return metadata