Return the Endpoints defined :attr:`Endpoint.response_handler`.

        :returns: A instance of the Endpoint specified :class:`ResonseHandler`.
        :rtype: :class:`ResponseHandler`
12434
def get_response_handler(self):
        
        assert self.response_handler is not None, \
            'Please define a response_handler ' \
            ' for Endpoint: %s' % self.__class__.__name__

        return self.response_handler(self, **self.get_response_handler_params())
253633
def _get_subscriptions_endpoint(self):
        

        s = self.settings()

        params = {
            'access_token': self.app_access_token,
        }

        return (
            GRAPH_ENDPOINT.format(f'{s["app_id"]}/subscriptions'),
            params,
        )
132869
def get_handler_classes(self):
        """"""

        handler_classes = [import_string(handler_cls) for handler_cls in settings.MODERNRPC_HANDLERS]

        if self.protocol == ALL:
            return handler_classes
        else:
            return [cls for cls in handler_classes if cls.protocol in ensure_sequence(self.protocol)]
1150141
private HttpRequestRetryHandler getRetryHandler() {
    final HttpRequestRetryHandler myRetryHandler = new HttpRequestRetryHandler() {

      public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
        if (executionCount >= connectionConfiguration.getExecutionCount()) {
          // Do not retry if over max retry count
          LOG.debug("Execution count {} is bigger than threshold. Stop", executionCount);
          return false;
        }
        if (exception instanceof NoHttpResponseException) {
          LOG.debug("NoHttpResponseException exception. Retry count {}", executionCount);
          return true;
        }
        if (exception instanceof UnknownHostException) {
          LOG.debug("UnknownHostException. Retry count {}", executionCount);
          return true;
        }
        if (exception instanceof ConnectTimeoutException) {
          LOG.debug("ConnectTimeoutException. Retry count {}", executionCount);
          return true;
        }
        if (exception instanceof SocketTimeoutException
            || exception.getClass() == SocketTimeoutException.class
            || exception.getClass().isInstance(SocketTimeoutException.class)) {
          // Connection refused
          LOG.debug("socketTimeoutException Retry count {}", executionCount);
          return true;
        }
        if (exception instanceof InterruptedIOException) {
          // Timeout
          LOG.debug("InterruptedIOException Retry count {}", executionCount);
          return true;
        }
        if (exception instanceof SSLException) {
          LOG.debug("SSLException Retry count {}", executionCount);
          return true;
        }
        final HttpClientContext clientContext = HttpClientContext.adapt(context);
        final HttpRequest request = clientContext.getRequest();
        boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
        if (idempotent) {
          LOG.debug("HttpEntityEnclosingRequest. Retry count {}", executionCount);
          return true;
        }
        LOG.debug("Retry stopped. Retry count {}", executionCount);
        return false;
      }
    };
    return myRetryHandler;
  }
286937
def get_response(self):
        
        res = IOCRBlockRes()
        for field in ["IOCRType", "IOCRReference", "FrameID"]:
            res.setfieldval(field, self.getfieldval(field))
        return res
601796
def handler(self, handler_class):
        """"""
        self.handler_class = handler_class
        # we take the docstring from the handler class, not the methods
        if self.docs is None and handler_class.__doc__:
            self.docs = clean_docstring(handler_class.__doc__)
        return handler_class
1083550
def get_handler(handler_name):
    

    from .conf import options
    
    handlers = options.handlers
    
    for handler in handlers:
        handler_path = handler.split(".")
        name = handler_path[-2]
        
        if handler_name == name:
            handler_module = __import__(".".join(handler_path[:-1]), {}, {}, str(handler_path[-1]))
            
            return getattr(handler_module, handler_path[-1])()
    
    return None
937643
def get_response_handler_params(self, **params):
        

        params = super(KimEndpoint, self).get_response_handler_params(**params)
        params['mapper_class'] = self.mapper_class
        params['role'] = self.serialize_role

        # After a successfull attempt to marshal an object has been made, a response
        # is generated using the RepsonseHandler.  Rather than taking the class level
        # setting for many by default, pull it from the request handler params config to
        # ensure Marshaling and Serializing are run the same way.
        if self._is_marshal_request():
            req_params = self.get_request_handler_params()
            params['many'] = req_params.get('many', self.many)
        else:
            params['many'] = self.many

        return params
1321809
def handle(self, endpoint, *args, **kwargs):
        
        method = self.request_method()

        try:
            if not method in self.http_methods.get(endpoint, {}):
                raise MethodNotImplemented(
                    "Unsupported method '{}' for {} endpoint.".format(
                        method,
                        endpoint
                    )
                )

            if not self.is_authenticated():
                raise Unauthorized()

            self.data = self.deserialize(method, endpoint, self.request_body())
            view_method = getattr(self, self.http_methods[endpoint][method])
            data = view_method(*args, **kwargs)
            if is_future(data):
                # need to check if the view_method is a generator or not
                data = yield data
            serialized = self.serialize(method, endpoint, data)
        except Exception as err:
            raise gen.Return(self.handle_error(err))

        status = self.status_map.get(self.http_methods[endpoint][method], OK)
        raise gen.Return(self.build_response(serialized, status=status))
269428
def _loadHandlers(self):
        
        return {handler.name: handler for handler in map(self.createHandler, self.config['handlers'])}
384474
def get_endpoint(cls):
        
        if cls.endpoint is not None:
            return cls.endpoint
        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', cls.__name__)
        return cls.sanitize_ep(
            re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower(),
            plural=True
        )
140191
public com.google.appengine.v1.ApiEndpointHandler getApiEndpoint() {
    if (handlerTypeCase_ == 4) {
       return (com.google.appengine.v1.ApiEndpointHandler) handlerType_;
    }
    return com.google.appengine.v1.ApiEndpointHandler.getDefaultInstance();
  }
1247128
def get_message_handler(self, message_handlers):
        
        encoder = self.options.encoder
        try:
            return message_handlers[encoder]
        except KeyError:
            raise NotImplementedError('No RequestHandler defined for given encoder (%s).' % encoder)
74005
def handle_get_request(self):
        
        self.objects = self.get_objects()
        self.response = self.get_response_handler()

        self.response.process(self.objects)

        return self.list_response()
695824
def _get_range(self, endpoint_name):
        

        url = self.build_url(self._endpoints.get(endpoint_name))
        response = self.session.get(url)
        if not response:
            return None
        data = response.json()
        return self.range_constructor(parent=self, **{self._cloud_data_key: data})
517651
def get_handler():
    
    host, port, signum = _pdbhandler._registered()
    if signum:
        return Handler(host if host else DFLT_ADDRESS[0].encode(),
                       port if port else DFLT_ADDRESS[1], signum)
194867
public com.google.appengine.v1.ApiEndpointHandlerOrBuilder getApiEndpointOrBuilder() {
    if (handlerTypeCase_ == 4) {
       return (com.google.appengine.v1.ApiEndpointHandler) handlerType_;
    }
    return com.google.appengine.v1.ApiEndpointHandler.getDefaultInstance();
  }