Python sys.excepthook() Examples

The following are code examples for showing how to use sys.excepthook(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the ones you don't like. You can also save this page to your account.

Example 1
Project: scm-workbench   Author: barry-scott   File: wb_logging.py    (license) View Source Project 8 votes vote down vote up
def __init__( self, app ):
        self.app = app
        self.__log_widget = WbLogTextWidget( self.app )

        self.__line = ''

        # Redirect the console IO to this panel
        sys.stdin = wb_platform_specific.getNullDevice().open( 'r' )
        if self.app.stdIoRedirected():
            sys.stdout = self
            sys.stderr = self
            sys.excepthook = self.excepthook

        # Redirect log to the Log panel
        self.widget_log_handler = WidgetLogHandler( self.app, self.__log_widget )
        self.app.log.addHandler( self.widget_log_handler )

        self.__session_log = open( str(wb_platform_specific.getLogFilename()) + '.session.log', 'w', buffering=1 ) 
Example 2
Project: iCount   Author: tomazc   File: logger.py    (license) View Source Project 7 votes vote down vote up
def _log_all_uncaught_exceptions(exc_type, exc_value, exc_traceback):
    """Log all uncaught exceptions in non-interactive mode.

    All python exceptions are handled by function, stored in
    ``sys.excepthook.`` By rewriting the default implementation, we
    can modify handling of all uncaught exceptions.

    Warning: modified behaviour (logging of all uncaught exceptions)
    applies only when runing in non-interactive mode.

    """
    # ignore KeyboardInterrupt
    if not issubclass(exc_type, KeyboardInterrupt):
        ROOT_LOGGER.error("", exc_info=(exc_type, exc_value, exc_traceback))

    sys.__excepthook__(exc_type, exc_value, exc_traceback)
    return


# Rewrite the default implementation os sys.excepthook to log all
# uncaught exceptions: 
Example 3
Project: scm-workbench   Author: barry-scott   File: wb_logging.py    (license) View Source Project 6 votes vote down vote up
def excepthook( self, type_, value, tb ):
        # emergency write
        self.__session_log.write( 'excepthook called\n' )
        self.__session_log.flush()

        all_exception_lines = traceback.format_exception( type_, value, tb )
        for line in all_exception_lines:
            self.__session_log.write( line )
        self.__session_log.flush()

        # cannot use the GUI window now app is not sane
        self.app.log.removeHandler( self.widget_log_handler )

        self.app.log.error( 'excepthook called' )
        for line in all_exception_lines:
            self.app.log.error( line.replace( '\n', '' ) )

        self.app.runInForeground( self.app.log.addHandler, (self.widget_log_handler,) )
        self.app.runInForeground( self.app.log.error, ('Check log for traceback details',) ) 
Example 4
Project: style50   Author: cs50   File: __main__.py    (license) View Source Project 6 votes vote down vote up
def excepthook(etype, value, tb):
    if etype is Error:
        termcolor.cprint(value.msg, "red", file=sys.stderr)
    else:
        termcolor.cprint("Sorry, something's wrong! "
                         "Let [email protected] know!",
                         "red", file=sys.stderr)

    # Main might not have initialized args yet.
    try:
        verbose = main.args.verbose
    except AttributeError:
        verbose = True

    if verbose:
        traceback.print_exception(etype, value, tb)


# Set global exception handler. 
Example 5
Project: TCP-IP   Author: JackZ0   File: log.py    (license) View Source Project 6 votes vote down vote up
def pre_arg_parse_except_hook(memory_handler, *args, **kwargs):
    """A simple wrapper around post_arg_parse_except_hook.

    The additional functionality provided by this wrapper is the memory
    handler will be flushed before Certbot exits. This allows us to
    write logging messages to a temporary file if we crashed before
    logging was fully configured.

    Since sys.excepthook isn't called on SystemExit exceptions, the
    memory handler will not be flushed in this case which prevents us
    from creating temporary log files when argparse exits because a
    command line argument was invalid or -h, --help, or --version was
    provided on the command line.

    :param MemoryHandler memory_handler: memory handler to flush
    :param tuple args: args for post_arg_parse_except_hook
    :param dict kwargs: kwargs for post_arg_parse_except_hook

    """
    try:
        post_arg_parse_except_hook(*args, **kwargs)
    finally:
        # flush() is called here so messages logged during
        # post_arg_parse_except_hook are also flushed.
        memory_handler.flush(force=True) 
Example 6
Project: Dolphin-Updater   Author: nbear3   File: dolphinapp.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, user_data_control):
        super().__init__()
        sys.excepthook = self._displayError
        self._udc = user_data_control

        self.check = QPixmap("res/check.png")
        self.cancel = QPixmap("res/cancel.png")

        self.setGeometry(500, 500, 500, 465)
        self.init_ui()
        self.init_window()
        self.init_user_data()

        self.setWindowTitle(self.APP_TITLE)
        self.setWindowIcon(QIcon('res/rabbit.png'))
        center(self)
        self.show()

    # PyQt Error Handling 
Example 7
Project: octario   Author: redhat-openstack   File: logger.py    (license) View Source Project 6 votes vote down vote up
def octario_excepthook(exc_type, exc_value, exc_traceback):
    """exception hook that sends OctarioException to log and other

    exceptions to stderr (default excepthook)
    """
    from octario.lib.exceptions import OctarioException

    # sends full exception with trace to log
    if not isinstance(exc_value, OctarioException):
        return sys.__excepthook__(exc_type, exc_value, exc_traceback)

    if LOG.getEffectiveLevel() <= logging.DEBUG:
        formated_exception = "".join(
            traceback.format_exception(exc_type, exc_value, exc_traceback))
        LOG.error(formated_exception + exc_value.message)
    else:
        LOG.error(exc_value.message) 
Example 8
Project: cuny-bdif   Author: aristotle-tek   File: awsqueryrequest.py    (license) View Source Project 6 votes vote down vote up
def boto_except_hook(debugger_flag, debug_flag):
    def excepthook(typ, value, tb):
        if typ is bdb.BdbQuit:
            sys.exit(1)
        sys.excepthook = sys.__excepthook__

        if debugger_flag and sys.stdout.isatty() and sys.stdin.isatty():
            if debugger.__name__ == 'epdb':
                debugger.post_mortem(tb, typ, value)
            else:
                debugger.post_mortem(tb)
        elif debug_flag:
            print(traceback.print_tb(tb))
            sys.exit(1)
        else:
            print(value)
            sys.exit(1)

    return excepthook 
Example 9
Project: cuny-bdif   Author: aristotle-tek   File: awsqueryrequest.py    (license) View Source Project 6 votes vote down vote up
def process_standard_options(self, options, args, d):
        if hasattr(options, 'help_filters') and options.help_filters:
            print('Available filters:')
            for filter in self.Filters:
                print('%s\t%s' % (filter.name, filter.doc))
            sys.exit(0)
        if options.debug:
            self.args['debug'] = 2
        if options.url:
            self.args['url'] = options.url
        if options.region:
            self.args['region'] = options.region
        if options.access_key_id:
            self.args['aws_access_key_id'] = options.access_key_id
        if options.secret_key:
            self.args['aws_secret_access_key'] = options.secret_key
        if options.version:
            # TODO - Where should the version # come from?
            print('version x.xx')
            exit(0)
        sys.excepthook = boto_except_hook(options.debugger,
                                          options.debug) 
Example 10
Project: rcli   Author: contains-io   File: dispatcher.py    (license) View Source Project 6 votes vote down vote up
def main():
    # type: () -> typing.Any
    """Parse the command line options and launch the requested command.

    If the command is 'help' then print the help message for the subcommand; if
    no subcommand is given, print the standard help message.
    """
    colorama.init(wrap=six.PY3)
    doc = usage.get_primary_command_usage()
    allow_subcommands = '<command>' in doc
    args = docopt(doc, version=settings.version,
                  options_first=allow_subcommands)
    if sys.excepthook is sys.__excepthook__:
        sys.excepthook = log.excepthook
    try:
        log.enable_logging(log.get_log_level(args))
        default_args = sys.argv[2 if args.get('<command>') else 1:]
        if (args.get('<command>') == 'help' and
                None not in settings.subcommands):
            subcommand = next(iter(args.get('<args>', default_args)), None)
            return usage.get_help_usage(subcommand)
        argv = [args.get('<command>')] + args.get('<args>', default_args)
        return _run_command(argv)
    except exc.InvalidCliValueError as e:
        return str(e) 
Example 11
Project: leetcode   Author: thomasyimgit   File: interactiveshell.py    (license) View Source Project 6 votes vote down vote up
def init_traceback_handlers(self, custom_exceptions):
        # Syntax error handler.
        self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor', parent=self)

        # The interactive one is initialized with an offset, meaning we always
        # want to remove the topmost item in the traceback, which is our own
        # internal code. Valid modes: ['Plain','Context','Verbose']
        self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
                                                     color_scheme='NoColor',
                                                     tb_offset = 1,
                                   check_cache=check_linecache_ipython,
                                   debugger_cls=self.debugger_cls, parent=self)

        # The instance will store a pointer to the system-wide exception hook,
        # so that runtime code (such as magics) can access it.  This is because
        # during the read-eval loop, it may get temporarily overwritten.
        self.sys_excepthook = sys.excepthook

        # and add any custom exception handlers the user may have specified
        self.set_custom_exc(*custom_exceptions)

        # Set the exception mode
        self.InteractiveTB.set_mode(mode=self.xmode) 
Example 12
Project: leetcode   Author: thomasyimgit   File: interactiveshell.py    (license) View Source Project 6 votes vote down vote up
def excepthook(self, etype, value, tb):
        """One more defense for GUI apps that call sys.excepthook.

        GUI frameworks like wxPython trap exceptions and call
        sys.excepthook themselves.  I guess this is a feature that
        enables them to keep running after exceptions that would
        otherwise kill their mainloop. This is a bother for IPython
        which excepts to catch all of the program exceptions with a try:
        except: statement.

        Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
        any app directly invokes sys.excepthook, it will look to the user like
        IPython crashed.  In order to work around this, we can disable the
        CrashHandler and replace it with this excepthook instead, which prints a
        regular traceback using our InteractiveTB.  In this fashion, apps which
        call sys.excepthook will generate a regular-looking exception from
        IPython, and the CrashHandler will only be triggered by real IPython
        crashes.

        This hook should be used sparingly, only in places which are not likely
        to be true IPython errors.
        """
        self.showtraceback((etype, value, tb), tb_offset=0) 
Example 13
Project: leetcode   Author: thomasyimgit   File: embed.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, **kw):
        if kw.get('user_global_ns', None) is not None:
            raise DeprecationWarning(
                "Key word argument `user_global_ns` has been replaced by `user_module` since IPython 4.0.")

        clid = kw.pop('_init_location_id', None)
        if not clid:
            frame = sys._getframe(1)
            clid = '%s:%s' % (frame.f_code.co_filename, frame.f_lineno)
        self._init_location_id = clid

        super(InteractiveShellEmbed,self).__init__(**kw)

        # don't use the ipython crash handler so that user exceptions aren't
        # trapped
        sys.excepthook = ultratb.FormattedTB(color_scheme=self.colors,
                                             mode=self.xmode,
                                             call_pdb=self.pdb) 
Example 14
Project: MDT   Author: cbclab   File: utils.py    (license) View Source Project 6 votes vote down vote up
def enable_pyqt_exception_hook():
    """Enable the PyQt exception handling hook for PyQt versions larger than 5.5.

    If this is not enabled, exceptions will be handled silently and will not be printed to the user. This
    makes it harder to solve the issue.
    """
    if QtCore.QT_VERSION >= 0x50501:
        old_stdout = sys.stdout
        old_stderr = sys.stderr

        def excepthook(type_, value, traceback_):
            sys.stdout = old_stdout
            sys.stderr = old_stderr
            traceback.print_exception(type_, value, traceback_)
            QtCore.qFatal('')
        sys.excepthook = excepthook 
Example 15
Project: landscape-client   Author: CanonicalLtd   File: test_facade.py    (license) View Source Project 6 votes vote down vote up
def test_perform_changes_dpkg_error_retains_excepthook(self):
        """
        We install a special excepthook when preforming package
        operations, to prevent Apport from generating crash reports when
        dpkg returns a failure. It's only installed when doing the
        actual package operation, so the original excepthook is there
        after the perform_changes() method returns.
        """
        old_excepthook = sys.excepthook
        self._add_system_package("foo")
        self.facade.reload_channels()
        foo = self.facade.get_packages_by_name("foo")[0]
        self.facade.mark_remove(foo)
        with self.assertRaises(TransactionError):
            self.facade.perform_changes()
        self.assertIs(old_excepthook, sys.excepthook) 
Example 16
Project: incubator-ariatosca   Author: apache   File: aria.py    (license) View Source Project 6 votes vote down vote up
def set_cli_except_hook():
    def recommend(possible_solutions):
        logger.info('Possible solutions:')
        for solution in possible_solutions:
            logger.info('  - {0}'.format(solution))

    def new_excepthook(tpe, value, trace):
        if env.logging.is_high_verbose_level():
            # log error including traceback
            logger.error(get_exception_as_string(tpe, value, trace))
        else:
            # write the full error to the log file
            with open(env.logging.log_file, 'a') as log_file:
                traceback.print_exception(
                    etype=tpe,
                    value=value,
                    tb=trace,
                    file=log_file)
            # print only the error message
            print value

        if hasattr(value, 'possible_solutions'):
            recommend(getattr(value, 'possible_solutions'))

    sys.excepthook = new_excepthook 
Example 17
Project: yt   Author: yt-project   File: startup_tasks.py    (license) View Source Project 6 votes vote down vote up
def __call__(self, parser, namespace, values, option_string = None):
        # If we recognize one of the arguments on the command line as indicating a
        # different mechanism for handling tracebacks, we attach one of those handlers
        # and remove the argument from sys.argv.
        #
        if self.dest == "paste":
            sys.excepthook = paste_traceback
            mylog.debug("Enabling traceback pasting")
        elif self.dest == "paste-detailed":
            sys.excepthook = paste_traceback_detailed
            mylog.debug("Enabling detailed traceback pasting")
        elif self.dest == "detailed":
            import cgitb
            cgitb.enable(format="text")
            mylog.debug("Enabling detailed traceback reporting")
        elif self.dest == "rpdb":
            sys.excepthook = rpdb.rpdb_excepthook
            mylog.debug("Enabling remote debugging") 
Example 18
Project: goldmine   Author: Armored-Dragon   File: gui.py    (license) View Source Project 6 votes vote down vote up
def main():
    """Main function."""
    sys.excepthook = error_handler
    try:
        signal.signal(signal.SIGINT, sigint_handler)
    except ValueError:
        print('Warning: couldn\'t start SIGINT (ctrl-c) handler.')
    QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
    app = QApplication(sys.argv)
    app.setStyleSheet(stylesheets[0])
    window = DiscordWindow()
    timer = QTimer()
    timer.start(20) # let interpreter run every 550ms
    timer.timeout.connect(lambda: None)
    window.show()
    window.raise_()
    window.setWindowState(window.windowState() & ~Qt.WindowMinimized | Qt.WindowActive)
    window.activateWindow() # mac...
    app.aboutToQuit.connect(lambda: quit_cleanup(window))
    exc = app.exec_()
    return exc 
Example 19
Project: vivisect-py3   Author: bat-serjo   File: monitor.py    (license) View Source Project 6 votes vote down vote up
def prehook(self, emu, op, starteip):

        if not self.onceop.get(starteip):
            self.onceop[starteip] = True
            for i, o in enumerate(op.opers):
                if o.isDeref():
                    discrete = o.isDiscrete()
                    operva = o.getOperAddr(op, emu)
                    # keep track of the max here, but save it for later too...
                    stackoff = emu.getStackOffset(operva)
                    if stackoff is not None:  # py 2->3 specific
                        if stackoff >= 0:
                            self.stackmax = max(self.stackmax, stackoff)

                    self.operrefs.append((starteip, i, operva, o.tsize, stackoff, discrete))

        if op.iflags & BRANCH_FLAGS:
            oper = op.opers[0]
            if oper.isDeref() or oper.isReg():
                for cb in self._dynamic_branch_handlers:
                    try:
                        cb(self, emu, op, starteip)
                    except:
                        sys.excepthook(*sys.exc_info()) 
Example 20
Project: PINCE   Author: korcankaraokcu   File: PINCE.py    (license) View Source Project 6 votes vote down vote up
def except_hook(exception_type, value, tb):
    if show_messagebox_on_exception:
        focused_widget = QApplication.focusWidget()
        if focused_widget:
            if exception_type == type_defs.GDBInitializeException:
                QMessageBox.information(focused_widget, "Error", "GDB isn't initialized yet")
            elif exception_type == type_defs.InferiorRunningException:
                error_dialog = InputDialogForm(item_list=[("Process is running" +
                                                           "\nPress " + break_hotkey + " to stop process" +
                                                           "\n\nGo to settings->General to disable this dialog",)])
                error_dialog.exec_()
    traceback.print_exception(exception_type, value, tb)


# From version 5.5 and onwards, PyQT calls qFatal() when an exception has been encountered
# So, we must override sys.excepthook to avoid calling of qFatal() 
Example 21
Project: pwndemo   Author: zh-explorer   File: atexception.py    (license) View Source Project 6 votes vote down vote up
def _run_handlers():
    """_run_handlers()

    Run registered handlers.  They run in the reverse order of which they were
    registered.

    If a handler raises an exception, it will be printed but nothing else
    happens, i.e. other handlers will be run.
    """
    context.clear()
    for _ident, (func, args, kwargs, ctx) in \
        sorted(_handlers.items(), reverse = True):
        try:
            with context.local(**ctx):
                func(*args, **kwargs)
        except SystemExit:
            pass
        except:
            # extract the current exception and rewind the traceback to where it
            # originated
            typ, val, tb = sys.exc_info()
            traceback.print_exception(typ, val, tb.tb_next)

# we rely on the existing excepthook to print exceptions 
Example 22
Project: StatisKit   Author: StatisKit   File: SConf.py    (license) View Source Project 6 votes vote down vote up
def failed(self):
        # check, if the reason was a ConfigureDryRunError or a
        # ConfigureCacheError and if yes, reraise the exception
        exc_type = self.exc_info()[0]
        if issubclass(exc_type, SConfError):
            raise
        elif issubclass(exc_type, SCons.Errors.BuildError):
            # we ignore Build Errors (occurs, when a test doesn't pass)
            # Clear the exception to prevent the contained traceback
            # to build a reference cycle.
            self.exc_clear()
        else:
            self.display('Caught exception while building "%s":\n' %
                         self.targets[0])
            sys.excepthook(*self.exc_info())
        return SCons.Taskmaster.Task.failed(self) 
Example 23
Project: opyrant   Author: opyrant   File: base.py    (license) View Source Project 6 votes vote down vote up
def configure_logging(self, level=logging.INFO, debug=False):
        """ Configures the basic logging for the experiment. This creates a handler for logging to the console, sets it at the appropriate level (info by default unless overridden in the config file or by the debug flag) and creates the default formatting for log messages.
        """

        if debug is True:
            self.log_level = logging.DEBUG
        else:
            self.log_level = level

        sys.excepthook = _log_except_hook  # send uncaught exceptions to file

        logging.basicConfig(
            level=self.log_level,
            format='"%(asctime)s","%(levelname)s","%(message)s"'
            )

        # Make sure that the stream handler has the requested log level.
        root_logger = logging.getLogger()
        for handler in root_logger.handlers:
            if isinstance(handler, logging.StreamHandler):
                handler.setLevel(self.log_level) 
Example 24
Project: specto   Author: mrknow   File: pydevd_breakpoints.py    (license) View Source Project 6 votes vote down vote up
def _set_pm_excepthook(handle_exceptions_dict=None):
    '''
    Should be called to register the excepthook to be used.

    It's only useful for uncaught exceptions. I.e.: exceptions that go up to the excepthook.

    @param handle_exceptions: dict(exception -> ExceptionBreakpoint)
        The exceptions that should be handled.
    '''
    global _handle_exceptions
    global _original_excepthook
    if sys.excepthook != _excepthook:
        #Only keep the original if it's not our own _excepthook (if called many times).
        _original_excepthook = sys.excepthook

    _handle_exceptions = handle_exceptions_dict
    sys.excepthook = _excepthook 
Example 25
Project: specto   Author: mrknow   File: pydevconsole.py    (license) View Source Project 6 votes vote down vote up
def showsyntaxerror(self, filename=None):
        """Display the syntax error that just occurred."""
        #Override for avoid using sys.excepthook PY-12600
        type, value, tb = sys.exc_info()
        sys.last_type = type
        sys.last_value = value
        sys.last_traceback = tb
        if filename and type is SyntaxError:
            # Work hard to stuff the correct filename in the exception
            try:
                msg, (dummy_filename, lineno, offset, line) = value.args
            except ValueError:
                # Not the format we expect; leave it alone
                pass
            else:
                # Stuff in the right filename
                value = SyntaxError(msg, (filename, lineno, offset, line))
                sys.last_value = value
        list = traceback.format_exception_only(type, value)
        sys.stderr.write(''.join(list)) 
Example 26
Project: specto   Author: mrknow   File: pydevconsole.py    (license) View Source Project 6 votes vote down vote up
def showtraceback(self):
        """Display the exception that just occurred."""
        #Override for avoid using sys.excepthook PY-12600
        try:
            type, value, tb = sys.exc_info()
            sys.last_type = type
            sys.last_value = value
            sys.last_traceback = tb
            tblist = traceback.extract_tb(tb)
            del tblist[:1]
            lines = traceback.format_list(tblist)
            if lines:
                lines.insert(0, "Traceback (most recent call last):\n")
            lines.extend(traceback.format_exception_only(type, value))
        finally:
            tblist = tb = None
        sys.stderr.write(''.join(lines)) 
Example 27
Project: borgcube   Author: enkore   File: server.py    (license) View Source Project 6 votes vote down vote up
def exit_by_exception():
    class SignalException(BaseException):
        pass

    def signal_fork(signum, stack_frame):
        log.info('Received signal %d, procuring hariki', signum)
        raise SignalException(signum)

    def excepthook(exc_type, exc_value, exc_trace):
        if exc_type is SignalException:
            sys.exit(1)
        else:
            sys.__excepthook__(exc_type, exc_value, exc_trace)

    sys.excepthook = excepthook
    signal.signal(signal.SIGINT, signal_fork)
    signal.signal(signal.SIGTERM, signal_fork) 
Example 28
Project: learneveryword   Author: karan   File: awsqueryrequest.py    (license) View Source Project 6 votes vote down vote up
def boto_except_hook(debugger_flag, debug_flag):
    def excepthook(typ, value, tb):
        if typ is bdb.BdbQuit:
            sys.exit(1)
        sys.excepthook = sys.__excepthook__

        if debugger_flag and sys.stdout.isatty() and sys.stdin.isatty():
            if debugger.__name__ == 'epdb':
                debugger.post_mortem(tb, typ, value)
            else:
                debugger.post_mortem(tb)
        elif debug_flag:
            print(traceback.print_tb(tb))
            sys.exit(1)
        else:
            print(value)
            sys.exit(1)

    return excepthook 
Example 29
Project: learneveryword   Author: karan   File: awsqueryrequest.py    (license) View Source Project 6 votes vote down vote up
def process_standard_options(self, options, args, d):
        if hasattr(options, 'help_filters') and options.help_filters:
            print('Available filters:')
            for filter in self.Filters:
                print('%s\t%s' % (filter.name, filter.doc))
            sys.exit(0)
        if options.debug:
            self.args['debug'] = 2
        if options.url:
            self.args['url'] = options.url
        if options.region:
            self.args['region'] = options.region
        if options.access_key_id:
            self.args['aws_access_key_id'] = options.access_key_id
        if options.secret_key:
            self.args['aws_secret_access_key'] = options.secret_key
        if options.version:
            # TODO - Where should the version # come from?
            print('version x.xx')
            exit(0)
        sys.excepthook = boto_except_hook(options.debugger,
                                          options.debug) 
Example 30
Project: proator   Author: mohit-thakur-721   File: function_prototype.py    (license) View Source Project 6 votes vote down vote up
def prototype(*outer_args,**outer_kwargs):  
    """ Verify that a method is called with a valid data type value.
        The datatype of a parameter must be a one of the type 
        defined in types package. 
    """
    def decorator(fn):                                          
        def decorated(*args,**kwargs):                            
            #do_something(*outer_args,**outer_kwargs)
            if len(outer_args)!=len(args):
                sys.excepthook = __exceptionHandler__
                raise Exception("Invalid Number of "
                "arguments in function call")
            for [typ, var] in zip(outer_args, args):
                if ( isinstance(var, typ)):
                    pass
                else:
                    sys.excepthook = __exceptionHandler__
                    raise Exception("Invalid Type")
            return fn(*args,**kwargs)                         
        return decorated                                          
    return decorator 
Example 31
Project: proator   Author: mohit-thakur-721   File: function_prototype.py    (license) View Source Project 6 votes vote down vote up
def ovrprototype(*outer_args,**outer_kwargs):  
    """ Verify that a method is called with a valid data type value.
        The datatype of a parameter must be a list of type defined 
        in package types. 
    """
    def decorator(fn):                                          
        def decorated(*args,**kwargs):                            
            #do_something(*outer_args,**outer_kwargs)
            if len(outer_args)!=len(args):
                sys.excepthook = __exceptionHandler__
                raise Exception("Invalid Number of "
                "arguments in function call")
            for [typ, var] in zip(outer_args, args):
                matched = False
                for i_typ in typ:
                    if ( isinstance(var, i_typ)):
                        matched = True
                        break
                if matched == False:
                    sys.excepthook = __exceptionHandler__
                    raise Exception("Invalid Type")
            return fn(*args,**kwargs)                         
        return decorated                                          
    return decorator 
Example 32
Project: python-   Author: secondtonone1   File: weakref.py    (license) View Source Project 5 votes vote down vote up
def _exitfunc(cls):
        # At shutdown invoke finalizers for which atexit is true.
        # This is called once all other non-daemonic threads have been
        # joined.
        reenable_gc = False
        try:
            if cls._registry:
                import gc
                if gc.isenabled():
                    reenable_gc = True
                    gc.disable()
                pending = None
                while True:
                    if pending is None or finalize._dirty:
                        pending = cls._select_for_exit()
                        finalize._dirty = False
                    if not pending:
                        break
                    f = pending.pop()
                    try:
                        # gc is disabled, so (assuming no daemonic
                        # threads) the following is the only line in
                        # this function which might trigger creation
                        # of a new finalizer
                        f()
                    except Exception:
                        sys.excepthook(*sys.exc_info())
                    assert f not in cls._registry
        finally:
            # prevent any more finalizers from executing during shutdown
            finalize._shutdown = True
            if reenable_gc:
                gc.enable() 
Example 33
Project: kinect-2-libras   Author: inessadl   File: site.py    (Apache License 2.0) View Source Project 5 votes vote down vote up
def execsitecustomize():
    """Run custom site specific code, if available."""
    try:
        import sitecustomize
    except ImportError:
        pass
    except Exception:
        if sys.flags.verbose:
            sys.excepthook(*sys.exc_info())
        else:
            print >>sys.stderr, \
                "'import sitecustomize' failed; use -v for traceback" 
Example 34
Project: kinect-2-libras   Author: inessadl   File: site.py    (Apache License 2.0) View Source Project 5 votes vote down vote up
def execusercustomize():
    """Run custom user specific code, if available."""
    try:
        import usercustomize
    except ImportError:
        pass
    except Exception:
        if sys.flags.verbose:
            sys.excepthook(*sys.exc_info())
        else:
            print>>sys.stderr, \
                "'import usercustomize' failed; use -v for traceback" 
Example 35
Project: kinect-2-libras   Author: inessadl   File: cgitb.py    (Apache License 2.0) View Source Project 5 votes vote down vote up
def enable(display=1, logdir=None, context=5, format="html"):
    """Install an exception handler that formats tracebacks as HTML.

    The optional argument 'display' can be set to 0 to suppress sending the
    traceback to the browser, and 'logdir' can be set to a directory to cause
    tracebacks to be written to files there."""
    sys.excepthook = Hook(display=display, logdir=logdir,
                          context=context, format=format) 
Example 36
Project: j3dview   Author: blank63   File: j3dview.py    (MIT License) View Source Project 5 votes vote down vote up
def excepthook(*exception_info):
        logger.error('unexpected error',exc_info=exception_info)

        message = QtGui.QMessageBox(None)
        message.setWindowTitle(QtGui.qApp.applicationName())
        message.setIcon(QtGui.QMessageBox.Critical)
        message.setText('An unexpected error occurred.')
        message.setDetailedText(logging_stream.getvalue())
        message.setStandardButtons(QtGui.QMessageBox.Ok)
        message.setDefaultButton(QtGui.QMessageBox.Ok)
        message.exec_()

        QtGui.qApp.exit() 
Example 37
Project: PyJFuzz   Author: mseclab   File: pjf_logger.py    (MIT License) View Source Project 5 votes vote down vote up
def init_logger():
        logging.basicConfig(filename="pjf_{0}.log".format(time.strftime("%d_%m_%Y")), level=PYJFUZZ_LOGLEVEL)
        logger = logging.getLogger(__name__)
        sys.tracebacklimit = 10

        def handle_exception(exc_type, exc_value, exc_traceback):
            if issubclass(exc_type, KeyboardInterrupt):
                sys.__excepthook__(exc_type, exc_value, exc_traceback)
                return
            logger.error("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
            sys.__excepthook__(exc_type, exc_value, None)
            return

        sys.excepthook = handle_exception
        return logger 
Example 38
Project: daiquiri   Author: jd   File: __init__.py    (Apache License 2.0) View Source Project 5 votes vote down vote up
def setup(level=logging.WARNING, outputs=[output.STDERR], program_name=None,
          capture_warnings=True):
    """Setup Python logging.

    This will setup basic handlers for Python logging.

    :param level: Root log level.
    :param outputs: Iterable of outputs to log to.
    :param program_name: The name of the program. Auto-detected if not set.
    :param capture_warnings: Capture warnings from the `warnings' module.
    """
    root_logger = logging.getLogger(None)

    # Remove all handlers
    for handler in list(root_logger.handlers):
        root_logger.removeHandler(handler)

    # Add configured handlers
    for out in outputs:
        if isinstance(out, str):
            out = output.preconfigured.get(out)
            if out is None:
                raise RuntimeError("Output {} is not available".format(out))
        out.add_to_logger(root_logger)

    root_logger.setLevel(level)

    program_logger = logging.getLogger(program_name)

    def logging_excepthook(exc_type, value, tb):
        program_logger.critical(
            "".join(traceback.format_exception(exc_type, value, tb)))

    sys.excepthook = logging_excepthook

    if capture_warnings:
        logging.captureWarnings(True) 
Example 39
Project: NeoAnalysis   Author: neoanalysis   File: test_stability.py    (license) View Source Project 5 votes vote down vote up
def crashtest():
    global allWidgets
    try:
        gc.disable()
        actions = [
                createWidget,
                #setParent,
                forgetWidget,
                showWidget,
                processEvents,
                #raiseException,
                #addReference,
                ]

        thread = WorkThread()
        thread.start()

        while True:
            try:
                action = randItem(actions)
                action()
                print('[%d widgets alive, %d zombie]' % (len(allWidgets), len(allWidgets) - len(widgets)))
            except KeyboardInterrupt:
                print("Caught interrupt; send another to exit.")
                try:
                    for i in range(100):
                        QtTest.QTest.qWait(100)
                except KeyboardInterrupt:
                    thread.terminate()
                    break
            except:
                sys.excepthook(*sys.exc_info())
    finally:
        gc.enable() 
Example 40
Project: NeoAnalysis   Author: neoanalysis   File: debug.py    (license) View Source Project 5 votes vote down vote up
def printException(exctype, value, traceback):
    """Print an exception with its full traceback.
    
    Set `sys.excepthook = printException` to ensure that exceptions caught
    inside Qt signal handlers are printed with their full stack trace.
    """
    print(''.join(formatException(exctype, value, traceback, skip=1))) 
Example 41
Project: NeoAnalysis   Author: neoanalysis   File: exceptionHandling.py    (license) View Source Project 5 votes vote down vote up
def implements(self, interface=None):
        ## this just makes it easy for us to detect whether an ExceptionHook is already installed.
        if interface is None:
            return ['ExceptionHandler']
        else:
            return interface == 'ExceptionHandler'
    


## replace built-in excepthook only if this has not already been done 
Example 42
Project: NeoAnalysis   Author: neoanalysis   File: processes.py    (license) View Source Project 5 votes vote down vote up
def eventLoop(self):
        while True:
            try:
                self.processRequests()  # exception raised when the loop should exit
                time.sleep(0.01)
            except ClosedError:
                break
            except:
                print("Error occurred in forked event loop:")
                sys.excepthook(*sys.exc_info())
        sys.exit(0) 
Example 43
Project: NeoAnalysis   Author: neoanalysis   File: parallelizer.py    (license) View Source Project 5 votes vote down vote up
def __exit__(self, *exc_info):
        
        if self.proc is not None:  ## worker 
            exceptOccurred = exc_info[0] is not None ## hit an exception during processing.
                
            try:
                if exceptOccurred:
                    sys.excepthook(*exc_info)
            finally:
                #print os.getpid(), 'exit'
                os._exit(1 if exceptOccurred else 0)
                
        else:  ## parent
            if self.showProgress:
                self.progressDlg.__exit__(None, None, None) 
Example 44
Project: NeoAnalysis   Author: neoanalysis   File: setup.py    (license) View Source Project 5 votes vote down vote up
def run(self):
        global path, version, initVersion, forcedVersion, installVersion
        
        name = self.config_vars['dist_name']
        print(name)
        path = os.path.join(self.install_libbase, 'NeoAnalysis')
        if os.path.exists(path):
            raise Exception("It appears another version of %s is already "
                            "installed at %s; remove this before installing." 
                            % (name, path))
        print("Installing to %s" % path)
        rval = install.install.run(self)

        
        # If the version in __init__ is different from the automatically-generated
        # version string, then we will update __init__ in the install directory
        if initVersion == version:
            return rval
        
        try:
            initfile = os.path.join(path, '__init__.py')
            data = open(initfile, 'r').read()
            open(initfile, 'w').write(re.sub(r"__version__ = .*", "__version__ = '%s'" % version, data))
            installVersion = version
        except:
            sys.stderr.write("Warning: Error occurred while setting version string in build path. "
                             "Installation will use the original version string "
                             "%s instead.\n" % (initVersion)
                             )
            if forcedVersion:
                raise
            installVersion = initVersion
            sys.excepthook(*sys.exc_info())
    
        return rval 
Example 45
Project: NeoAnalysis   Author: neoanalysis   File: test_stability.py    (license) View Source Project 5 votes vote down vote up
def crashtest():
    global allWidgets
    try:
        gc.disable()
        actions = [
                createWidget,
                #setParent,
                forgetWidget,
                showWidget,
                processEvents,
                #raiseException,
                #addReference,
                ]

        thread = WorkThread()
        thread.start()

        while True:
            try:
                action = randItem(actions)
                action()
                print('[%d widgets alive, %d zombie]' % (len(allWidgets), len(allWidgets) - len(widgets)))
            except KeyboardInterrupt:
                print("Caught interrupt; send another to exit.")
                try:
                    for i in range(100):
                        QtTest.QTest.qWait(100)
                except KeyboardInterrupt:
                    thread.terminate()
                    break
            except:
                sys.excepthook(*sys.exc_info())
    finally:
        gc.enable() 
Example 46
Project: NeoAnalysis   Author: neoanalysis   File: debug.py    (license) View Source Project 5 votes vote down vote up
def printException(exctype, value, traceback):
    """Print an exception with its full traceback.
    
    Set `sys.excepthook = printException` to ensure that exceptions caught
    inside Qt signal handlers are printed with their full stack trace.
    """
    print(''.join(formatException(exctype, value, traceback, skip=1))) 
Example 47
Project: NeoAnalysis   Author: neoanalysis   File: exceptionHandling.py    (license) View Source Project 5 votes vote down vote up
def implements(self, interface=None):
        ## this just makes it easy for us to detect whether an ExceptionHook is already installed.
        if interface is None:
            return ['ExceptionHandler']
        else:
            return interface == 'ExceptionHandler'
    


## replace built-in excepthook only if this has not already been done 
Example 48
Project: NeoAnalysis   Author: neoanalysis   File: parallelizer.py    (license) View Source Project 5 votes vote down vote up
def __exit__(self, *exc_info):
        
        if self.proc is not None:  ## worker 
            exceptOccurred = exc_info[0] is not None ## hit an exception during processing.
                
            try:
                if exceptOccurred:
                    sys.excepthook(*exc_info)
            finally:
                #print os.getpid(), 'exit'
                os._exit(1 if exceptOccurred else 0)
                
        else:  ## parent
            if self.showProgress:
                self.progressDlg.__exit__(None, None, None) 
Example 49
Project: NeoAnalysis   Author: neoanalysis   File: setup.py    (license) View Source Project 5 votes vote down vote up
def run(self):
        global path, version, initVersion, forcedVersion, installVersion
        
        name = self.config_vars['dist_name']
        print(name)
        path = os.path.join(self.install_libbase, 'NeoAnalysis')
        if os.path.exists(path):
            raise Exception("It appears another version of %s is already "
                            "installed at %s; remove this before installing." 
                            % (name, path))
        print("Installing to %s" % path)
        rval = install.install.run(self)

        
        # If the version in __init__ is different from the automatically-generated
        # version string, then we will update __init__ in the install directory
        if initVersion == version:
            return rval
        
        try:
            initfile = os.path.join(path, '__init__.py')
            data = open(initfile, 'r').read()
            open(initfile, 'w').write(re.sub(r"__version__ = .*", "__version__ = '%s'" % version, data))
            installVersion = version
        except:
            sys.stderr.write("Warning: Error occurred while setting version string in build path. "
                             "Installation will use the original version string "
                             "%s instead.\n" % (initVersion)
                             )
            if forcedVersion:
                raise
            installVersion = initVersion
            sys.excepthook(*sys.exc_info())
    
        return rval 
Example 50
Project: piperine   Author: DNA-and-Natural-Algorithms-Group   File: energetics.py    (MIT License) View Source Project 5 votes vote down vote up
def exceptionhook(exception_type, exception, traceback, default_hook = sys.excepthook):
    if 'Toehold' in exception_type.__name__ :
        print("{}: {}".format('RuntimeError', exception.message))
    else:
        default_hook(exception_type, exception, traceback)