Python _compat.reraise函数代码示例

 def __exit__(self, exc_type, exc_value, tb):
     exception_name = self.exc_type.__name__
     if exc_type is None:
         self.test_case.fail('Expected exception of type %r' %
                             exception_name)
     elif not issubclass(exc_type, self.exc_type):
         reraise(exc_type, exc_value, tb)
     self.exc_value = exc_value
     return True

 def start_response(status, response_headers, exc_info=None):
     if exc_info:
         try:
             if headers_sent:
                 reraise(*exc_info)
         finally:
             exc_info = None
     elif headers_set:
         raise AssertionError('Headers already set')
     headers_set[:] = [status, response_headers]
     return write

    def _handle_syntaxerror(self, exception, pkg, import_str):
        """
        Properly handle an syntax error.

        Pass through the error unless silent is set to True.
        """
        if not self.silent:
            reraise(
                SyntaxError,
                SyntaxError(*exception.args),
                sys.exc_info()[2]
            )

def import_string(import_name, silent=False):
    """Imports an object based on a string.  This is useful if you want to
    use import paths as endpoints or something similar.  An import path can
    be specified either in dotted notation (``xml.sax.saxutils.escape``)
    or with a colon as object delimiter (``xml.sax.saxutils:escape``).

    If `silent` is True the return value will be `None` if the import fails.

    :param import_name: the dotted name for the object to import.
    :param silent: if set to `True` import errors are ignored and
                   `None` is returned instead.
    :return: imported object
    """
    # force the import name to automatically convert to strings
    # __import__ is not able to handle unicode strings in the fromlist
    # if the module is a package
    import_name = str(import_name).replace(':', '.')
    try:
        try:
            __import__(import_name)
        except ImportError:
            if '.' not in import_name:
                raise
        else:
            return sys.modules[import_name]

        module_name, obj_name = import_name.rsplit('.', 1)
        try:
            module = __import__(module_name, None, None, [obj_name])
        except ImportError:
            # support importing modules not yet set up by the parent module
            # (or package for that matter)
            module = import_string(module_name)

        try:
            return getattr(module, obj_name)
        except AttributeError as e:
            raise ImportError(e)

    except ImportError as e:
        if not silent:
            reraise(
                ImportStringError,
                ImportStringError(import_name, e),
                sys.exc_info()[2])

def get_current_traceback(ignore_system_exceptions=False,
                          show_hidden_frames=False, skip=0):
    """Get the current exception info as `Traceback` object.  Per default
    calling this method will reraise system exceptions such as generator exit,
    system exit or others.  This behavior can be disabled by passing `False`
    to the function as first parameter.
    """
    exc_type, exc_value, tb = sys.exc_info()
    if ignore_system_exceptions and exc_type in system_exceptions:
        reraise(exc_type, exc_value, tb)
    for _ in range_type(skip):
        if tb.tb_next is None:
            break
        tb = tb.tb_next
    tb = Traceback(exc_type, exc_value, tb)
    if not show_hidden_frames:
        tb.filter_hidden_frames()
    return tb

    def _handle_importerror(self, exception, pkg, import_str):
        """
        Properly handle an import error

        If a module does not exists, it's not an error, however an
        ImportError generated from importing an existing module is an
        error.
        """
        try:
            for found_module_name in find_modules(pkg):
                if found_module_name == import_str:
                    reraise(
                        ImportError,
                        ImportError(*exception.args),
                        sys.exc_info()[2]
                    )
        except ValueError:
            # pkg doesn't exist or is not a package
            pass

def import_string(import_name, silent=False):
    """Imports an object based on a string.  This is useful if you want to
    use import paths as endpoints or something similar.  An import path can
    be specified either in dotted notation (``xml.sax.saxutils.escape``)
    or with a colon as object delimiter (``xml.sax.saxutils:escape``).

    If `silent` is True the return value will be `None` if the import fails.

    :param import_name: the dotted name for the object to import.
    :param silent: if set to `True` import errors are ignored and
                   `None` is returned instead.
    :return: imported object
    """
    #XXX: py3 review needed
    assert isinstance(import_name, string_types)
    # force the import name to automatically convert to strings
    import_name = str(import_name)
    try:
        if ':' in import_name:
            module, obj = import_name.split(':', 1)
        elif '.' in import_name:
            module, obj = import_name.rsplit('.', 1)
        else:
            return __import__(import_name)
        # __import__ is not able to handle unicode strings in the fromlist
        # if the module is a package
        if PY2 and isinstance(obj, unicode):
            obj = obj.encode('utf-8')
        try:
            return getattr(__import__(module, None, None, [obj]), obj)
        except (ImportError, AttributeError):
            # support importing modules not yet set up by the parent module
            # (or package for that matter)
            modname = module + '.' + obj
            __import__(modname)
            return sys.modules[modname]
    except ImportError as e:
        if not silent:
            reraise(
                ImportStringError,
                ImportStringError(import_name, e),
                sys.exc_info()[2])

    def _discover_module(self, pkg):
        """
        Method to discover a single module. May be overwritten by subclasses.
        """
        import_str = pkg + '.' + self.module_name

        try:
            module = import_string(import_str, self.silent)
            self.register(module)
        except ImportError as e:  # pylint: disable=C0103
            # If a module does not exists, it's not an error, however an
            # ImportError generated from importing an existing module is an
            # error.
            try:
                for found_module_name in find_modules(pkg):
                    if found_module_name == import_str:
                        reraise(
                            ImportError,
                            ImportError(*e.args),
                            sys.exc_info()[2]
                        )
            except ValueError:
                # pkg doesn't exist or is not a package
                pass

 def start_response(status, headers, exc_info=None):
     if exc_info is not None:
         reraise(*exc_info)
     response[:] = [status, headers]
     return buffer.append