Makes a request for registration info and returns the response object

        Args:
            registration_id: id to be checked

        Returns:
            response of registration info request
356659
def registration_info_request(self, registration_id):
        
        return self.requests_session.get(
            self.INFO_END_POINT + registration_id,
            params={'details': 'true'}
        )
790982
def info(self, server_id):
        
        result = self._storage[server_id].info()
        result['id'] = server_id
        return result
268501
def dispatch(self, *args, **kwargs):
        
        if not self.registration_allowed():
            return HttpResponseRedirect(force_text(self.disallowed_url))
        return super(RegistrationView, self).dispatch(*args, **kwargs)
1064120
def clean_registration_ids(self, registration_ids=[]):
        
        valid_registration_ids = []
        for registration_id in registration_ids:
            details = self.registration_info_request(registration_id)
            if details.status_code == 200:
                valid_registration_ids.append(registration_id)
        return valid_registration_ids
789143
def get_startup(self, id_):
    
    return _get_request(_STARTUP.format(c_api=_C_API_BEGINNING,
                                        api=_API_VERSION,
                                        id_=id_,
                                        at=self.access_token))
1050769
def request(self, id, **kwargs):
        
        data = self.get('requests', id, **kwargs)
        return data
919189
def info(self, user_id):
        
        resp = self._rtm_client.get('v1/user.info?user_id={}'.format(user_id))
        if resp.is_fail():
            raise RTMServiceError('Failed to get user information', resp)

        return resp.data['result']
1242627
def get_release_id_data(self, release_id: bytes) -> Tuple[str, str, str]:
        
        self._validate_set_registry()
        return self.registry._get_release_data(release_id)
1104457
def registration_request_verify(registration_request):
    
    try:
        registration_request.verify()
    except MessageException as e:
        raise InvalidClientRegistrationRequest(str(e), registration_request, oauth_error='invalid_request') from e
106976
def register
      request = if @receivers.empty?
                  Request.post('checkout', api_version, params)
                else
                  Request.post_xml('checkouts', api_version, credentials, xml_params)
                end

      Response.new(request)
    end
65778
def id_exists(api, search_id):
    
    response = utils.checked_api_call(api, 'get_specific', id=search_id)
    return response is not None
226272
def query_by_id(self, id):
        
        return json.loads(self._get(UrlEncoded(str(id))).body.read().decode('utf-8'))
1018271
def post(self, request, id=None, **kwargs):
        
        if id:
            # No posting to an object detail page
            return HttpResponseForbidden()
        else:
            if not self.has_add_permission(request):
                return HttpResponseForbidden(_('You do not have permission to perform this action.'))
            else:
                return self.add_object(request)
990806
def is_registered(id):
    """"""
    bucket = registration_s3_bucket()
    key = registration_key(id)
    found_keys = set(obj.key for obj in bucket.objects.filter(Prefix=key))
    return key in found_keys
574535
def get_vip_request_details(self, vip_request_id):
        
        uri = 'api/v3/vip-request/details/%s/' % vip_request_id

        return super(ApiVipRequest, self).get(uri)
331376
def addRegistration(self, key, registration):
        
        if key in self._registrations:
            raise KeyError("Key already registered")

        self._registrations[key] = registration
        return self
468692
def handle_client_registration_request(self, request, http_headers=None):
        # type: (Optional[str], Optional[Mapping[str, str]]) -> oic.oic.message.RegistrationResponse
        
        registration_req = RegistrationRequest().deserialize(request, 'json')

        for validator in self.registration_request_validators:
            validator(registration_req)
        logger.debug('parsed authentication_request: %s', registration_req)

        client_id, client_secret = self._issue_new_client()
        credentials = {
            'client_id': client_id,
            'client_id_issued_at': int(time.time()),
            'client_secret': client_secret,
            'client_secret_expires_at': 0  # never expires
        }

        response_params = self.match_client_preferences_with_provider_capabilities(registration_req)
        response_params.update(credentials)
        self.clients[client_id] = copy.deepcopy(response_params)

        registration_resp = RegistrationResponse(**response_params)
        logger.debug('registration_resp=%s from registration_req=%s', registration_resp, registration_req)
        return registration_resp