def setUpClass(cls): """ Create the application for the test case. """ cls._app = QtGui.QApplication.instance() if cls._app is None: cls._app = QtGui.QApplication([]) cls._app.setQuitOnLastWindowClosed(False)
def main(): print_process_id() app = QtGui.QApplication([]) widget = ConsoleWidget() monokai = qtconsole.styles.default_dark_style_sheet widget.style_sheet = monokai widget.execute_command("%run -m src.loadenv") widget.execute_command("%matplotlib inline\n") """ instructions = "{}{}{}{}".format( "Check 'ghargs': ", str(sys.argv[1]) if len(sys.argv)>1 else "Null", "%run -m src.openstudio_python $osmfile\n", "PID: "+str(os.getpid()) ) """ #widget.print_text(instructions) widget.show() app.exec_()
def main(): # The option parser usage = "usage: %prog [options]" parser = optparse.OptionParser(usage=usage) parser.add_option('-f', '--file', action='store', type='string', nargs=2, \ default=(None, None), help="Provide a parfile and a timfile") parser.add_option('-p', '--periodfile', action='store', type='string', nargs=1, \ default=(None, None), help="Provide a period file (per)") parser.add_option('-e', '--engine', action='store', type='string', nargs=1, \ default='pint', \ help="Pulsar timing engine: libstempo/pint") (options, args) = parser.parse_args() # Create the application app = QtGui.QApplication(sys.argv) # Create the window, and start the application qtipwin = QtipWindow(engine=options.engine, \ parfile=options.file[0], timfile=options.file[1],\ perfile=options.periodfile[0]) qtipwin.raise_() # Required on OSX to move the app to the foreground sys.exit(app.exec_())
def main(): """Invoke GUI application.""" signal.signal(signal.SIGINT, signal.SIG_DFL) app = QtGui.QApplication(sys.argv) ns = {} ns['exit'] = sys.exit window = MainWindow(ns) logging.basicConfig(level=logging.INFO) window.show() app.exec_()
def main(): # The option parser usage = "usage: %prog [options]" parser = optparse.OptionParser(usage=usage) parser.add_option('-p', '--parfile', action='store', type='string', nargs=1, \ default=None, help="provide a parfile") parser.add_option('-t', '--timfile', action='store', type='string', nargs=1, \ default=None, help="provide a timfile") (options, args) = parser.parse_args() # Create the application app = QtGui.QApplication(sys.argv) # Create the window, and start the application qtipwin = QtipWindow(parfile=options.parfile, timfile=options.timfile) qtipwin.raise_() # Required on OSX to move the app to the foreground sys.exit(app.exec_())
def _run_embedded_qtconsole(conn_filename): # This is launched as a new process. # # Wait max. ten seconds for the IPython kernel to be up and running, # which is done by checking for presence of the connection file # containing the kernels Zero Message Queue sockets and credentials. # # Then, start a new QApplication running the Jupyter Console client # widget connected to the kernel via the connection file. # for i in range(100): try: st = os.stat(conn_filename) except OSError as e: if e.errno != errno.ENOENT: # No such file exception is ignored, all others re-raised raise else: if st.st_size > 0: # OK, connection file found, kernel seems to be running break time.sleep(0.1) app = QtGui.QApplication(["Plot Workbench Console"]) kernel_client = QtKernelClient(connection_file=conn_filename) kernel_client.load_connection_file() kernel_client.start_channels() def exit(): kernel_client.shutdown() kernel_client.stop_channels() app.exit() ipython_widget = RichJupyterWidget() ipython_widget.kernel_client = kernel_client ipython_widget.exit_requested.connect(exit) ipython_widget.show() app.exec_()
def main(): usage, description = __doc__.split('\n\n', 1) parser = optparse.OptionParser(usage=usage, description=description) parser.add_option('--serial', '-s', default='/dev/ttyACM0') parser.add_option('--baudrate', '-b', type='int', default=115200) parser.add_option('--devices', '-d', type='str', default='1') parser.add_option('--target', '-t', default=None) parser.add_option('--rs485', '-c', action='store_true') parser.add_option('--max-receive-bytes', default=127, type=int) options, args = parser.parse_args() assert len(args) == 0 app = QtGui.QApplication(sys.argv) # To work around https://bugreports.qt.io/browse/PYSIDE-88 app.aboutToQuit.connect(lambda: os._exit(0)) tv = TviewMainWindow(options) tv.show() app.exec_()
""" self.kernel_manager.kernel.shell.push(variableDict) def clear(self): """ Clears the terminal """ self._control.clear() # self.kernel_manager def print_text(self, text): """ Prints some plain text to the console """ self._append_plain_text(text) def execute_command(self, command): """ Execute a command in the frame of the console widget """ self._execute(command, False) if __name__ == '__main__': app = QtGui.QApplication([]) widget = ConsoleWidget() widget.show() app.exec_()
def init_qt_app(self): # separate from qt_elements, because it must run first self.app = QtGui.QApplication(['jupyter-qtconsole']) self.app.setApplicationName('jupyter-qtconsole')
def init_qt_app(self): # separate from qt_elements, because it must run first self.app = QtGui.QApplication([])
def main(): app = QtGui.QApplication(sys.argv) tool = CityscapesViewer() sys.exit(app.exec_())
def procsteppython_do_run(stepglobals, runfunc, argkw, ipythonmodelist, action, scripthref, pycode_text, pycode_lineno): if not ipythonmodelist[0]: resultdict = runfunc(**argkw) return resultdict else: # ipython mode # in-process kernel, a-la https://raw.githubusercontent.com/ipython/ipython/master/examples/Embedding/inprocess_qtconsole.py ## Set PyQt4 API version to 2 and import it -- required for ipython compatibility #import sip #sip.setapi('QVariant', 2) #sip.setapi('QString', 2) #sip.setapi('QDateTime', 2) #sip.setapi('QDate', 2) #sip.setapi('QTextStream', 2) #sip.setapi('QTime', 2) #sip.setapi('QUrl', 2) #from PyQt4 import QtGui # force IPython to use PyQt4 by importing it first # RHEL6 compatibility -- if running under Python 2.6, just import IPython, get PyQt4 if sys.version_info < (2, 7): from IPython.qt.console.rich_ipython_widget import RichIPythonWidget from IPython.qt.inprocess import QtInProcessKernelManager pass else: # Under more recent OS's: Make matplotlib use PySide # http://stackoverflow.com/questions/6723527/getting-pyside-to-work-with-matplotlib import matplotlib matplotlib.use('Qt4Agg') matplotlib.rcParams['backend.qt4'] = 'PySide' pass import IPython from IPython.core.interactiveshell import DummyMod if LooseVersion(IPython.__version__) >= LooseVersion('4.0.0'): # Recent Jupyter/ipython: Import from qtconsole # Force PySide bindings import PySide.QtCore from qtconsole.qt import QtGui from qtconsole.inprocess import QtInProcessKernelManager # Obtain the running QApplication instance app = QtGui.QApplication.instance() if app is None: # Start our own if necessary app = QtGui.QApplication([]) pass pass else: from IPython.qt.inprocess import QtInProcessKernelManager from IPython.lib import guisupport app = guisupport.get_app_qt4() pass kernel_manager = QtInProcessKernelManager() kernel_manager.start_kernel() kernel = kernel_manager.kernel kernel.gui = 'qt4' #sys.stderr.write("id(stepglobals)=%d" % (id(stepglobals))) # Make ipython use our globals as its global dictionary # ... but first keep a backup stepglobalsbackup = copy.copy(stepglobals) (kernel.user_module, kernel.user_ns) = kernel.shell.prepare_user_module( user_ns=stepglobals) # Should we attempt to run the function here? # (gui, backend) = kernel.shell.enable_matplotlib("qt4") #,import_all=False) # (args.gui, import_all=import_all) (gui, backend, clobbered) = kernel.shell.enable_pylab( "qt4", import_all=False) # (args.gui, import_all=import_all) # kernel.shell.push(stepglobals) # provide globals as variables -- no longer necessary as it's using our namespace already kernel.shell.push(argkw) # provide arguments as variables kernel.shell.push( {"kernel": kernel}, interactive=False) # provide kernel for debugging purposes kernel_client = kernel_manager.client() kernel_client.start_channels() abort_requested_list = [False ] # encapsulated in a list to make it mutable def stop(): control.hide() kernel_client.stop_channels() kernel_manager.shutdown_kernel() app.exit() pass def abort(): # simple exit doesn't work. See http://stackoverflow.com/questions/1527689/exit-from-ipython # too bad this doesn't work right now!!! class Quitter(object): def __repr__(self): sys.exit() pass kernel.shell.push({"quitter": Quitter()}) kernel.shell.ex("quitter") stop() abort_requested_list.pop() abort_requested_list.append(True) pass if pycode_text is None: kernel.shell.write("\n\nExecute %s/%s\n" % (scripthref.getpath(), runfunc.__name__)) pass else: kernel.shell.write( "\n\nExecute %s/%s/%s\n" % (scripthref.getpath(), action, runfunc.__name__)) pass kernel.shell.write("Assign return value to \"ret\" and press Ctrl-D\n") kernel.shell.write("Set cont=True to disable interactive mode\n") # kernel.shell.write("call abort() to exit\n") if LooseVersion(IPython.__version__) >= LooseVersion('4.0.0'): # Recent Jupyter/ipython: Import from qtconsole from qtconsole.rich_jupyter_widget import RichJupyterWidget as RichIPythonWidget pass else: from IPython.qt.console.rich_ipython_widget import RichIPythonWidget pass control = RichIPythonWidget() control.kernel_manager = kernel_manager control.kernel_client = kernel_client control.exit_requested.connect(stop) control.show() #sys.stderr.write("lines=%s\n" % (str(lines))) #sys.stderr.write("lines[0]=%s\n" % (str(lines[0]))) try: if pycode_text is None: (lines, startinglineno) = inspect.getsourcelines(runfunc) assert (lines[0].startswith("def") ) # first line of function is the defining line del lines[0] # remove def line lines.insert(0, "if 1:\n") # allow function to be indented runfunc_syntaxtree = ast.parse( "".join(lines), filename=scripthref.getpath(), mode='exec' ) # BUG: Should set dont_inherit parameter and properly determine which __future__ import flags should be passed # fixup line numbers for syntreenode in ast.walk(runfunc_syntaxtree): if hasattr(syntreenode, "lineno"): syntreenode.lineno += startinglineno - 1 pass pass # runfunc_syntaxtree should consist of the if statement we just added # use _fields attribute to look up fields of an AST element # (e.g. test, body, orelse for IF) # then those fields can be accessed directly assert (len(runfunc_syntaxtree.body) == 1) code_container = runfunc_syntaxtree.body[0] assert (isinstance(code_container, ast.If) ) # code_container is the if statement we just wrote kernel.shell.push( {"runfunc_syntaxtree": runfunc_syntaxtree}, interactive=False ) # provide processed syntax tree for debugging purposes pass else: fullsyntaxtree = ast.parse( pycode_text ) # BUG: Should set dont_inherit parameter and properly determine which __future__ import flags should be passed # fixup line numbers for syntreenode in ast.walk(fullsyntaxtree): if hasattr(syntreenode, "lineno"): syntreenode.lineno += pycode_lineno - 1 pass pass code_container = None for codeelement in fullsyntaxtree.body: if isinstance(codeelement, ast.FunctionDef): if codeelement.name == runfunc.__name__: code_container = codeelement runfunc_syntaxtree = codeelement pass pass pass if code_container is None: raise ValueError( "Couldn't find code for %s for ipython execution" % (runfunc.__name__)) kernel.shell.push( {"fullsyntaxtree": fullsyntaxtree}, interactive=False ) # provide full syntax tree for debugging purposes pass # identify global variables from runfunc_syntaxtree globalvars = set() for treeelem in ast.walk(runfunc_syntaxtree): if isinstance(treeelem, ast.Global): globalvars = globalvars.union(treeelem.names) pass pass kernel.shell.push({"abort": abort}) # provide abort function kernel.shell.push({"cont": False}) # continue defaults to False returnstatement = code_container.body[-1] if isinstance(returnstatement, ast.Return): # last statement is a return statement! # Create assign statement that assigns # the result to ret retassign = ast.Assign(targets=[ ast.Name(id="ret", ctx=ast.Store(), lineno=returnstatement.lineno, col_offset=returnstatement.col_offset) ], value=returnstatement.value, lineno=returnstatement.lineno, col_offset=returnstatement.col_offset) del code_container.body[-1] # remove returnstatement code_container.body.append(retassign) # add assignment pass runfunc_lines = code_container.body kernel.shell.push( { "runfunc_lines": runfunc_lines, "scripthref": scripthref }, interactive=False ) # provide processed syntax tree for debugging purposes # kernel.shell.run_code(compile("kernel.shell.run_ast_nodes(runfunc_lines,scriptpath,interactivity='all')","None","exec")) if LooseVersion(IPython.__version__) >= LooseVersion('4.0.0'): # Recent Jupyter/ipython: Import from qtconsole from qtconsole.inprocess import QtCore pass else: from IPython.qt.inprocess import QtCore pass QTimer = QtCore.QTimer def showret(): control.execute("ret") pass def runcode(): control.execute( "kernel.shell.run_ast_nodes(runfunc_lines,scripthref.getpath(),interactivity='none')" ) # QTimer.singleShot(25,showret) # get callback 25ms into main loop # showret disabled because it prevents you from running the # debugger in post-mortem mode to troubleshoot an exception: # import pdb; pdb.pm() pass QTimer.singleShot(25, runcode) # get callback 25ms into main loop # control.execute("kernel.shell.run_ast_nodes(runfunc_lines,scripthref.getpath(),interactivity='none')") pass except: (exctype, excvalue) = sys.exc_info()[:2] sys.stderr.write( "%s while attempting to prepare URL %s code for interactive execution: %s\n" % (exctype.__name__, scripthref.absurl(), str(excvalue))) traceback.print_exc() raise if LooseVersion(IPython.__version__) >= LooseVersion('4.0.0'): # Recent Jupyter/ipython: Import from qtconsole app.exec_() pass else: # Old ipython guisupport.start_event_loop_qt4(app) pass if abort_requested_list[0]: pass if kernel.shell.ev("cont"): # cont==True -> disable interactive mode ipythonmodelist.pop() ipythonmodelist.append(False) pass try: retval = kernel.shell.ev( "ret") # Assign result dictionary to "ret" variable pass except NameError: # if ret not assigned, return {} retval = {} pass # Performing this execution changed values in stepglobals # but it should have only done that for variables specified # as 'global' in the function. # So: Update our backup of the value of stepglobals, # according to the specified globals, and # replace stepglobals with that updated backup stepglobalsbackup.update( dict([(varname, stepglobals[varname]) for varname in globalvars])) stepglobals.clear() stepglobals.update(stepglobalsbackup) return retval pass