Returns raw response for an given asset by its unique id.
182190
def _get_asset(self, asset_uid):
        
        uri = self.uri + '/v2/assets/' + asset_uid

        headers = self._get_headers()

        return self.service._get(uri, headers=headers)
1365324
def do_response(self, response_id):
        '''
        '''
        if response_id != Gtk.ResponseType.OK:
            return
        filelist = []
        for row in self.rows:
            if row[1].get_text() == row[2].get_text():
                continue
            filelist.append({'path': row[0], 'newname': row[2].get_text()})
        if len(filelist) == 0:
            return
        pcs.rename(self.app.cookie, self.app.tokens, filelist)
        gutil.async_call(pcs.rename, self.app.cookie, self.app.tokens,
                         filelist, callback=self.app.reload_current_page)
1209931
def find_one_raw(self, resource, _id):
        """"""
        return self._find_by_id(resource=resource, _id=_id)
721005
def _extract_id_from_batch_response(r, name='id'):
        """"""
        names = name + 's'
        if names in r:
            # soon-to-be deprecated batch reponse
            if 'errors' in r and r['errors']:
                raise GeneralException(r['errors'][0]['desc'])
            id = r[names][0]
        else:
            # new-style simplified api response
            id = r[name]
        return int(id)
568548
def get_site_by_id(self, id):
        
        response = self._session.get(BASE_URL_TSQUARE + '/site/{}.json'.format(id))
        response.raise_for_status()
        site_data = response.json()
        return TSquareSite(**site_data)
1063959
def get_custom_color(self, id, asset_string):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - id
        """ID"""
        path["id"] = id

        # REQUIRED - PATH - asset_string
        """ID"""
        path["asset_string"] = asset_string

        self.logger.debug("GET /api/v1/users/{id}/colors/{asset_string} with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("GET", "/api/v1/users/{id}/colors/{asset_string}".format(**path), data=data, params=params, no_data=True)
416874
def attribute_response(resource, name, value):
    
    if _get_acceptable_response_type() == JSON:
        return _single_attribute_json_response(name, value)
    else:
        return _single_attribute_html_response(resource, name, value)
516743
def get (id:)
      response = Faraday.get("#{API_BASE}/#{id}")
      attributes = JSON.parse(response.body)
      Track.new(attributes)
    end
157240
private HttpResponse getResponse(StringBuilder q, String _id) throws URISyntaxException, IOException,
            ClientProtocolException
    {
        URI uri = new URI(CouchDBConstants.PROTOCOL, null, httpHost.getHostName(), httpHost.getPort(), _id,
                q.toString(), null);
        HttpGet get = new HttpGet(uri);
        get.addHeader("Accept", "application/json");
        return httpClient.execute(httpHost, get, CouchDBUtils.getContext(httpHost));
    }
938236
def return_response(self, value=None):
        # type: (Any) -> Tuple[Callback, Return]
        """"""
        response = Return(id=self.id, value=value)
        return self.callback, response
731807
def get_asset_id(self, tx_id):
        
        tx = self.driver.instance.transactions.retrieve(txid=tx_id)
        assert tx is not None
        return tx['id'] if tx['operation'] == 'CREATE' else tx['asset']['id']
238864
def handle_response(self, data):
        """"""
        identifier = data.get('id')
        self._buffer[identifier]['data'] = data.get('result')
        self._buffer[identifier]['flag'].set()
1372640
def get_block(block_id, api_code=None):
    

    resource = 'rawblock/' + block_id
    if api_code is not None:
        resource += '?api_code=' + api_code
    response = util.call_api(resource)
    json_response = json.loads(response)
    return Block(json_response)
924645
def get_image(self, id):
        """"""
        url = self._base_url + "/3/image/{0}".format(id)
        resp = self._send_request(url)
        return Image(resp, self)
1249256
def FetchResponses(self, session_id):
    
    timestamp = (0, self.frozen_timestamp or rdfvalue.RDFDatetime.Now())

    for response in self.data_store.FetchResponsesForWellKnownFlow(
        session_id, self.response_limit, timestamp=timestamp):
      yield response
1067843
def get_by_id(id, with_estimate = 1)
      params = { :id => id, :with_estimate => with_estimate }
      requires params
      DataSift.request(:GET, 'historics/get', @config, params)
    end
659881
def thumbnail(self, id):
        
        res = self._raw_api_request('thumb', data={'i': id})
        if not res:
            raise PuushError("Getting thumbnail failed.")
        return res