**get**

        Make a GET call to a remote endpoint

        Input:
            * An endpoint relative to the ``base_url``

        Output:
            * A :py:mod:`pygett.request.GettResponse` object
484621
def get(self, endpoint, *args, **kwargs):
        
        endpoint = self.base_url + endpoint
        return self._make_request(endpoint, type='GET')
231831
def get(self, url):
        
        return requests.get(url, params=self.data, headers=self.config.HEADERS)
113747
def __request(self, endpoint, method='GET', params=None, convJSON=False):
        
        url = '%s/%s' % (self.api_url, endpoint)

        method = method.lower()
        params = params or {}
        if convJSON:
            params = json.dumps(params)

        func = getattr(self.client, method)
        request_args = {}
        if method == 'get':
            request_args['params'] = params
        else:
            request_args['data'] = params

        try:
            # Normally some valid HTTP-response will be the case
            # if not some exception regarding the request / connection has
            # occurred
            # this will be one of the exceptions of the request module
            # if so, we will a PostcodeError exception and pass the request
            # exception message
            response = func(url, **request_args)
        except requests.RequestException as e:
            raise PostcodeError("ERRrequest", {"exception": e.__doc__})

        content = response.content.decode('utf-8')

        content = json.loads(content)

        if response.status_code == 200:
            return content

        # Errors, otherwise we did not get here ...
        if 'exceptionId' in content:
            raise PostcodeError(content['exceptionId'], content)

        raise PostcodeError("UnknownExceptionFromPostcodeNl")
1178842
def _get_range(self, endpoint, *args, method='GET', **kwargs):
        
        if args:
            url = self.build_url(self._endpoints.get(endpoint).format(*args))
        else:
            url = self.build_url(self._endpoints.get(endpoint))
        if not kwargs:
            kwargs = None
        if method == 'GET':
            response = self.session.get(url, params=kwargs)
        elif method == 'POST':
            response = self.session.post(url, data=kwargs)
        if not response:
            return None
        return self.__class__(parent=self, **{self._cloud_data_key: response.json()})
1330440
def endpoint(url, method="GET", expected_status=200):
    
    def dec(obj):
        obj.ENDPOINT = url
        obj.METHOD = method
        obj.EXPECTED_STATUS = expected_status
        return obj

    return dec
473490
def get(self, suffix, params=None):
        

        url = self.base + suffix
        params = filter_params(params)

        response = self.session.get(url=url, params=params)

        return self._handler_response(response)
766839
def _req(self, endpoint, get_data=dict(), post_data=dict()):

        

        if get_data:
            request_parameter = "{}?{}".format(endpoint, urlencode(get_data))
        else:
            request_parameter = endpoint

        try:
            encdata = urlencode(post_data, True).encode('utf-8')
            response = self.oauth.request(request_parameter, data=encdata)
            self._checkResponseForErrors(response)
        except HTTPError as e:
            raise DeviantartError(e)

        return response
990315
def rest_get(url, timeout):
    ''''''
    try:
        response = requests.get(url, timeout=timeout)
        return response
    except Exception as e:
        print('Get exception {0} when sending http get to url {1}'.format(str(e), url))
        return None
1148586
def _get(function, return_format=None):
    
    if return_format:
        return requests.get(''.join([__BASE_URL, function, return_format])).text
    return requests.get(''.join([__BASE_URL, function, JSON])).json()
490914
def get(self, endpoint):
        ''''''
        json_body = urlopen(self.url(endpoint)).read().decode('utf-8')
        return json.loads(json_body)
905313
def get(api, options = {})
      options[:apikey] = SmartSMS.config.api_key
      uri = URI.join(base_url, api)
      result Net::HTTP.get(uri, options)
    end
507672
def get(self, uri_relative, params, custom_headers):
        

        return self._request(
            self._METHOD_GET,
            uri_relative,
            self._BYTES_EMPTY,
            params,
            custom_headers
        )
985315
def rest(url, req="GET", data=None):
    
    load_variables()

    return _rest(base_url + url, req, data)
356294
def get(self, key, **kwargs):
        '''
        
        '''
        return self._get('/'.join([self._endpoint, key]), payload=kwargs)
1283517
def _http_request(self, base_url, **kwargs):
        

        # Build our URI
        request_params = urlencode(kwargs)
        uri = u'%s?%s&ywsid=%s&output=%s' % \
            (base_url, request_params, self._client_key, self._output)

        self.LOG.debug("_http_request() - URI: %s", uri)

        header, response = self._conn.request(uri, method='GET')

        return header, response
596556
def get(path, args = {}, response_type = nil)
      response_type = SimpleSolrClient::Response::GenericResponse if response_type.nil?
      response_type.new(_get(path, args))
    end
334557
def make_inaturalist_api_get_call(endpoint: str, params: Dict, **kwargs) -> requests.Response:
    
    headers = {'Accept': 'application/json'}

    response = requests.get(urljoin(INAT_NODE_API_BASE_URL, endpoint), params, headers=headers, **kwargs)
    return response