def start(self, application):
     """ Starts the plugin.
     """
     # Tell the FBI to wiretap all unauthorized exceptions:
     enable_fbi()
     push_exception_handler(
         handler=lambda obj, name, old, new: fbi(), locked=False, main=True)
예제 #2
0
def setup():
    # If a trait exception occurs, fail the test.
    push_exception_handler(
        handler=lambda o, t, ov, nv: None,
        reraise_exceptions=True,
        main=True,
    )
예제 #3
0
파일: run.py 프로젝트: ritika-giri/cytoflow
def remote_main(parent_workflow_conn, parent_mpl_conn, log_q, running_event):
    # this should only ever be main method after a spawn() call
    # (not fork). So we should have a fresh logger to set up.

    # messages that end up at the root logger to go log_q
    from logging.handlers import QueueHandler
    h = QueueHandler(log_q)
    logging.getLogger().addHandler(h)

    # We want matplotlib to use our backend .... in both the GUI and the
    # remote process.  Must be called BEFORE cytoflow is imported

    import matplotlib
    matplotlib.use('module://cytoflowgui.matplotlib_backend_remote')

    from traits.api import push_exception_handler
    from cytoflowgui.workflow import RemoteWorkflow

    # install a global (gui) error handler for traits notifications
    push_exception_handler(handler=log_notification_handler,
                           reraise_exceptions=False,
                           main=True)

    sys.excepthook = log_excepthook

    # take care of the 3 places in the cytoflow module that
    # need different behavior in a GUI
    import cytoflow
    cytoflow.RUNNING_IN_GUI = True

    running_event.set()
    RemoteWorkflow().run(parent_workflow_conn, parent_mpl_conn)
예제 #4
0
 def start ( self, application ):
     """ Starts the plugin.
     """
     # Tell the FBI to wiretap all unauthorized exceptions:
     enable_fbi()
     push_exception_handler( handler = lambda obj, name, old, new: fbi(),
                             locked  = False,
                             main    = True )
예제 #5
0
def traits_test_context():
    """Context to raise errors in trait handlers."""
    from traits.api import push_exception_handler

    push_exception_handler(reraise_exceptions=True)
    try:
        yield
    finally:
        push_exception_handler(reraise_exceptions=False)
예제 #6
0
def traits_test_context():
    """Context to raise errors in trait handlers."""
    from traits.api import push_exception_handler

    push_exception_handler(reraise_exceptions=True)
    try:
        yield
    finally:
        push_exception_handler(reraise_exceptions=False)
예제 #7
0
 def setUp(self):
     self.binder = DummyBinder()
     self.model = DummyModel()
     self.blah = DummyBinder()
     self.context = dict(
         object=self.model,
         blah=self.blah,
     )
     push_exception_handler(lambda *args, **kwds: None,
                            reraise_exceptions=True)
예제 #8
0
 def setUp(self):
     self.binder = DummyBinder()
     self.model = DummyModel()
     self.blah = DummyBinder()
     self.context = dict(
         object=self.model,
         blah=self.blah,
     )
     push_exception_handler(lambda *args, **kwds: None,
                            reraise_exceptions=True)
예제 #9
0
def remote_main(parent_workflow_conn, parent_mpl_conn, log_q):
    from cytoflowgui.workflow import RemoteWorkflow

    # install a global (gui) error handler for traits notifications
    push_exception_handler(handler=log_notification_handler,
                           reraise_exceptions=debug,
                           main=True)

    sys.excepthook = log_excepthook

    RemoteWorkflow().run(parent_workflow_conn, parent_mpl_conn, log_q)
예제 #10
0
파일: field.py 프로젝트: 5n1p/enaml
    def test_validator_change(self):
        """ Check that changing a validator works properly.

        """
        output = [False]
        def handler(obj, name, old, new):
            output[0] = True
        push_exception_handler(handler)
        old = self.component.validator
        self.component.validator = IntValidator()
        self.component.validator = old
        pop_exception_handler()
        self.assertTrue(output[0])
예제 #11
0
def reraise_exceptions(logger=_TRAITSUI_LOGGER):
    """ Context manager to capture all exceptions occurred in the context and
    then reraise a RuntimeError if there are any exceptions captured.

    Exceptions from traits change notifications are also captured and reraised.

    Depending on the GUI toolkit backend, unexpected exceptions occurred in the
    GUI event loop may (1) cause fatal early exit of the test suite or (2) be
    printed to the console without causing the test to error. This context
    manager is intended for testing purpose such that unexpected exceptions
    will result in a test error.

    Parameters
    ----------
    logger : logging.Logger
        Logger to use for logging errors.
    """
    serialized_exceptions = []

    def excepthook(type, value, tb):
        serialized = _serialize_exception(type, value, tb)
        serialized_exceptions.append(serialized)
        logger.error("Unexpected error captured in sys excepthook. \n%s",
                     serialized[-1])

    def handler(object, name, old, new):
        type, value, tb = sys.exc_info()
        serialized_exceptions.append(_serialize_exception(type, value, tb))
        logger.exception(
            "Unexpected error occurred from change handler "
            "(object: %r, name: %r, old: %r, new: %r).",
            object,
            name,
            old,
            new,
        )

    push_exception_handler(handler=handler)
    sys.excepthook = excepthook
    try:
        yield
    finally:
        sys.excepthook = sys.__excepthook__
        pop_exception_handler()
        if serialized_exceptions:
            msg = "Uncaught exceptions found.\n"
            msg += "\n".join("=== Exception (type: {}, value: {}) ===\n"
                             "{}".format(*record)
                             for record in serialized_exceptions)
            raise RuntimeError(msg)
예제 #12
0
    def test_validator_change(self):
        """ Check that changing a validator works properly.

        """
        output = [False]

        def handler(obj, name, old, new):
            output[0] = True

        push_exception_handler(handler)
        old = self.component.validator
        self.component.validator = IntValidator()
        self.component.validator = old
        pop_exception_handler()
        self.assertTrue(output[0])
    def setUp(self):
        """ Prepares the test fixture before each test method is called. """

        self.preferences = set_default_preferences(Preferences())

        # The filename of the example preferences file.
        self.example = os.fspath(files(PKG) / "example.ini")

        # A temporary directory that can safely be written to.
        self.tmpdir = tempfile.mkdtemp()

        # Path to a temporary file
        self.tmpfile = os.path.join(self.tmpdir, "tmp.ini")

        push_exception_handler(reraise_exceptions=True)
        self.addCleanup(pop_exception_handler)
예제 #14
0
def init_error_handlers(debug = False):
    """ Initialize application error handlers.
    """
    # Configure logging.
    logging.basicConfig()
    logger = logging.getLogger('nemesis')
    logger.setLevel(logging.DEBUG if debug else logging.WARN)
    
    # Prevent Traits from suppressing errors.
    push_exception_handler(handler = lambda o, t, ov, nv: None,
                            reraise_exceptions = True,
                            main = True, locked = True)
    
    # Install GUI exception handler.
    if not debug:
        sys.excepthook = gui_except_hook
예제 #15
0
    def setUp(self):
        # Start up a QApplication if needed.
        self.app = QtGui.QApplication.instance()
        if self.app is None:
            self.app = QtGui.QApplication([])

        push_exception_handler(reraise_exceptions=True)

        # We make a new class here to test that the traits get added only at
        # the right time.
        # WARNING: If anyone instantiates Binder() itself, this subclass will
        # see its added traits, and the test will fail.
        class Object(Binder):
            qclass = QtCore.QObject

            x = QtDynamicProperty(10)

        self.Object = Object
예제 #16
0
    def setUp(self):
        # Start up a QApplication if needed.
        self.app = QtGui.QApplication.instance()
        if self.app is None:
            self.app = QtGui.QApplication([])

        push_exception_handler(reraise_exceptions=True)

        # We make a new class here to test that the traits get added only at
        # the right time.
        # WARNING: If anyone instantiates Binder() itself, this subclass will
        # see its added traits, and the test will fail.
        class Object(Binder):
            qclass = QtCore.QObject

            x = QtDynamicProperty(10)

        self.Object = Object
예제 #17
0
def remote_main(parent_workflow_conn, parent_mpl_conn, log_q, running_event):
    # We want matplotlib to use our backend .... in both the GUI and the
    # remote process.  Must be called BEFORE cytoflow is imported

    import matplotlib
    matplotlib.use('module://cytoflowgui.matplotlib_backend')

    from traits.api import push_exception_handler
    from cytoflowgui.workflow import RemoteWorkflow

    # install a global (gui) error handler for traits notifications
    push_exception_handler(handler=log_notification_handler,
                           reraise_exceptions=False,
                           main=True)

    sys.excepthook = log_excepthook

    running_event.set()
    RemoteWorkflow().run(parent_workflow_conn, parent_mpl_conn, log_q)
예제 #18
0
def notification_context(handler=null_handler, reraise_exceptions=True, main=False, locked=True):
    """ Context manager to temporarily add a TraitsExceptionHandler
    
    We use a context manager to ensure that the exception handler gets cleared
    no matter what.  Default behaviour is to use the null_handler with
    exceptions re-raised, which means any exceptions which occur will be passed
    through.
    
    """
    yield push_exception_handler(handler, reraise_exceptions, main, locked)
    pop_exception_handler()
예제 #19
0
def main():
    """ A program for visualizing Sim4Life EM fields from scES simulations
    """
    configuration = ConfigParser()
    configuration.read_file(open('src/default.ini'))
    configuration.read(['config.ini'])
    push_exception_handler(reraise_exceptions=True)
    # Create the GUI (this does NOT start the GUI event loop).
    gui = GUI()

    # Create a Task and add it to a TaskWindow.
    task = S4LVisualizationTask(configuration=configuration)
    window = TaskWindow(
        size=(configuration.getint('Display', 'window_width'),
              configuration.getint('Display', 'window_height')))
    window.add_task(task)

    # Show the window.
    window.open()

    # Start the GUI event loop.
    gui.start_event_loop()
예제 #20
0
파일: main.py 프로젝트: ericpre/spacetime
	def run(self):
		options, args = self.parseargs()

		logger = logging.getLogger()
		if options.debug:
			logger.setLevel(logging.DEBUG)
		else:
			logger.setLevel(logging.WARNING)

		sys.excepthook = self.excepthook
		traits.push_exception_handler(self.trait_exception_handler, main=True, locked=True)

		if options.pypy:
			if platform.system() == 'Windows' and sys.executable:
				prefix = os.path.dirname(sys.executable)
				pypymanager.set_executable(os.path.join(prefix, 'pypy', 'pypy.exe'))
			else:
				pypymanager.set_executable('pypy')
			pypymanager.launch_delegate()

		try:
			app = wx.App(False)

			self.moduleloader = modules.loader.Loader()
			self.ui = self.edit_traits()
			self.context.uiparent = self.ui.control
			self.context.plot = self.plot
			self.prefs.restore_window('main', self.ui)
			self.init_recent_menu()

			if args:
				# passing in 'self' for the info argument is a bit of a hack, but fortunately self.ui.context seems to be working fine
				self.ui.handler.do_open(self, args[0])
				# silently ignore multiple projects for Windows Explorer integration

			app.MainLoop()
		finally:
			pypymanager.shutdown_delegate()
예제 #21
0
파일: exceptions.py 프로젝트: rwl/enaml
def notification_context(handler=null_handler,
                         reraise_exceptions=True,
                         main=False,
                         locked=True):
    """ Context manager to temporarily add a TraitsExceptionHandler
    
    We use a context manager to ensure that the exception handler gets cleared
    no matter what.  Default behaviour is to use the null_handler with
    exceptions re-raised, which means any exceptions which occur will be passed
    through.
    
    """
    yield push_exception_handler(handler, reraise_exceptions, main, locked)
    pop_exception_handler()
예제 #22
0
파일: run.py 프로젝트: netphone/cytoflow
def remote_main(parent_workflow_conn, parent_mpl_conn, log_q, running_event):
    # We want matplotlib to use our backend .... in both the GUI and the
    # remote process.  Must be called BEFORE cytoflow is imported
    
    import matplotlib
    matplotlib.use('module://cytoflowgui.matplotlib_backend_remote')
    
    from traits.api import push_exception_handler    
    from cytoflowgui.workflow import RemoteWorkflow
    
    # install a global (gui) error handler for traits notifications
    push_exception_handler(handler = log_notification_handler,
                           reraise_exceptions = False,
                           main = True)
    
    sys.excepthook = log_excepthook
    
    # take care of the 3 places in the cytoflow module that
    # need different behavior in a GUI
    import cytoflow
    cytoflow.RUNNING_IN_GUI = True
    
    running_event.set()
    RemoteWorkflow().run(parent_workflow_conn, parent_mpl_conn, log_q)
예제 #23
0
import pandas as pd
from traits.api import (HasTraits, File, Property, Int, Str, Dict, List, Type,
                        Bool, Either, push_exception_handler, cached_property,
                        Array, Instance, Float, Any)

from pysemantic.utils import TypeEncoder, get_md5_checksum, colnames
from pysemantic.custom_traits import (DTypesDict, NaturalNumber, AbsFile,
                                      ValidTraitList)

try:
    from yaml import CDumper as Dumper
    from yaml import CLoader as Loader
except ImportError:
    from yaml import Dumper, Loader

push_exception_handler(lambda *args: None, reraise_exceptions=True)
logger = logging.getLogger(__name__)


class DataFrameValidator(HasTraits):

    """A validator class for `pandas.DataFrame` objects."""

    # The dataframe in question
    data = Instance(pd.DataFrame)

    # the column rules to be enforced
    column_rules = Dict

    # rules related to the dataset itself
    rules = Dict
예제 #24
0
 def setUp(self):
     super(TestUiLoader, self).setUp()
     push_exception_handler(reraise_exceptions=True)
예제 #25
0
def setup_package():
    push_exception_handler(handler=lambda *args, **kwds: None, reraise_exceptions=True)
예제 #26
0
 def __enter__(self):
     self.notification_handler = push_exception_handler(self.handler,
         self.reraise_exceptions, self.main, self.locked)
     return self
예제 #27
0
def run_gui():
    debug = ("--debug" in sys.argv)

    remote_process, remote_connection = start_remote_process(debug)

    import matplotlib

    # We want matplotlib to use our backend
    matplotlib.use('module://cytoflowgui.matplotlib_backend')

    # getting real tired of the matplotlib deprecation warnings
    import warnings
    warnings.filterwarnings('ignore', '.*is deprecated and replaced with.*')

    from traits.api import push_exception_handler

    def QtMsgHandler(msg_type, msg_string):
        # Convert Qt msg type to logging level
        log_level = [
            logging.DEBUG, logging.WARN, logging.ERROR, logging.FATAL
        ][int(msg_type)]
        logging.log(log_level, 'Qt message: ' + msg_string.decode('utf-8'))

    ## monkey-patch envisage for a py3k bug.  this is fixed in envisage HEAD,
    ## so check for version
    import envisage
    if envisage.__version__ == '4.6.0':
        import pickle
        from envisage.ui.tasks.tasks_application import TasksApplication, TasksApplicationState
        logger = logging.getLogger(__name__)
        logger.info("Monkey-patching envisage 4.6.0")

        def _envisage_load_state(self):
            """ Loads saved application state, if possible.
            """
            state = TasksApplicationState()
            filename = os.path.join(self.state_location, 'application_memento')
            if os.path.exists(filename):
                # Attempt to unpickle the saved application state.
                try:
                    with open(filename, 'rb') as f:
                        restored_state = pickle.load(f)
                    if state.version == restored_state.version:
                        state = restored_state
                    else:
                        logger.warn('Discarding outdated application layout')
                except:
                    # If anything goes wrong, log the error and continue.
                    logger.exception('Restoring application layout from %s',
                                     filename)

            self._state = state

        def _envisage_save_state(self):
            """ Saves the application state.
            """
            # Grab the current window layouts.
            window_layouts = [w.get_window_layout() for w in self.windows]
            self._state.previous_window_layouts = window_layouts

            # Attempt to pickle the application state.
            filename = os.path.join(self.state_location, 'application_memento')
            try:
                with open(filename, 'wb') as f:
                    pickle.dump(self._state, f)
            except:
                # If anything goes wrong, log the error and continue.
                logger.exception('Saving application layout')

        TasksApplication._load_state = _envisage_load_state
        TasksApplication._save_state = _envisage_save_state

    from envisage.core_plugin import CorePlugin
    from envisage.ui.tasks.tasks_plugin import TasksPlugin
    from pyface.image_resource import ImageResource

    from cytoflowgui.flow_task import FlowTaskPlugin
    from cytoflowgui.cytoflow_application import CytoflowApplication
    from cytoflowgui.op_plugins import (
        ImportPlugin,
        ThresholdPlugin,
        RangePlugin,
        QuadPlugin,
        Range2DPlugin,
        PolygonPlugin,
        BinningPlugin,
        GaussianMixture1DPlugin,
        GaussianMixture2DPlugin,
        BleedthroughLinearPlugin,  #BleedthroughPiecewisePlugin,
        BeadCalibrationPlugin,
        AutofluorescencePlugin,
        ColorTranslationPlugin,
        TasbePlugin,
        ChannelStatisticPlugin,
        TransformStatisticPlugin,
        RatioPlugin)

    from cytoflowgui.view_plugins import (
        HistogramPlugin,
        Histogram2DPlugin,
        ScatterplotPlugin,
        BarChartPlugin,
        Stats1DPlugin,
        Kde1DPlugin,  #Kde2DPlugin,
        ViolinPlotPlugin,
        TablePlugin,
        Stats2DPlugin)
    #    assert(multiprocessing.get_start_method() == "spawn")

    from cytoflow.utility.custom_traits import Removed, Deprecated
    Removed.gui = True
    Deprecated.gui = True

    from pyface.qt import qt_api

    cmd_line = " ".join(sys.argv)

    if qt_api == "pyside":
        print("Cytoflow uses PyQT; but it is trying to use PySide instead.")
        print(" - Make sure PyQT is installed.")
        print(
            " - If both are installed, and you don't need both, uninstall PySide."
        )
        print(" - If you must have both installed, select PyQT by setting the")
        print("   environment variable QT_API to \"pyqt\"")
        print("   * eg, on Linux, type on the command line:")
        print("     QT_API=\"pyqt\" " + cmd_line)
        print("   * on Windows, try: ")
        print("     setx QT_API \"pyqt\"")

        sys.exit(1)

    from pyface.qt.QtCore import qInstallMsgHandler
    qInstallMsgHandler(QtMsgHandler)

    # if we're frozen, add _MEIPASS to the pyface search path for icons etc
    if getattr(sys, 'frozen', False):
        from pyface.resource_manager import resource_manager
        resource_manager.extra_paths.append(sys._MEIPASS)  # @UndefinedVariable

    # install a global (gui) error handler for traits notifications
    push_exception_handler(handler=log_notification_handler,
                           reraise_exceptions=debug,
                           main=True)

    sys.excepthook = log_excepthook

    plugins = [
        CorePlugin(),
        TasksPlugin(),
        FlowTaskPlugin(debug=debug, remote_connection=remote_connection)
    ]

    # reverse of the order on the toolbar
    view_plugins = [
        TablePlugin(),
        Stats2DPlugin(),
        Stats1DPlugin(),
        BarChartPlugin(),
        ViolinPlotPlugin(),
        #                     Kde2DPlugin(),    # disabled until we can make it faster
        Kde1DPlugin(),
        Histogram2DPlugin(),
        ScatterplotPlugin(),
        HistogramPlugin()
    ]

    plugins.extend(view_plugins)

    op_plugins = [
        RatioPlugin(),
        TransformStatisticPlugin(),
        ChannelStatisticPlugin(),
        TasbePlugin(),
        ColorTranslationPlugin(),
        AutofluorescencePlugin(),
        BeadCalibrationPlugin(),
        #                   BleedthroughPiecewisePlugin(),
        BleedthroughLinearPlugin(),
        GaussianMixture2DPlugin(),
        GaussianMixture1DPlugin(),
        BinningPlugin(),
        PolygonPlugin(),
        QuadPlugin(),
        Range2DPlugin(),
        RangePlugin(),
        ThresholdPlugin(),
        ImportPlugin()
    ]

    plugins.extend(op_plugins)

    # these two lines stop pkg_resources from trying to load resources
    # from the __main__ module, which is frozen (and thus not loadable.)
    icon = ImageResource('icon')
    icon.search_path = []

    app = CytoflowApplication(id='edu.mit.synbio.cytoflow',
                              plugins=plugins,
                              icon=icon,
                              debug=debug)
    app.run()
    remote_process.join()
    logging.shutdown()
예제 #28
0
 def setUp(self):
     push_exception_handler(lambda *args: None, reraise_exceptions=True)
예제 #29
0
 def setUp(self):
     push_exception_handler(reraise_exceptions=True)
예제 #30
0
    def setUp(self):
        def ignore(*args):
            pass

        push_exception_handler(handler=ignore, reraise_exceptions=True)
예제 #31
0
 def setUp(self):
     push_exception_handler(reraise_exceptions=True)
     self.addCleanup(pop_exception_handler)
예제 #32
0
def rotate_scene(t):
    """
    Rotate the camera of the mayavi scene at time t.

    :param t: time in the range [0, duration]
    :return: a screenshot of the scene
    """
    mlab.view(azimuth=360 / duration * t, elevation=63, distance=distance)
    return mlab.screenshot(figure=myfig, mode='rgb',
                           antialiased=True)  # return a RGB image


#############
# load data #
#############
push_exception_handler(
    reraise_exceptions=True)  # force exceptions to be re-raised in Traits
root = tk.Tk()
root.withdraw()

file_path = filedialog.askopenfilename(initialdir=homedir,
                                       title="Select the diffraction pattern",
                                       filetypes=[("NPZ", "*.npz")])
data, _ = util.load_file(file_path)
assert data.ndim == 3, 'data should be a 3D array'

nz, ny, nx = data.shape
print("Initial data shape: ", nz, ny, nx)

file_path = filedialog.askopenfilename(initialdir=homedir,
                                       title="Select q values",
                                       filetypes=[("NPZ", "*.npz")])
예제 #33
0

from mayavi import mlab
from mayavi.core import lut_manager
from mayavi.core.ui.api import MlabSceneModel, SceneEditor
from mayavi.core.ui.mayavi_scene import MayaviScene

from pyface.api import FileDialog, OK, confirm, YES, GUI

from tvtk.api import tvtk

from traits.api import push_exception_handler


push_exception_handler( handler = lambda o,t,ov,nv: None,
                        reraise_exceptions = True,
                        main = True,
                        locked = True )



class MouseHandler(object):
    """
    interactor style for escher application. how to do right clicking on mousepad?
    create toggle button for mousepad?

    rotation needs be improved; pick point on right click and match it to raycasted point
    left click; for spline manipulation, raycast to sphere
    for height editor, pick world coord on surface
    """
    def __init__(self, interactor):
        self.interactor = interactor
 def setUp(self):
     push_exception_handler(lambda *args: None, reraise_exceptions=True)
예제 #35
0
파일: exceptions.py 프로젝트: rwl/enaml
 def __enter__(self):
     self.notification_handler = push_exception_handler(
         self.handler, self.reraise_exceptions, self.main, self.locked)
     return self
예제 #36
0
파일: run.py 프로젝트: ritika-giri/cytoflow
def run_gui():
    import os, sys
    try:
        # if we're running as a one-click from a MacOS app,
        # we need to reset the working directory
        os.chdir(sys._MEIPASS)
    except:
        # if we're not running as a one-click, fail gracefully
        pass

    # take care of the 3 places in the cytoflow module that
    # need different behavior in a GUI
    import cytoflow
    cytoflow.RUNNING_IN_GUI = True

    # this is ridiculous, but here's the situation.  Qt5 now uses Chromium
    # as their web renderer.  Chromium needs OpenGL.  if you don't
    # initialize OpoenGL here, things crash on some platforms.

    # so now i guess we depend on opengl too.

    from OpenGL import GL  # @UnresolvedImport @UnusedImport

    # check that we're using the right Qt API
    from pyface.qt import qt_api

    cmd_line = " ".join(sys.argv)

    if qt_api == "pyside":
        print("Cytoflow uses PyQT; but it is trying to use PySide instead.")
        print(" - Make sure PyQT is installed.")
        print(
            " - If both are installed, and you don't need both, uninstall PySide."
        )
        print(" - If you must have both installed, select PyQT by setting the")
        print("   environment variable QT_API to \"pyqt5\"")
        print("   * eg, on Linux, type on the command line:")
        print("     QT_API=\"pyqt5\" " + cmd_line)
        print("   * on Windows, try: ")
        print("     setx QT_API \"pyqt5\"")

        sys.exit(1)

    # parse args
    parser = argparse.ArgumentParser(description='Cytoflow GUI')
    parser.add_argument("--debug", action='store_true')
    parser.add_argument("filename", nargs='?', default="")

    args = parser.parse_args()

    # start the remote process

    remote_process, remote_connection, queue_listener = start_remote_process()

    # getting real tired of the matplotlib deprecation warnings
    import warnings
    warnings.filterwarnings('ignore', '.*is deprecated and replaced with.*')

    # if we're frozen, add _MEIPASS to the pyface search path for icons etc
    if getattr(sys, 'frozen', False):
        from pyface.resource_manager import resource_manager
        resource_manager.extra_paths.append(sys._MEIPASS)  # @UndefinedVariable

    # these three lines stop pkg_resources from trying to load resources
    # from the __main__ module, which is frozen (and thus not loadable.)
    from pyface.image_resource import ImageResource
    icon = ImageResource('icon')
    icon.search_path = []

    # monkey patch the resource manager to use SVGs for icons
    import pyface.resource.resource_manager
    pyface.resource.resource_manager.ResourceManager.IMAGE_EXTENSIONS.append(
        '.svg')

    # monkey patch checklist editor to stop lowercasing
    import traitsui.qt4.check_list_editor  # @UnusedImport
    traitsui.qt4.check_list_editor.capitalize = lambda s: s

    # define and install a message handler for Qt errors
    from traits.api import push_exception_handler

    def QtMsgHandler(msg_type, msg_context, msg_string):
        # Convert Qt msg type to logging level
        log_level = [
            logging.DEBUG, logging.WARN, logging.ERROR, logging.FATAL
        ][int(msg_type)]
        logging.log(log_level, 'Qt message: ' + msg_string)

    from pyface.qt.QtCore import qInstallMessageHandler  # @UnresolvedImport
    qInstallMessageHandler(QtMsgHandler)

    # install a global (gui) error handler for traits notifications
    push_exception_handler(handler=log_notification_handler,
                           reraise_exceptions=False,
                           main=True)

    sys.excepthook = log_excepthook

    # Import, then load, the envisage plugins

    from envisage.core_plugin import CorePlugin
    from envisage.ui.tasks.tasks_plugin import TasksPlugin

    from cytoflowgui.flow_task import FlowTaskPlugin
    from cytoflowgui.tasbe_task import TASBETaskPlugin
    from cytoflowgui.export_task import ExportFigurePlugin
    from cytoflowgui.cytoflow_application import CytoflowApplication
    from cytoflowgui.op_plugins import (
        ImportPlugin, ThresholdPlugin, RangePlugin, QuadPlugin, Range2DPlugin,
        PolygonPlugin, BinningPlugin, GaussianMixture1DPlugin,
        GaussianMixture2DPlugin, BleedthroughLinearPlugin,
        BeadCalibrationPlugin, AutofluorescencePlugin, ColorTranslationPlugin,
        TasbePlugin, ChannelStatisticPlugin, TransformStatisticPlugin,
        RatioPlugin, DensityGatePlugin, FlowPeaksPlugin, KMeansPlugin,
        PCAPlugin)

    from cytoflowgui.view_plugins import (
        HistogramPlugin, Histogram2DPlugin, ScatterplotPlugin, BarChartPlugin,
        Stats1DPlugin, Kde1DPlugin, Kde2DPlugin, ViolinPlotPlugin, TablePlugin,
        Stats2DPlugin, DensityPlugin, ParallelCoordinatesPlugin, RadvizPlugin)

    plugins = [
        CorePlugin(),
        TasksPlugin(),
        FlowTaskPlugin(),
        TASBETaskPlugin(),
        ExportFigurePlugin()
    ]

    # ordered as we want them to show up in the toolbar
    view_plugins = [
        HistogramPlugin(),
        ScatterplotPlugin(),
        Histogram2DPlugin(),
        DensityPlugin(),
        Kde1DPlugin(),
        Kde2DPlugin(),
        RadvizPlugin(),
        ParallelCoordinatesPlugin(),
        ViolinPlotPlugin(),
        BarChartPlugin(),
        Stats1DPlugin(),
        Stats2DPlugin(),
        TablePlugin()
    ]

    plugins.extend(view_plugins)

    op_plugins = [
        ImportPlugin(),
        ThresholdPlugin(),
        RangePlugin(),
        QuadPlugin(),
        Range2DPlugin(),
        PolygonPlugin(),
        RatioPlugin(),
        ChannelStatisticPlugin(),
        TransformStatisticPlugin(),
        BinningPlugin(),
        GaussianMixture1DPlugin(),
        GaussianMixture2DPlugin(),
        DensityGatePlugin(),
        KMeansPlugin(),
        FlowPeaksPlugin(),
        PCAPlugin(),
        AutofluorescencePlugin(),
        BleedthroughLinearPlugin(),
        BeadCalibrationPlugin(),
        ColorTranslationPlugin(),
        TasbePlugin()
    ]

    plugins.extend(op_plugins)

    # start the app

    app = CytoflowApplication(id='edu.mit.synbio.cytoflow',
                              plugins=plugins,
                              icon=icon,
                              remote_process=remote_process,
                              remote_connection=remote_connection,
                              filename=args.filename,
                              debug=args.debug)

    from pyface.qt import QtGui
    QtGui.QApplication.instance().setStyle(
        QtGui.QStyleFactory.create('Fusion'))

    app.run()

    remote_process.join()
    queue_listener.stop()
    logging.shutdown()
def setup():
    # If a trait exception occurs, fail the test.
    push_exception_handler( handler = lambda o,t,ov,nv: None,
                            reraise_exceptions = True,
                            main = True,
                          )
예제 #38
0
 def setUp(self):
     push_exception_handler(reraise_exceptions=True)
예제 #39
0
import numpy as np
from numpy.testing import assert_allclose
from traits.testing.unittest_tools import UnittestTools
from traits.api import push_exception_handler

import vtk

from mayavi import mlab
from mayavi.core.engine import Engine
from tvtk.api import tvtk
from mayavi.tools.engine_manager import engine_manager
from mayavi.core.registry import registry
from mayavi.tests.common import get_example_data

push_exception_handler(reraise_exceptions=True)  # XXX should probably be elsewhere


################################################################################
# class `TestMlabNullEngine`
###############################################################################
class TestMlabNullEngine(unittest.TestCase):
    """ Stub mlab to isolate as well as possible from creation of a new
        figure.
    """

    def _stop_unregister_all_engines(self):
        # Some tests leave around engines hanging around, so we clean them
        # up to avoid strange test errors.
        for engine in list(registry.engines.values()):
            engine.stop()
예제 #40
0
import numpy as np
from numpy.testing import assert_allclose
from traits.testing.unittest_tools import UnittestTools
from traits.api import push_exception_handler

import vtk

from mayavi import mlab
from mayavi.core.engine import Engine
from tvtk.api import tvtk
from mayavi.tools.engine_manager import engine_manager
from mayavi.core.registry import registry
from mayavi.tests.common import get_example_data

# XXX should probably be elsewhere
push_exception_handler(reraise_exceptions=True)


class TestMlabNullEngine(unittest.TestCase):
    """ Stub mlab to isolate as well as possible from creation of a new
        figure.
    """

    def _stop_unregister_all_engines(self):
        # Some tests leave around engines hanging around, so we clean them
        # up to avoid strange test errors.
        for engine in list(registry.engines.values()):
            engine.stop()
            registry.unregister_engine(engine)

    def setUp(self):
예제 #41
0
def main():
    # show complete stacktraces for debugging
    push_exception_handler(reraise_exceptions=True)
    gui = CiteOverlapGUI()
    gui.configure_traits()
예제 #42
0
 def setUp(self):
     push_exception_handler(handler=lambda *args: None,
                            reraise_exceptions=True)
     self.addTypeEqualityFunc(traits_listener.ListenerItem,
                              partial(assert_listener_item_equal, self))
예제 #43
0
import logging
import click

from envisage.core_plugin import CorePlugin
from envisage.ui.tasks.tasks_plugin import TasksPlugin
from stevedore import extension
from stevedore.exception import NoMatches
from traits.api import push_exception_handler

from force_bdss.core_plugins.factory_registry_plugin import (
    FactoryRegistryPlugin)
from force_wfmanager.version import __version__
from force_wfmanager.wfmanager import WfManager
from force_wfmanager.plugins.wfmanager_plugin import WfManagerPlugin

push_exception_handler(lambda *args: None, reraise_exceptions=True)


@click.command()
@click.version_option(version=__version__)
@click.option('--debug',
              is_flag=True,
              default=False,
              help="Prints extra debug information in force_wfmanager.log")
@click.option('--profile',
              is_flag=True,
              default=False,
              help="Run GUI under cProfile, creating .prof and .pstats "
              "files in the current directory.")
@click.option('--window-size',
              nargs=2,
예제 #44
0
except Exception:
    pass
else:
    scrapers += ('mayavi',)
try:
    with warnings.catch_warnings():
        warnings.filterwarnings("ignore", category=DeprecationWarning)
        import pyvista
    pyvista.OFF_SCREEN = False
except Exception:
    pass
else:
    scrapers += ('pyvista',)
if any(x in scrapers for x in ('pyvista', 'mayavi')):
    from traits.api import push_exception_handler
    push_exception_handler(reraise_exceptions=True)
    report_scraper = mne.report._ReportScraper()
    scrapers += (report_scraper,)
else:
    report_scraper = None
if 'pyvista' in scrapers:
    brain_scraper = mne.viz._brain._BrainScraper()
    scrapers = list(scrapers)
    scrapers.insert(scrapers.index('pyvista'), brain_scraper)
    scrapers = tuple(scrapers)


def append_attr_meth_examples(app, what, name, obj, options, lines):
    """Append SG examples backreferences to method and attr docstrings."""
    # NumpyDoc nicely embeds method and attribute docstrings for us, but it
    # does not respect the autodoc templates that would otherwise insert
예제 #45
0
 def setUp(self):
     super(TestUiLoader, self).setUp()
     push_exception_handler(reraise_exceptions=True)
예제 #46
0
def setup_package():
    push_exception_handler(handler=lambda *args, **kwds: None,
                           reraise_exceptions=True)
예제 #47
0
    def setUp(self):
        def ignore(*args):
            pass

        push_exception_handler(handler=ignore, reraise_exceptions=True)