def define_commands(dictionary): print "Ipython detected - magicing commands" magiced_names = [] commands = hkl_commands_for_help + ub_commands_for_help # @UndefinedVariable commands += [pos, scan] # @UndefinedVariable ipython.GLOBAL_NAMESPACE_DICT = dictionary for f in commands: # Skip section headers like 'Motion' if not hasattr(f, '__call__'): continue # magic the function and remove from namespace (otherwise it would # shadow the magiced command) register_line_magic(parse_line(f)) del dictionary[f.__name__] command_map[f.__name__] = f magiced_names.append(f.__name__) print "Magiced commands: " + ' '.join(magiced_names) # because the functions have gone from namespace we need to override pythons_help = __builtins__.help del __builtins__.help register_line_magic(help) del help
def reload_kedro(path, line=None): """"Line magic which reloads all Kedro default variables.""" global startup_error global context global io try: import kedro.config.default_logger from kedro.context import load_context from kedro.cli.jupyter import collect_line_magic except ImportError: logging.error( "Kedro appears not to be installed in your current environment " "or your current IPython session was not started in a valid Kedro project." ) raise try: path = path or project_path logging.debug("Loading the context from %s", str(path)) context = load_context(path) io = context.catalog logging.info("** Kedro project %s", str(context.project_name)) logging.info("Defined global variable `context` and `catalog`") for line_magic in collect_line_magic(): register_line_magic(line_magic) logging.info("Registered line magic `%s`", line_magic.__name__) except Exception as err: startup_error = err logging.exception("Kedro's ipython session startup script failed:\n%s", str(err)) raise err
def magic_commands(global_namespace_dict): """Magic commands left in global_namespace_dict by previous import from diffcalc. Also creates a help command. NOTE that calling this will remove the original commands from the global namespace as otherwise these would shadow the ipython magiced versions. Depends on hkl_commands_for_help & ub_commands_for_help list having been left in the global namespace and assumes there is pos and scan command. """ gnd = global_namespace_dict global GLOBAL_NAMESPACE_DICT GLOBAL_NAMESPACE_DICT = gnd ### Magic commands in namespace ### commands = list(gnd['hkl_commands_for_help']) commands += gnd['ub_commands_for_help'] commands.append(gnd['pos']) commands.append(gnd['scan']) command_map = {} for f in commands: # Skip section headers like 'Motion' if not hasattr(f, '__call__'): continue # magic the function and remove from namespace (otherwise it would # shadow the magiced command) register_line_magic(parse_line(f, gnd)) del gnd[f.__name__] command_map[f.__name__] = f ### Create help function ### #Expects python's original help to be named pythons_help and to be #available in the top-level global namespace (where non-diffcalc #objects may have help called from). def help(s): # @ReservedAssignment """Diffcalc help for iPython """ if s == '': print _DEFAULT_HELP elif s == 'hkl': # Use help injected into hkl object print Hkl.dynamic_docstring elif s == 'ub': # Use help injected into ub command print command_map['ub'].__doc__ elif s in command_map: print "%s (diffcalc command):" % s print command_map[s].__doc__ else: exec('pythons_help(%s)' % s, gnd) ### Setup help command ### gnd['pythons_help'] = ORIGINAL_PYTHON_HELP register_line_magic(help) # Remove builtin help # (otherwise it would shadow magiced command if 'help' in __builtins__: del __builtins__['help']
def reload_kedro(path, line=None): """Line magic which reloads all Kedro default variables.""" global startup_error global context global catalog global session try: import kedro.config.default_logger from kedro.framework.hooks import get_hook_manager from kedro.framework.project import configure_project from kedro.framework.session import KedroSession from kedro.framework.session.session import _activate_session from kedro.framework.cli.jupyter import collect_line_magic except ImportError: logging.error( "Kedro appears not to be installed in your current environment " "or your current IPython session was not started in a valid Kedro project." ) raise try: path = path or project_path # clear hook manager hook_manager = get_hook_manager() name_plugin_pairs = hook_manager.list_name_plugin() for name, plugin in name_plugin_pairs: hook_manager.unregister(name=name, plugin=plugin) # remove cached user modules metadata = _get_project_metadata(path) to_remove = [ mod for mod in sys.modules if mod.startswith(metadata.package_name) ] # `del` is used instead of `reload()` because: If the new version of a module does not # define a name that was defined by the old version, the old definition remains. for module in to_remove: del sys.modules[module] configure_project(metadata.package_name) session = KedroSession.create(metadata.package_name, path) _activate_session(session, force=True) logging.debug("Loading the context from %s", str(path)) context = session.load_context() catalog = context.catalog logging.info("** Kedro project %s", str(metadata.project_name)) logging.info("Defined global variable `context` and `catalog`") for line_magic in collect_line_magic(): register_line_magic(needs_local_scope(line_magic)) logging.info("Registered line magic `%s`", line_magic.__name__) except Exception as err: startup_error = err logging.exception("Kedro's ipython session startup script failed:\n%s", str(err)) raise err
def _new_test_flag_fn(flag): "Create a new test flag function and magic" # don't create "empty" test flags if tst_flags is not set, set to whitespace, has trailing | etc if not flag.strip(): return def _(line): _validate_param(line, f'nbdev_{flag}_test', fixed_value='all') _.__doc__ = f"""Put an `%nbdev_{flag}_test` magic on each "{flag}" test cell that you do not want to be run by default. To apply this flag to all tests in a notebook, one cell should contain: `%nbdev_{flag}_test all` These tests can be executed with the command line tool: `nbdev_test_nbs --flags {flag}`'.""" register_line_magic(f'nbdev_{flag}_test')(_)
def reload_kedro(path, line=None): """Line magic which reloads all Kedro default variables.""" global startup_error global context global catalog try: import kedro.config.default_logger # noqa from kedro.framework.cli.jupyter import collect_line_magic from kedro.framework.context import load_context except ImportError: logging.error( "Kedro appears not to be installed in your current environment " "or your current IPython session was not started in a valid Kedro project." ) raise try: path = path or project_path # remove cached user modules context = load_context(path) to_remove = [ mod for mod in sys.modules if mod.startswith(context.package_name) ] # `del` is used instead of `reload()` because: If the new version of a module does not # define a name that was defined by the old version, the old definition remains. for module in to_remove: del sys.modules[module] # clear hook manager; hook implementations will be re-registered when the # context is instantiated again in `load_context()` below hook_manager = get_hook_manager() name_plugin_pairs = hook_manager.list_name_plugin() for name, plugin in name_plugin_pairs: hook_manager.unregister(name=name, plugin=plugin) logging.debug("Loading the context from %s", str(path)) # Reload context to fix `pickle` related error (it is unable to serialize reloaded objects) # Some details can be found here: # https://modwsgi.readthedocs.io/en/develop/user-guides/issues-with-pickle-module.html#packing-and-script-reloading context = load_context(path) catalog = context.catalog logging.info("** Kedro project %s", str(context.project_name)) logging.info("Defined global variable `context` and `catalog`") for line_magic in collect_line_magic(): register_line_magic(needs_local_scope(line_magic)) logging.info("Registered line magic `%s`", line_magic.__name__) except Exception as err: startup_error = err logging.exception("Kedro's ipython session startup script failed:\n%s", str(err)) raise err
def load_ipython_extension(ipython): """Load bg extension""" global ip, old_run_code, ext_state if ext_state == "never loaded": ip = ipython ip.input_transformers_post.append(bgtransform) for magic in bgmagics: register_line_magic(magic) old_run_code = ip.run_code ip.run_code = new_run_code ext_state = "enabled" new_thread()
def _declare_line_magic(name, module, magic_module_loader): """Declare a line magic called name in module.""" # If the module or extension has already been imported, don't overwrite the # existing definition. if module in sys.modules or module in get_ipython( ).extension_manager.loaded: return def impl(line, **kwargs): return _get_extension_magic(name, module, 'line', magic_module_loader)(line, **kwargs) # pylint: disable=g-long-lambda impl.getdoc = lambda: _get_extension_magic(name, module, 'line', magic_module_loader).__doc__ magic.register_line_magic(name)(impl)
def _make_line_magic(self): line_magic_names = [f[0] for f in inspect.getmembers(line_magics) if inspect.isfunction(f[1])] def _safety(line_: str): # this is to avoid capturing `self` and creating an extra reference to the singleton try: cmd, line = line_.split(' ', 1) except ValueError: cmd, line = line_, '' if cmd in ('deps', 'show_deps', 'show_dependency', 'show_dependencies'): return line_magics.show_deps(line) elif cmd in ('stale', 'show_stale'): return line_magics.show_stale(line) elif cmd == 'trace_messages': return line_magics.trace_messages(line) elif cmd in ('hls', 'nohls', 'highlight', 'highlights'): return line_magics.set_highlights(cmd, line) elif cmd in ('slice', 'make_slice', 'gather_slice'): return line_magics.make_slice(line) elif cmd == 'remove_dependency': return line_magics.remove_dep(line) elif cmd in ('add_dependency', 'add_dep'): return line_magics.add_dep(line) elif cmd == 'turn_off_warnings_for': return line_magics.turn_off_warnings_for(line) elif cmd == 'turn_on_warnings_for': return line_magics.turn_on_warnings_for(line) elif cmd in line_magic_names: print('We have a magic for %s, but have not yet registered it' % cmd) else: print(line_magics.USAGE) # FIXME (smacke): probably not a great idea to rely on this _safety.__name__ = _SAFETY_LINE_MAGIC return register_line_magic(_safety)
def _make_line_magic(self): line_magic_names = [ f[0] for f in inspect.getmembers(line_magics) if inspect.isfunction(f[1]) ] def _safety(line_: str): line = line_.split() if not line or line[0] not in line_magic_names: print(line_magics.USAGE) return elif line[0] in ("show_deps", "show_dependency", "show_dependencies"): return line_magics.show_deps(self, line) elif line[0] == "show_stale": return line_magics.show_stale(self, line) elif line[0] == "set_propagation": return line_magics.set_propagation(self, line) elif line[0] == "trace_messages": return line_magics.trace_messages(self, line) elif line[0] == "remove_dependency": return line_magics.remove_dep(self, line) elif line[0] in ("add_dependency", "add_dep"): return line_magics.add_dep(self, line) elif line[0] == "turn_off_warnings_for": return line_magics.turn_off_warnings_for(self, line) elif line[0] == "turn_on_warnings_for": return line_magics.turn_on_warnings_for(self, line) # FIXME (smacke): probably not a great idea to rely on this _safety.__name__ = _SAFETY_LINE_MAGIC return register_line_magic(_safety)
def reload_kedro(path, env: str = None, extra_params: Dict[str, Any] = None): """Line magic which reloads all Kedro default variables.""" import kedro.config.default_logger # noqa: F401 # pylint: disable=unused-import from kedro.framework.cli import load_entry_points from kedro.framework.project import pipelines from kedro.framework.session import KedroSession from kedro.framework.session.session import _activate_session from kedro.framework.startup import bootstrap_project _clear_hook_manager() path = path or project_path metadata = bootstrap_project(path) _remove_cached_modules(metadata.package_name) session = KedroSession.create(metadata.package_name, path, env=env, extra_params=extra_params) _activate_session(session, force=True) logging.debug("Loading the context from %s", str(path)) context = session.load_context() catalog = context.catalog get_ipython().push( variables={ "context": context, "catalog": catalog, "session": session, "pipelines": pipelines, }) logging.info("** Kedro project %s", str(metadata.project_name)) logging.info( "Defined global variable `context`, `session`, `catalog` and `pipelines`" ) for line_magic in load_entry_points("line_magic"): register_line_magic(needs_local_scope(line_magic)) logging.info("Registered line magic `%s`", line_magic.__name__) # type: ignore
def reload_kedro(path, line=None): """"Line magic which reloads all Kedro default variables.""" global startup_error global context global catalog try: import kedro.config.default_logger from kedro.context import KEDRO_ENV_VAR, load_context from kedro.cli.jupyter import collect_line_magic except ImportError: logging.error( "Kedro appears not to be installed in your current environment " "or your current IPython session was not started in a valid Kedro project." ) raise try: path = path or project_path logging.debug("Loading the context from %s", str(path)) context = load_context(path, env=os.getenv(KEDRO_ENV_VAR)) catalog = context.catalog # remove cached user modules package_name = context.__module__.split(".")[0] to_remove = [ mod for mod in sys.modules if mod.startswith(package_name) ] for module in to_remove: del sys.modules[module] logging.info("** Kedro project %s", str(context.project_name)) logging.info("Defined global variable `context` and `catalog`") for line_magic in collect_line_magic(): register_line_magic(line_magic) logging.info("Registered line magic `%s`", line_magic.__name__) except Exception as err: startup_error = err logging.exception("Kedro's ipython session startup script failed:\n%s", str(err)) raise err
def load_kedro_objects(path, line=None): # pylint: disable=unused-argument """Line magic which reloads all Kedro default variables.""" import kedro.config.default_logger # noqa: F401 # pylint: disable=unused-import from kedro.framework.cli import load_entry_points from kedro.framework.cli.utils import _add_src_to_path from kedro.framework.project import configure_project from kedro.framework.session import KedroSession from kedro.framework.session.session import _activate_session from kedro.framework.startup import _get_project_metadata global context global catalog global session path = path or project_path metadata = _get_project_metadata(path) _add_src_to_path(metadata.source_dir, path) configure_project(metadata.package_name) _clear_hook_manager() _remove_cached_modules(metadata.package_name) session = KedroSession.create(metadata.package_name, path) _activate_session(session) logging.debug("Loading the context from %s", str(path)) context = session.load_context() catalog = context.catalog get_ipython().push(variables={ "context": context, "catalog": catalog, "session": session }) logging.info("** Kedro project %s", str(metadata.project_name)) logging.info("Defined global variable `context`, `session` and `catalog`") for line_magic in load_entry_points("line_magic"): register_line_magic(needs_local_scope(line_magic)) logging.info("Registered line magic `%s`", line_magic.__name__)
# chi = ScannableAdapter(satilt, 'chi', 90) # chi = satilt + 90deg # phi = ScannableAdapter(saazimuth, 'phi') def usediode(): _fourc.delta_scn = diodetth setmin(delta, 0) setmax(delta, 180) def usevessel(): _fourc.delta_scn = m5tth setmin(delta, 0) setmax(delta, 150) if IPYTHON: from IPython import get_ipython # @UnresolvedImport @UnusedImport register_line_magic(parse_line(usediode, globals())) del usediode register_line_magic(parse_line(usevessel, globals())) del usevessel register_line_magic(parse_line(centresample, globals())) del centresample register_line_magic(parse_line(zerosample, globals())) del zerosample register_line_magic(parse_line(toolpoint_on, globals())) del toolpoint_on register_line_magic(parse_line(toolpoint_off, globals())) del toolpoint_off print "Created i21 bespoke commands: usediode & usevessel"
'if not root.handlers: ' 'handler = logging.StreamHandler(); ' 'handler.setFormatter(formatter); ' 'root.setLevel(logging.INFO); ' 'root.addHandler(handler)', ]) ) if ( register_line_magic is not None and get_ipython is not None and get_ipython() is not None ): import_all = register_line_magic(import_all) __all__ = [ 'analysis', 'cluster', 'correlation', 'data_sets', 'discoverer', 'levels', 'loading', 'motifs', 'phosphosite', 'paths', 'pathways', 'pride', 'species',
@contextmanager def redirect_stdout(out): orig_stdout = sys.stdout sys.stdout = out try: yield finally: sys.stdout = orig_stdout def trace(line): """Usage: %trace (enable|disable) [file pattern] [output path]""" args = line.split() enable = args[0] in {'enable', 'on'} if not enable: sys.settrace(None) sys.stdout = _ORIGINAL_STDOUT return pattern = args[1] if len(args) > 1 else None sys.stdout = open(args[2], 'a') if len(args) > 2 else sys.stdout sys.settrace(partial(trace_line, pattern)) try: register_line_magic(trace) except NameError: pass
def load_ipython_extension(ipython): from IPython.core.magic import register_line_magic register_line_magic(nose)
def load_ipython_extension(ipython): from IPython.core.magic import register_line_magic, register_cell_magic register_line_magic(profilegraph) register_cell_magic(profilegraph)
"if not root.handlers: " "handler = logging.StreamHandler(); " "handler.setFormatter(formatter); " "root.setLevel(logging.INFO); " "root.addHandler(handler)", ]) ) if ( register_line_magic is not None and get_ipython is not None and get_ipython() is not None ): import_all = register_line_magic(import_all) __all__ = [ "analysis", "bca", "cluster", "correlation", "data_sets", "discoverer", "levels", "loading", "motifs", "phosphosite", "paths", "pathways", "pride",
def define_magic(interpreter, function): def get_ipython(): return interpreter from IPython.core.magic import register_line_magic register_line_magic(function)
except Exception as ex: print(f'UsageError: {ex}') def _new_test_flag_fn(flag): "Create a new test flag function and magic" # don't create "empty" test flags if tst_flags is not set, set to whitespace, has trailing | etc if not flag.strip(): return def _(line): _validate_param(line, f'nbdev_{flag}_test', fixed_value='all') _.__doc__ = f"""Put an `%nbdev_{flag}_test` magic on each "{flag}" test cell that you do not want to be run by default. To apply this flag to all tests in a notebook, one cell should contain: `%nbdev_{flag}_test all` These tests can be executed with the command line tool: `nbdev_test_nbs --flags {flag}`'.""" register_line_magic(f'nbdev_{flag}_test')(_) if IN_IPYTHON: from IPython.core.magic import register_line_magic, needs_local_scope fns = [ nbdev_default_export, nbdev_export, nbdev_export_and_show, nbdev_export_internal, nbdev_hide, nbdev_hide_input, nbdev_hide_output, nbdev_default_class_level, nbdev_collapse_input, nbdev_collapse_output, needs_local_scope(nbdev_add2all) ] for fn in fns: register_line_magic(fn) for flag in Config().get('tst_flags', '').split('|'): _new_test_flag_fn(flag)
def load_ipython_extension(ipython): _install_namespace(ipython) ipython.register_magics(_PatchedMagics) # Add warning to timing magics. register_line_magic(autoimport)
def load_ipython_extension(shell): """Load the extension.""" register_line_magic(copy)
def register_line_magic(f): # noqa return magic.register_line_magic(magic.no_var_expand(f))
import shlex import pwny import pwnypack.main from IPython.core.magic import register_line_magic __all__ = [] def wrap_main(func_name): def wrapper(line): pwnypack.main.main([func_name] + shlex.split(line)) return wrapper for f_name, f_dict in pwnypack.main.MAIN_FUNCTIONS.items(): register_line_magic(f_name)(wrap_main(f_name)) def load_ipython_extension(ipython): ipython.push(vars(pwny)) def unload_ipython_extension(ipython): ipython.drop_by_id(vars(pwny))
from IPython.core.magic import register_line_magic from diffcmd.ipython import parse_line delta = ScannableAdapter(diode_tth, 'delta') # or vessel_tth eta = ScannableAdapter(sapol, 'eta') chi = ScannableAdapter(satilt, 'chi', 90) # chi = satilt + 90deg phi = ScannableAdapter(saaz, 'phi') def usediode(): delta.delegate_scn = diode_tth def usevessel(): delta.delegate_scn = vessel_tth if IPYTHON: from IPython import get_ipython register_line_magic(parse_line(usediode, globals())) del usediode register_line_magic(parse_line(usevessel, globals())) del usevessel print "Created i21 bespoke commands: usediode & usevessel" _fourc = ScannableGroup('_fourc', (delta, eta, chi, phi)) en = Dummy('en') en.level = 3 ### Configure and import diffcalc objects ### ESMTGKeV = 1 settings.hardware = ScannableHardwareAdapter(_fourc, en, ESMTGKeV) settings.geometry = diffcalc.hkl.you.geometry.FourCircle() # @UndefinedVariable
`%nbdev_show_doc name_1, name_2, title_level=3`. To show doc for a class and some of its members and specify class level: `%nbdev_show_doc MyClass . __init__, my_method, default_cls_level=3` To show doc for a class and all of its "public" members: `%nbdev_show_doc MyClass *`""" names, wild_names, kwargs = parse_nbdev_show_doc(line, local_ns) for k,v in kwargs.items(): if not 1 <= v <= 6: print(f'UsageError: Invalid {k} "{v}". Usage `%nbdev_show_doc name_1 {k}=[int between 1 and 6]`') if not names: print(f'UsageError: List of names is missing. Usage `%nbdev_show_doc name_1, name_2`') for name in names: show_doc(eval(name,local_ns), name=name, **kwargs) if IN_IPYTHON: from IPython.core.magic import register_line_magic, needs_local_scope register_line_magic(needs_local_scope(nbdev_show_doc)) # Cell def md2html(md): "Convert markdown `md` to HTML code" import nbconvert if nbconvert.__version__ < '5.5.0': return HTMLExporter().markdown2html(md) else: return HTMLExporter().markdown2html(collections.defaultdict(lambda: collections.defaultdict(dict)), md) # Cell def get_doc_link(func): mod = inspect.getmodule(func) module = mod.__name__.replace('.', '/') + '.py' try: nbdev_mod = importlib.import_module(mod.__package__.split('.')[0] + '._nbdev') try_pack = source_nb(func, mod=nbdev_mod)
def load_ipython_extension(ipython): magic.register_line_magic(nose)
def nbdev_add2all(line, local_ns): """To add something to `__all__` if it's not picked automatically, write an exported cell with something like: `%nbdev_add2all name_1, name_2 ...`""" if line.strip() == '': print(f'UsageError: List of names is missing. Usage `%nbdev_add2all name_1, name_2`') return try: [eval(s, local_ns) for s in parse_line(line)] except Exception as ex: print(f'UsageError: {ex}') def _new_test_flag_fn(flag): "Create a new test flag function and magic" # don't create "empty" test flags if tst_flags is not set, set to whitespace, has trailing | etc if not flag.strip(): return def _(line): _validate_param(line, f'nbdev_{flag}_test', fixed_value='all') _.__doc__ = f"""Put an `%nbdev_{flag}_test` magic on each "{flag}" test cell that you do not want to be run by default. To apply this flag to all tests in a notebook, one cell should contain: `%nbdev_{flag}_test all` These tests can be executed with the command line tool: `nbdev_test_nbs --flags {flag}`'.""" register_line_magic(f'nbdev_{flag}_test')(_) if IN_IPYTHON: from IPython.core.magic import register_line_magic, needs_local_scope fns = [nbdev_default_export, nbdev_export, nbdev_export_and_show, nbdev_export_internal, nbdev_hide, nbdev_hide_input, nbdev_hide_output, nbdev_default_class_level, nbdev_collapse_input, nbdev_collapse_output, needs_local_scope(nbdev_add2all)] for fn in fns: register_line_magic(fn) try: for flag in Config().get('tst_flags', '').split('|'): _new_test_flag_fn(flag) except: pass # do not fail if we can't find config
from IPython.utils.process import arg_split args = arg_split(line) path = os.path.abspath(args[0]) args = args[1:] if not os.path.isfile(path): from IPython.core.error import UsageError raise UsageError("%%pudb: file %s does not exist" % path) from pudb import runscript runscript(path, args) register_line_magic(pudb) def debugger(self, force=False): """ Call the PuDB debugger """ from IPython.utils.warn import error if not (force or self.call_pdb): return if not hasattr(sys, "last_traceback"): error("No traceback has been produced, nothing to debug.") return from pudb import pm
print(pudb.__doc__) return from IPython.utils.process import arg_split args = arg_split(line) path = os.path.abspath(args[0]) args = args[1:] if not os.path.isfile(path): from IPython.core.error import UsageError raise UsageError("%%pudb: file %s does not exist" % path) from pudb import runscript runscript(path, args) register_line_magic(pudb) def debugger(self, force=False): """ Call the PuDB debugger """ from IPython.utils.warn import error if not (force or self.call_pdb): return if not hasattr(sys, 'last_traceback'): error('No traceback has been produced, nothing to debug.') return from pudb import pm
if args and args[-1].endswith('.pdf'): pdf = args[-1] else: pdf = None verbose = '-v' in args if '-l' in args: pdf_from_latex(pdf, verbose) else: pdf_from_html(pdf, verbose) # this is hackery so that CI works. # it is an error to do this when there is not IPython try: pdf = register_line_magic(pdf) except: pass ################################################################## # File utilities ################################################################## def fid_from_url(url): '''Return a file ID for a file on GDrive from its url.''' u = urlparse(url) # This is a typical sharing link # https://drive.google.com/file/d/1q_qE9RGdfV_8Vv3zuApf-LqXBwqo8HO2/view?usp=sharing if (u.netloc == 'drive.google.com') and (u.path.startswith('/file/d/')): return u.path.split('/')[3]
def _make_line_magic(self): print_ = print # to keep the test from failing since this is a legitimate print line_magic_names = [ f[0] for f in inspect.getmembers(line_magics) if inspect.isfunction(f[1]) ] def _handle(cmd, line): if cmd in ("deps", "show_deps", "show_dependency", "show_dependencies"): return line_magics.show_deps(line) elif cmd in ("stale", "show_stale"): return line_magics.show_stale(line) elif cmd == "trace_messages": return line_magics.trace_messages(line) elif cmd in ("hls", "nohls", "highlight", "highlights"): return line_magics.set_highlights(cmd, line) elif cmd in ("dag", "make_dag", "cell_dag", "make_cell_dag"): return json.dumps(self.create_dag_metadata(), indent=2) elif cmd in ("slice", "make_slice", "gather_slice"): return line_magics.make_slice(line) elif cmd in ("mode", "exec_mode"): return line_magics.set_exec_mode(line) elif cmd in ("schedule", "exec_schedule", "execution_schedule"): return line_magics.set_exec_schedule(line) elif cmd in ("flow", "flow_order", "semantics", "flow_semantics"): return line_magics.set_flow_order(line) elif cmd == "clear": self.min_timestamp = self.cell_counter() return None elif cmd in line_magic_names: logger.warning( "We have a magic for %s, but have not yet registered it", cmd) return None else: logger.warning(line_magics.USAGE) return None def _safety(line: str): # this is to avoid capturing `self` and creating an extra reference to the singleton try: cmd, line = line.split(" ", 1) if cmd in ("slice", "make_slice", "gather_slice"): # FIXME: hack to workaround some input transformer line = re.sub(r"--tag +<class '(\w+)'>", r"--tag $\1", line) except ValueError: cmd, line = line, "" try: line, fname = line.split(">", 1) except ValueError: line, fname = line, None line = line.strip() if fname is not None: fname = fname.strip() outstr = _handle(cmd, line) if outstr is None: return if fname is None: print_(outstr) else: with open(fname, "w") as f: f.write(outstr) # FIXME (smacke): probably not a great idea to rely on this _safety.__name__ = _SAFETY_LINE_MAGIC return register_line_magic(_safety)
from gda.jython.commands.GeneralCommands import alias # @UnresolvedImport alias("usem5tth") alias("uselowq") alias("usehighq") alias("usedifftth") alias("usem5tth_tp") alias("uselowq_tp") alias("usehighq_tp") alias("usedifftth_tp") alias("usesim") else: from IPython.core.magic import register_line_magic # @UnresolvedImport from diffcmd.ipython import parse_line if IPYTHON: from IPython import get_ipython # @UnresolvedImport @UnusedImport register_line_magic(parse_line(usem5tth, globals())) del usem5tth register_line_magic(parse_line(uselowq, globals())) del uselowq register_line_magic(parse_line(usehighq, globals())) del usehighq register_line_magic(parse_line(usedifftth, globals())) del usedifftth register_line_magic(parse_line(usem5tth_tp, globals())) del usem5tth_tp register_line_magic(parse_line(uselowq_tp, globals())) del uselowq_tp register_line_magic(parse_line(usehighq_tp, globals())) del usehighq_tp register_line_magic(parse_line(usedifftth_tp, globals())) del usedifftth_tp