Requires: account ID (taken from Client object)
        Returns: a list of Server objects
        Endpoint: api.newrelic.com
        Errors: 403 Invalid API Key
        Method: Get
1502
def view_servers(self):
        
        endpoint = "https://api.newrelic.com"
        uri = "{endpoint}/api/v1/accounts/{id}/servers.xml".format(endpoint=endpoint, id=self.account_id)
        response = self._make_get_request(uri)
        servers = []

        for server in response.findall('.//server'):
            server_properties = {}
            for field in server:
                server_properties[field.tag] = field.text
            servers.append(Server(server_properties))
        return servers
892251
def get(cls, payment_service_provider_credential_id, custom_headers=None):
        

        if custom_headers is None:
            custom_headers = {}

        api_client = client.ApiClient(cls._get_api_context())
        endpoint_url = cls._ENDPOINT_URL_READ.format(
            payment_service_provider_credential_id)
        response_raw = api_client.get(endpoint_url, {}, custom_headers)

        return BunqResponsePaymentServiceProviderCredential.cast_from_bunq_response(
            cls._from_json(response_raw, cls._OBJECT_TYPE_GET)
        )
357275
def get_account(netid, timestamp=None):
    
    response = _get_account(netid, timestamp=timestamp)
    return _account_from_json(response)
572662
def get(identity_id = '', service = '')
      fail BadParametersError, 'identity_id is required' if identity_id.empty?
      fail BadParametersError, 'service is required' if service.empty?

      DataSift.request(:GET, "account/identity/#{identity_id}/limit/#{service}", @config)
    end
1197599
def get(self, id, no_summary=False):
        
        resp = self.client.accounts.get(id)
        if no_summary:
            return self.display(resp)

        results = []
        # Get a list of all volumes for this tenant id
        client = LunrClient(self.get_admin(), debug=self.debug)
        volumes = client.volumes.list(account_id=resp['id'])
        #volumes = self.client.volumes.list(resp['id'])
        for volume in volumes:
            if volume['status'] == 'DELETED':
                continue
            results.append(volume)

        self.display(resp, ['name', 'status', 'last_modified', 'created_at'])
        if results:
            return self.display(response(results, 200),
                                ['id', 'status', 'size'])
        else:
            print("-- This account has no active volumes --")
        print("\nThis is a summary, use --no-summary "
              "to see the entire response")
461720
def getReqId(self) -> int:
        
        if not self.isReady():
            raise ConnectionError('Not connected')
        newId = self._reqIdSeq
        self._reqIdSeq += 1
        return newId
1198572
def account(self, key=None, address=None, name=None):
        """"""
        if key:
            return self.client.account(key, wallet=self)
        if address:
            q = dict(address=address)
        elif name:
            q = dict(name=name)
        else:
            raise TypeError("Missing param: key, address, or name is required.")

        return Account(
            self.resource.account_query(q).get(), self.client, wallet=self)
123401
def get_client(self, client_id):
        
        self.assert_has_permission('clients.read')

        uri = self.uri + '/oauth/clients/' + client_id
        headers = self.get_authorization_headers()
        response = requests.get(uri, headers=headers)
        if response.status_code == 200:
            return response.json()
        else:
            # Not found but don't raise
            return
1140860
def get(self, id):
        
        url = self._url('%s' % (id))
        return self.client.get(url)
514456
def account_lists(self, id):
        
        id = self.__unpack_id(id)
        params = self.__generate_params(locals(), ['id'])
        url = '/api/v1/accounts/{0}/lists'.format(str(id))
        return self.__api_request('GET', url, params)
262843
def get_list(client, list_id):
    '''  '''
    endpoint = '/'.join([client.api.Endpoints.LISTS, str(list_id)])
    response = client.authenticated_request(endpoint)
    return response.json()
116179
def get_hfs_accounts(netid):
    
    url = ACCOUNTS_URL.format(uwnetid=netid)
    response = get_resource(url)
    return _object_from_json(response)
263851
def user
      response = JSON.parse(@client.get("wallet_accounts/#{send(:id)}/users").body)
      response.key?('users') ? Promisepay::User.new(@client, response['users']) : nil
    end
1320985
def get_endpoint_obj(client, endpoint, object_id):
    '''  '''
    endpoint = '/'.join([endpoint, str(object_id)])
    return client.authenticated_request(endpoint).json()
206258
def get_template(template_id, options = {})
      content_type = { 'Content-Type' => 'application/json' }
      content_type.merge(options[:headers]) if options[:headers]

      uri = build_uri("/accounts/#{acct_id}/templates/#{template_id}")

      http = initialize_net_http_ssl(uri)
      request = Net::HTTP::Get.new(uri.request_uri, headers(content_type))
      response = http.request(request)
      generate_log(request, response, uri)
      JSON.parse(response.body)
    end
197930
function (accountIdOrSlug, params) {
    var path;
    if (accountIdOrSlug) {
      path = this.constructPath(constants.ACCOUNTS, accountIdOrSlug);
      return this.Core.GET(path, params);
    } else {
      return this.rejectRequest('Bad Request: An account id or slug must be supplied for this operation');
    }
  }
561022
def get_client(self, client_id):
        ''''''
        client_response = self.get_request('clients/%s' % client_id)
        return Client(self, client_response['client'])