def load_ipython_extension(ip): global _unregister_key_bindings _unregister_key_bindings = register_key_bindings(ip) from IPython.terminal.pt_inputhooks import register register("julia", julia_inputhook) if not ip.active_eventloop: ip.enable_gui("julia") maybe_load_pyjulia() ip.set_hook("complete_command", _julia_completer, re_key=r""".*\bMain\.eval\(["']""")
def embed(self, close_scene_on_exit: bool = True) -> None: if not self.preview: # Ignore embed calls when there is no preview return self.inside_embed = True self.stop_skipping() self.linger_after_completion = False self.update_frame() self.save_state() # Configure and launch embedded IPython terminal from IPython.terminal import embed, pt_inputhooks shell = embed.InteractiveShellEmbed.instance() # Use the locals namespace of the caller local_ns = inspect.currentframe().f_back.f_locals # Add a few custom shortcuts local_ns.update({ name: getattr(self, name) for name in [ "play", "wait", "add", "remove", "clear", "save_state", "undo", "redo", "i2g", "i2m" ] }) # Enables gui interactions during the embed def inputhook(context): while not context.input_is_ready(): if not self.window.is_closing: self.update_frame(dt=0) pt_inputhooks.register("manim", inputhook) shell.enable_gui("manim") # Operation to run after each ipython command def post_cell_func(*args, **kwargs): self.refresh_static_mobjects() self.save_state() shell.events.register("post_run_cell", post_cell_func) # Launch shell, with stack_depth=2 indicating we should use caller globals/locals shell(local_ns=local_ns, stack_depth=2) self.inside_embed = False # End scene when exiting an embed if close_scene_on_exit: raise EndSceneEarlyException()
def registerInputHook(): """ Registers the mechanica input hook with the ipython pt_inputhooks class. The ipython TerminalInteractiveShell.enable_gui('name') method looks in the registered input hooks in pt_inputhooks, and if it finds one, it activtes that hook. To acrtivate the gui mode, call: ip = IPython.get_ipython() ip. """ import IPython.terminal.pt_inputhooks as pt_inputhooks pt_inputhooks.register("mechanica", inputhook)
def _ipython_config(): # Integrate IPython >= 5 with ROOT's event loop # Check for new GUI events until there is some user input to process from IPython.terminal import pt_inputhooks def inputhook(context): while not context.input_is_ready(): gSystem.ProcessEvents() time.sleep(0.01) pt_inputhooks.register('ROOT', inputhook) ipy = get_ipython() if ipy: get_ipython().run_line_magic('gui', 'ROOT')
def _ipython_config(): # Integrate IPython >= 5 with ROOT's event loop # Check for new GUI events until there is some user input to process from IPython.terminal import pt_inputhooks def inputhook(context): while not context.input_is_ready(): gSystem.ProcessEvents() time.sleep(0.01) pt_inputhooks.register('ROOT', inputhook) ipy = get_ipython() if ipy: get_ipython().run_line_magic('gui', 'ROOT')
def sage_inputhook(context): f = context.fileno() while True: sage.repl.attach.reload_attached_files_if_modified() try: r, _, _ = select.select([f], [], [], TIMEOUT) if f in r: return # IPython signalled us to stop except select.error as e: if e[0] != errno.EINTR: raise register('sage', sage_inputhook) def install(): """ Install the Sage input hook EXAMPLES:: sage: from sage.repl.inputhook import install sage: install() """ ip = get_ipython() if not ip: return # Not running in ipython, e.g. doctests ip.enable_gui('sage')
def sage_inputhook(context): f = context.fileno() while True: sage.repl.attach.reload_attached_files_if_modified() try: r, w, e = select.select([f], [], [], TIMEOUT) if f in r: return # IPython signalled us to stop except select.error as e: if e[0] != errno.EINTR: raise register('sage', sage_inputhook) def install(): """ Install the Sage input hook EXAMPLES:: sage: from sage.repl.inputhook import install sage: install() """ ip = get_ipython() if not ip: return # Not running in ipython, e.g. doctests ip.enable_gui('sage')
def __finalSetup(self): # prevent this method from being re-entered through the gROOT wrapper self.__dict__['gROOT'] = _root.gROOT # switch to running gettattr/setattr self.__class__.__getattr__ = self.__class__.__getattr2 del self.__class__.__getattr2 self.__class__.__setattr__ = self.__class__.__setattr2 del self.__class__.__setattr2 # normally, you'll want a ROOT application; don't init any further if # one pre-exists from some C++ code somewhere hasargv = hasattr(sys, 'argv') if hasargv and PyConfig.IgnoreCommandLineOptions: argv = sys.argv sys.argv = [] appc = _root.CreateScopeProxy('PyROOT::TPyROOTApplication') if (not _builtin_cppyy and appc.CreatePyROOTApplication()) or _builtin_cppyy: appc.InitROOTGlobals() # TODO Cling equivalent needed: appc.InitCINTMessageCallback(); appc.InitROOTMessageCallback() if hasargv and PyConfig.IgnoreCommandLineOptions: sys.argv = argv # must be called after gApplication creation: if _is_ipython: # IPython's FakeModule hack otherwise prevents usage of python from Cling (TODO: verify necessity) _root.gROOT.ProcessLine('TPython::Exec( "" );') sys.modules['__main__'].__builtins__ = __builtins__ # special case for cout (backwards compatibility) if hasattr(cppyy.gbl.std, '__1'): attr_1 = getattr(cppyy.gbl.std, '__1') if hasattr(attr_1, 'cout'): self.__dict__['cout'] = attr_1.cout # python side pythonizations (should live in their own file, if we get many) def set_size(self, buf): buf.SetSize(self.GetN()) return buf # TODO: add pythonization API to pypy-c if not PYPY_CPPYY_COMPATIBILITY_FIXME: cppyy.add_pythonization( cppyy.compose_method("^TGraph(2D)?$|^TGraph.*Errors$", "GetE?[XYZ]$", set_size)) gRootDir = self.gRootDir else: gRootDir = _root.gRootDir # custom logon file (must be after creation of ROOT globals) if hasargv and not '-n' in sys.argv and not PyConfig.DisableRootLogon: rootlogon = os.path.expanduser('~/.rootlogon.py') if os.path.exists(rootlogon): # could also have used execfile, but import is likely to give fewer surprises import imp imp.load_module('rootlogon', open(rootlogon, 'r'), rootlogon, ('.py', 'r', 1)) del imp else: # if the .py version of rootlogon exists, the .C is ignored (the user can # load the .C from the .py, if so desired) # system logon, user logon, and local logon (skip Rint.Logon) name = '.rootlogon.C' logons = [ os.path.join(str(self.TROOT.GetEtcDir()), 'system' + name), os.path.expanduser(os.path.join('~', name)) ] if logons[-1] != os.path.join(os.getcwd(), name): logons.append(name) for rootlogon in logons: if os.path.exists(rootlogon): appc.ExecuteFile(rootlogon) del rootlogon, logons # use either the input hook or thread to send events to GUIs if self.PyConfig.StartGuiThread and \ not ( self.keeppolling or _root.gROOT.IsBatch() ): if _is_ipython and 'IPython' in sys.modules and sys.modules[ 'IPython'].version_info[0] >= 5: from IPython.terminal import pt_inputhooks def _inputhook(context): while not context.input_is_ready(): _root.gSystem.ProcessEvents() pt_inputhooks.register('ROOT', _inputhook) get_ipython().run_line_magic('gui', 'ROOT') elif self.PyConfig.StartGuiThread == 'inputhook' or\ _root.gSystem.InheritsFrom( 'TMacOSXSystem' ): # new, PyOS_InputHook based mechanism if PyConfig.GUIThreadScheduleOnce: for guicall in PyConfig.GUIThreadScheduleOnce: guicall() PyConfig.GUIThreadScheduleOnce = [] _root.InstallGUIEventInputHook() else: # original, threading based approach import threading self.__dict__['keeppolling'] = 1 self.__dict__[ 'PyGUIThread' ] = \ threading.Thread( None, _processRootEvents, None, ( self, ) ) def _finishSchedule(ROOT=self): import threading if threading.currentThread() != self.PyGUIThread: while self.PyConfig.GUIThreadScheduleOnce: self.PyGUIThread.join(0.1) self.PyGUIThread.finishSchedule = _finishSchedule self.PyGUIThread.setDaemon(1) self.PyGUIThread.start() # store already available ROOT objects to prevent spurious lookups for name in self.module.__pseudo__all__ + _memPolicyAPI + _sigPolicyAPI: self.__dict__[name] = getattr(_root, name) # the macro NULL is not available from Cling globals, but might be useful setattr(_root, 'NULL', 0) # TODO: is the following still necessary? Note: dupe of classes in cppyy.py for name in ('complex', 'pair', 'deque', 'list', 'queue', 'stack', 'vector', 'map', 'multimap', 'set', 'multiset'): setattr(_root, name, getattr(cppyy.gbl.std, name)) # set the display hook sys.displayhook = _displayhook # manually load libMathCore, for example to obtain gRandom # This can be removed once autoloading on selected variables is available _root.gSystem.Load("libMathCore")
def __finalSetup( self ): # prevent this method from being re-entered through the gROOT wrapper self.__dict__[ 'gROOT' ] = _root.gROOT # switch to running gettattr/setattr self.__class__.__getattr__ = self.__class__.__getattr2 del self.__class__.__getattr2 self.__class__.__setattr__ = self.__class__.__setattr2 del self.__class__.__setattr2 # normally, you'll want a ROOT application; don't init any further if # one pre-exists from some C++ code somewhere hasargv = hasattr( sys, 'argv' ) if hasargv and PyConfig.IgnoreCommandLineOptions: argv = sys.argv sys.argv = [] appc = _root.CreateScopeProxy( 'PyROOT::TPyROOTApplication' ) if (not _builtin_cppyy and appc.CreatePyROOTApplication()) or _builtin_cppyy: appc.InitROOTGlobals() # TODO Cling equivalent needed: appc.InitCINTMessageCallback(); appc.InitROOTMessageCallback(); if hasargv and PyConfig.IgnoreCommandLineOptions: sys.argv = argv # must be called after gApplication creation: if _is_ipython: # IPython's FakeModule hack otherwise prevents usage of python from Cling (TODO: verify necessity) _root.gROOT.ProcessLine( 'TPython::Exec( "" );' ) sys.modules[ '__main__' ].__builtins__ = __builtins__ # special case for cout (backwards compatibility) if hasattr( cppyy.gbl.std, '__1' ): attr_1 = getattr( cppyy.gbl.std, '__1' ) if hasattr( attr_1, 'cout' ): self.__dict__[ 'cout' ] = attr_1.cout # python side pythonizations (should live in their own file, if we get many) def set_size(self, buf): buf.SetSize(self.GetN()) return buf # TODO: add pythonization API to pypy-c if not PYPY_CPPYY_COMPATIBILITY_FIXME: cppyy.add_pythonization( cppyy.compose_method("^TGraph(2D)?$|^TGraph.*Errors$", "GetE?[XYZ]$", set_size)) gRootDir = self.gRootDir else: gRootDir = _root.gRootDir # custom logon file (must be after creation of ROOT globals) if hasargv and not '-n' in sys.argv and not PyConfig.DisableRootLogon: rootlogon = os.path.expanduser( '~/.rootlogon.py' ) if os.path.exists( rootlogon ): # could also have used execfile, but import is likely to give fewer surprises import imp imp.load_module( 'rootlogon', open( rootlogon, 'r' ), rootlogon, ('.py','r',1) ) del imp else: # if the .py version of rootlogon exists, the .C is ignored (the user can # load the .C from the .py, if so desired) # system logon, user logon, and local logon (skip Rint.Logon) name = '.rootlogon.C' logons = [ os.path.join( str(self.TROOT.GetEtcDir()), 'system' + name ), os.path.expanduser( os.path.join( '~', name ) ) ] if logons[-1] != os.path.join( os.getcwd(), name ): logons.append( name ) for rootlogon in logons: if os.path.exists( rootlogon ): appc.ExecuteFile( rootlogon ) del rootlogon, logons # use either the input hook or thread to send events to GUIs if self.PyConfig.StartGuiThread and \ not ( self.keeppolling or _root.gROOT.IsBatch() ): if _is_ipython and 'IPython' in sys.modules and sys.modules['IPython'].version_info[0] >= 5 : from IPython.terminal import pt_inputhooks import time def _inputhook(context): while not context.input_is_ready(): _root.gSystem.ProcessEvents() time.sleep( 0.01 ) pt_inputhooks.register('ROOT',_inputhook) if get_ipython() : get_ipython().run_line_magic('gui', 'ROOT') elif self.PyConfig.StartGuiThread == 'inputhook' or\ _root.gSystem.InheritsFrom( 'TMacOSXSystem' ): # new, PyOS_InputHook based mechanism if PyConfig.GUIThreadScheduleOnce: for guicall in PyConfig.GUIThreadScheduleOnce: guicall() PyConfig.GUIThreadScheduleOnce = [] _root.InstallGUIEventInputHook() else: # original, threading based approach import threading self.__dict__[ 'keeppolling' ] = 1 self.__dict__[ 'PyGUIThread' ] = \ threading.Thread( None, _processRootEvents, None, ( self, ) ) def _finishSchedule( ROOT = self ): import threading if threading.currentThread() != self.PyGUIThread: while self.PyConfig.GUIThreadScheduleOnce: self.PyGUIThread.join( 0.1 ) self.PyGUIThread.finishSchedule = _finishSchedule self.PyGUIThread.setDaemon( 1 ) self.PyGUIThread.start() # store already available ROOT objects to prevent spurious lookups for name in self.module.__pseudo__all__ + _memPolicyAPI + _sigPolicyAPI: self.__dict__[ name ] = getattr( _root, name ) # the macro NULL is not available from Cling globals, but might be useful setattr( _root, 'NULL', 0 ) # TODO: is the following still necessary? Note: dupe of classes in cppyy.py for name in ( 'complex', 'pair', 'deque', 'list', 'queue', 'stack', 'vector', 'map', 'multimap', 'set', 'multiset' ): setattr( _root, name, getattr( cppyy.gbl.std, name ) ) # set the display hook sys.displayhook = _displayhook # manually load libMathCore, for example to obtain gRandom # This can be removed once autoloading on selected variables is available _root.gSystem.Load( "libMathCore" )
logger.debug("automatically creating a Datoviz app") _APP = app() assert _APP is not None _EVENT_LOOP_INTEGRATION = True while not context.input_is_ready(): _APP.run_one_frame() def enable_ipython(): ipython = get_ipython() if ipython is not None: ipython.magic('%gui datoviz') # _IN_IPYTHON = in_ipython() register('datoviz', inputhook) # print(is_interactive()) # def enable_ipython(): # ipython = get_ipython() # if ipython is not None: # ipython.magic('%gui datoviz') # global _IN_IPYTHON # if _IN_IPYTHON: # return # try: # # Try to activate the GUI integration only if we are in IPython, and if # # IPython event loop has not yet been activated. # from IPython import get_ipython # ipython = get_ipython()
def embed(self, close_scene_on_exit: bool = True) -> None: if not self.preview: return # Embed is only relevant with a preview self.inside_embed = True self.stop_skipping() self.update_frame() self.save_state() # Configure and launch embedded IPython terminal from IPython.terminal import embed, pt_inputhooks shell = embed.InteractiveShellEmbed.instance() # Use the locals namespace of the caller local_ns = inspect.currentframe().f_back.f_locals # Add a few custom shortcuts local_ns.update({ name: getattr(self, name) for name in [ "play", "wait", "add", "remove", "clear", "save_state", "undo", "redo", "i2g", "i2m" ] }) # This is useful if one wants to re-run a block of scene # code, while developing, tweaking it each time. # As long as the copied selection starts with a comment, # this will revert to the state of the scene at the first # point of running. def checkpoint_paste(skip=False, show_progress=True): pasted = pyperclip.paste() line0 = pasted.lstrip().split("\n")[0] if line0.startswith("#"): if line0 not in self.checkpoint_states: self.checkpoint(line0) else: self.revert_to_checkpoint(line0) self.update_frame(dt=0) if skip: originally_skip = self.skip_animations self.skip_animations = True if show_progress: originally_show_animation_progress = self.show_animation_progress self.show_animation_progress = True shell.run_line_magic("paste", "") if skip: self.skip_animations = originally_skip if show_progress: self.show_animation_progress = originally_show_animation_progress local_ns['checkpoint_paste'] = checkpoint_paste # Enables gui interactions during the embed def inputhook(context): while not context.input_is_ready(): if not self.is_window_closing(): self.update_frame(dt=0) if self.is_window_closing(): shell.ask_exit() pt_inputhooks.register("manim", inputhook) shell.enable_gui("manim") # This is hacky, but there's an issue with ipython which is that # when you define lambda's or list comprehensions during a shell session, # they are not aware of local variables in the surrounding scope. Because # That comes up a fair bit during scene construction, to get around this, # we (admittedly sketchily) update the global namespace to match the local # namespace, since this is just a shell session anyway. shell.events.register( "pre_run_cell", lambda: shell.user_global_ns.update(shell.user_ns)) # Operation to run after each ipython command def post_cell_func(): self.refresh_static_mobjects() if not self.is_window_closing(): self.update_frame(dt=0, ignore_skipping=True) self.save_state() shell.events.register("post_run_cell", post_cell_func) shell(local_ns=local_ns, stack_depth=2) # End scene when exiting an embed if close_scene_on_exit: raise EndScene()