request.RequestException

Here are the examples of the python api request.RequestException taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

1 Examples 7

Example 1

Project: simpleapi Source File: route.py
    def __call__(self, http_request=None, **urlparameters):
        sapi_request = SAPIRequest(self, http_request)
        request_items = dict(sapi_request.REQUEST.items())
        request_items.update(urlparameters)

        if SIMPLEAPI_DEBUG and SIMPLEAPI_DEBUG_LEVEL == 'call':
            self.logger.info(pprint.pformat(request_items))
            self.profile_start()

        version = request_items.pop('_version', 'default')
        callback = request_items.pop('_callback', None)
        output_formatter = request_items.pop('_output', None)

        # let's activate JSONP automatically if _callback is given
        if callback and not output_formatter:
            output_formatter = 'jsonp'
        elif not output_formatter:
            output_formatter = 'json'

        input_formatter = request_items.pop('_input', 'value')
        wrapper = request_items.pop('_wrapper', 'default')
        mimetype = request_items.pop('_mimetype', None)

        input_formatter_instance = None
        output_formatter_instance = None
        wrapper_instance = None

        try:
            try:
                version = int(version)
            except (ValueError, TypeError):
                pass
            if not self.nmap.has_key(version):
                # continue with wrong version to get the formatters/wrappers
                # raise the error later!
                namespace = self.nmap['default']
            else:
                namespace = self.nmap[version]

            # check input formatter
            if input_formatter not in namespace['input_formatters']:
                raise RequestException(u'Input formatter not allowed or ' \
                                        'unknown: %s' % input_formatter)

            # get input formatter
            input_formatter_instancec = namespace['input_formatters'][input_formatter](sapi_request, callback)

            # check output formatter
            if output_formatter not in namespace['output_formatters']:
                raise RequestException(u'Output formatter not allowed or ' \
                                        'unknown: %s' % output_formatter)

            # get output formatter
            output_formatter_instance = namespace['output_formatters'][output_formatter](sapi_request, callback)

            # check wrapper
            if wrapper not in namespace['wrappers']:
                raise RequestException(u'Wrapper unknown or not allowed: %s' % \
                    wrapper)

            # get wrapper
            wrapper_instance = namespace['wrappers'][wrapper]

            # check whether version exists or not
            if not self.nmap.has_key(version):
                raise RouterException(u'Version %s not found (possible: %s)' % \
                    (version, ", ".join(map(lambda i: str(i), self.nmap.keys()))))

            request = Request(
                sapi_request=sapi_request,
                namespace=namespace,
                input_formatter=input_formatter_instancec,
                output_formatter=output_formatter_instance,
                wrapper=wrapper_instance,
                callback=callback,
                mimetype=mimetype,
                restful=self.restful,
                debug=self.debug,
                route=self,
                ignore_unused_args=self.ignore_unused_args,
            )

            # map request items to the correct names
            wi = wrapper_instance(sapi_request=sapi_request)
            request_items = wi._parse(request_items)
            if not isinstance(request_items,
                (list, tuple, types.GeneratorType)):
                request_items = [request_items, ]

            responses = []
            for request_item in request_items:
                # clear session (except _internal)
                sapi_request.session.clear()

                # process request
                try:
                    responses.append(request.process_request(request_item))
                except (NamespaceException, RequestException, \
                        ResponseException, RouterException, FeatureException),e:
                    response = Response(
                        sapi_request,
                        errors=e.message,
                        output_formatter=output_formatter_instance,
                        wrapper=wrapper_instance,
                        mimetype=mimetype
                    )
                    responses.append(response)

            rm = ResponseMerger(
                sapi_request=sapi_request,
                responses=responses,
            )
            http_response = rm.build()
        except Exception, e:
            if isinstance(e, (NamespaceException, RequestException, \
                              ResponseException, RouterException, \
                              FeatureException)):
                err_msg = repr(e)
            else:
                err_msg = u'An internal error occurred during your request.'
            
            trace = inspect.trace()
            msgs = []
            msgs.append('')
            msgs.append(u"cuem*** Exception raised *******")
            msgs.append(u'Exception type: %s' % type(e))
            msgs.append(u'Exception msg: %s' % repr(e))
            msgs.append('')
            msgs.append(u'------- Traceback follows -------')
            for idx, item in enumerate(trace):
                msgs.append(u"(%s)\t%s:%s (%s)" % 
                    (idx+1, item[3], item[2], item[1]))
                if item[4]:
                    for line in item[4]:
                        msgs.append(u"\t\t%s" % line.strip())
                msgs.append('') # blank line
            msgs.append('     -- End of traceback --     ')
            msgs.append('')
            self.logger.error("\n".join(msgs))

            if self.debug:
                e, m, tb = sys.exc_info()
                pdb.post_mortem(tb)

            response = Response(
                sapi_request,
                errors=err_msg,
                output_formatter=output_formatter_instance,
                wrapper=wrapper_instance,
                mimetype=mimetype
            )
            http_response = response.build(skip_features=True)

        if SIMPLEAPI_DEBUG and SIMPLEAPI_DEBUG_LEVEL == 'call':
            self.profile_stop()
            self.profile_stats()

        return http_response