def paste(self, parameter_s=''): """Paste & execute a pre-formatted code block from clipboard. The text is pulled directly from the clipboard without user intervention and printed back on the screen before execution (unless the -q flag is given to force quiet mode). The block is dedented prior to execution to enable execution of method definitions. '>' and '+' characters at the beginning of a line are ignored, to allow pasting directly from e-mails, diff files and doctests (the '...' continuation prompt is also stripped). The executed block is also assigned to variable named 'pasted_block' for later editing with '%edit pasted_block'. You can also pass a variable name as an argument, e.g. '%paste foo'. This assigns the pasted block to variable 'foo' as string, without executing it (preceding >>> and + is still stripped). Options: -r: re-executes the block previously entered by cpaste. -q: quiet mode: do not echo the pasted text back to the terminal. IPython statements (magics, shell escapes) are not supported (yet). See also -------- cpaste: manually paste code into terminal until you mark its end. """ opts, name = self.parse_options(parameter_s, 'rq', mode='string') if 'r' in opts: self.rerun_pasted() return try: block = self.shell.hooks.clipboard_get() except TryNext as clipboard_exc: message = getattr(clipboard_exc, 'args') if message: error(message[0]) else: error('Could not get text from the clipboard.') return except ClipboardEmpty: raise UsageError("The clipboard appears to be empty") # By default, echo back to terminal unless quiet mode is requested if 'q' not in opts: write = self.shell.write write(self.shell.pycolorize(block)) if not block.endswith('\n'): write('\n') write("## -- End pasted text --\n") self.store_or_execute(block, name)
def load_ext(self, module_str): """Load an IPython extension by its module name.""" if not module_str: raise UsageError('Missing module name.') res = self.shell.extension_manager.load_extension(module_str) if res == 'already loaded': print("The %s extension is already loaded. To reload it, use:" % module_str) print(" %reload_ext", module_str) elif res == 'no load function': print("The %s module is not an IPython extension." % module_str)
def run_examples(self, arg): """ Run doctest-format examples in an object's docstring. """ args = parse_argstring(self.run_examples, arg) obj = self.get_variable(args.object) if not hasattr(obj, '__doc__'): raise UsageError("%s does not have a docstring" % args.object) d = DoctestDemo(StringIO(obj.__doc__)) while not d.finished: d()
def lineage_json(self, line): opts, args = self.parse_options(line, '', 'path') use_path = 'path' in opts self.validate_inputs() if use_path: if args not in self._declared_outputs.keys(): raise UsageError( 'Could not find path {} in declared outputs'.format(args)) return self._lineage_template_provider( self._declared_outputs[args], self._declared_inputs) elif not args: raise UsageError('Missing dataset name.') else: ds = self.shell.user_ns[args] output_schema = { "schema": ds.schema.json(), "timestamp": self.current_milli_time() } return self._lineage_template_provider(output_schema, self._declared_inputs)
def list_container(self, line): args = magic_arguments.parse_argstring(self.list_container, line) if not args.i: raise UsageError('-i option is mandatory for listing') if not args.o: raise UsageError('-o option is mandatory for listing') if not args.o[0].startswith(tuple(string.ascii_letters)): raise UsageError('The output variable name must be a valid prefix ' 'of a python variable, that is, start with a ' 'letter') # Get the objects conn = get_swift_connection() _, objects = conn.get_container(args.i, full_listing=True) # Populate the returned list obj_names = [] for obj_dict in objects: obj_names.append(obj_dict['name']) self.shell.user_ns[args.o] = obj_names
def copy(self, line): args = magic_arguments.parse_argstring(self.copy, line) if not args.o: raise UsageError('-o option is mandatory for the invocation') if not args.o[0].startswith(tuple(string.ascii_letters)): raise UsageError('The output variable name must be a valid prefix ' 'of a python variable, that is, start with a ' 'letter') if not args.storlet: raise UsageError('--storlet option is mandatory ' 'for the invocation') if not args.input: raise UsageError('--input option is mandatory for the invocation') if not args.output: raise UsageError('--output option is mandatory for the invocation') src_container, src_obj = self._parse_input_path(args.input) dst_container, dst_obj = self._parse_input_path(args.output) destination = '/%s/%s' % (dst_container, dst_obj) headers = {'X-Run-Storlet': '%s' % args.storlet} # pick -i option and translate the params to # X-Storlet-Parameter-x headers storlet_headers = self._generate_params_headers( self.shell.user_ns[args.i] if args.i else {}) headers.update(storlet_headers) # invoke storlet app on copy conn = get_swift_connection() response_dict = dict() conn.copy_object( src_container, src_obj, destination=destination, headers=headers, response_dict=response_dict) res = Response(int(response_dict['status']), response_dict['headers']) self.shell.user_ns[args.o] = res
def _load(argv): """Load an external Tcl script, modifies argv.""" content = None if not argv: raise UsageError('%tcl FILENAME [ARGS...]') try: with open(argv[0], "r") as file: content = file.read() except EnvironmentError as e: sys.stderr.write(str(e)) del argv[0] return content
def ec(self, line, cell='', address=target_memory.shell_code): """Evaluate a 32-bit C++ expression on the target""" d = self.shell.user_ns['d'] try: return evalc(d, line + cell, defines=all_defines(), includes=all_includes(), address=address, verbose=True) except CodeError, e: raise UsageError(str(e))
def less(self, arg_s): """Show a file through the pager. Files ending in .py are syntax-highlighted.""" if not arg_s: raise UsageError('Missing filename.') if arg_s.endswith('.py'): cont = self.shell.pycolorize(openpy.read_py_file(arg_s, skip_encoding_cookie=False)) else: cont = open(arg_s).read() page.page(cont)
def get_variable(self, variable): """ Get a variable from the shell's namespace. """ ipshell = self.shell if variable not in ipshell.user_ns: try: obj = eval(variable, ipshell.user_global_ns, ipshell.user_ns) except Exception: raise UsageError('variable %r not in namespace' % variable) else: obj = ipshell.user_ns[variable] return obj
def inactive(self, parameter_s='', cell=None): """Does *not* exeutes a cell. Usage: %%inactive code... This magic can be used to mark a cell (temporary) as inactive. """ if cell is None: raise UsageError('empty cell, nothing to ignore :-)') print("Cell inactive: not executed!")
def profile(self, parameter_s=''): """Print your currently active IPython profile. See Also -------- prun : run code using the Python profiler (:meth:`~IPython.core.magics.execution.ExecutionMagics.prun`) """ raise UsageError( "The `%profile` magic has been deprecated since IPython 2.0. " "and removed in IPython 6.0. Please use the value of `get_ipython().profile` instead " "to see current profile in use. Perhaps you meant to use `%prun` to profile code?" )
def _enable_autopx(self): """Enable %autopx mode by saving the original run_cell and installing pxrun_cell. """ if self.active_view is None: raise UsageError(NO_ACTIVE_VIEW) # override run_cell self._original_run_cell = self.shell.run_cell self.shell.run_cell = self.pxrun_cell self._autopx = True print "%autopx enabled"
def load_ipython_extension(ipython): """Load our IPython magic.""" from IPython.core.error import UsageError import os if os.environ.get("__FIL_STATUS") != "api": raise UsageError( "In order to use Fil, you need to run your notebook with the Fil kernel.\n\n" "You can change the kernel via the 'Change Kernel' option at the bottom of " "the Kernel menu in Jupyter.") from ._ipython import FilMagics ipython.register_magics(FilMagics)
def _parse_input_path(self, path_str): """ Parse formatted to path to swift container and object names :param path_str: path string starts with "path:" prefix :return (container, obj): Both container and obj are formatted as string :raise UsageError: if the path_str is not formatted as expected """ if not path_str.startswith('path:'): raise UsageError( 'swift object path must have the format: ' '"path:/<container>/<object>"') try: src_container_obj = path_str[len('path:'):] src_container, src_obj = src_container_obj.strip( '/').split('/', 1) return src_container, src_obj except ValueError: raise UsageError( 'swift object path must have the format: ' '"path:/<container>/<object>"')
def pwd(self, parameter_s=''): """Return the current working directory path. Examples -------- :: In [9]: pwd Out[9]: '/home/tsuser/sprint/ipython' """ try: return os.getcwd() except FileNotFoundError: raise UsageError("CWD no longer exists - please use %cd to change directory.")
def wrapper(self, ns): data_doc_client = DatasetDocClient(AuthClient.get_access_token, os.environ['DOC_TEMPLATE_URL']) version = _current_milli_time() if not hasattr(self._df, 'lineage'): return write_method(self, ns) lineage = json.dumps(extract_lineage(self._df, ns, version), indent=2) schema = self._df.schema.json() validation = data_doc_client.get_lineage_validation(schema, lineage) status = validation['status'] if status == 'ok': return write_method(self, ns) message = validation['message'] raise UsageError("{}".format(message))
def test_parse_argstring_or_throw(): parse_argstring = MagicMock(side_effect=UsageError('OOGABOOGABOOGA')) try: parse_argstring_or_throw(MagicMock(), MagicMock(), parse_argstring=parse_argstring) assert False except BadUserDataException as e: assert_equals(str(e), str(parse_argstring.side_effect)) parse_argstring = MagicMock(side_effect=ValueError('AN UNKNOWN ERROR HAPPENED')) try: parse_argstring_or_throw(MagicMock(), MagicMock(), parse_argstring=parse_argstring) assert False except ValueError as e: assert_is(e, parse_argstring.side_effect)
def wdb_f(self, arg): """ Debug a script (like %run -d) in IPython process, Using WinPdb Usage: %wdb test.py run test.py, with a winpdb breakpoint at start of the file %wdb pass Change the password (e.g. if you have forgotten the old one) Note that after the script has been run, you need to do "Go" (f5) in WinPdb to resume normal IPython operation. """ global rpdb_started if not arg.strip(): print __doc__ return if arg.strip() == 'pass': passwd = raw_input('Enter new winpdb session password: '******'winpdb_pass'] = passwd print "Winpdb password changed" if rpdb_started: print "You need to restart IPython to use the new password" return path = os.path.abspath(arg) if not os.path.isfile(path): raise UsageError("%%wdb: file %s does not exist" % path) if not rpdb_started: passwd = ip.db.get('winpdb_pass', None) if passwd is None: import textwrap print textwrap.dedent("""\ Winpdb sessions need a password that you use for attaching the external winpdb session. IPython will remember this. You can change the password later by '%wpdb pass' """) passwd = raw_input('Enter new winpdb session password: '******'winpdb_pass'] = passwd print "Starting rpdb2 in IPython process" rpdb2.start_embedded_debugger(passwd, timeout=0) rpdb_started = True rpdb2.set_temp_breakpoint(path) print 'It is time to attach with WinPdb (launch WinPdb if needed, File -> Attach)' ip.magic('%run ' + arg)
def bowtie(self, line=''): """Build and serve a Bowtie app.""" opts, appvar = self.parse_options(line, 'w:h:b:p:') width = opts.get('w', 1500) height = opts.get('h', 1000) border = opts.get('b', 2) port = opts.get('p', 9991) host = '0.0.0.0' sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) result = sock.connect_ex((host, port)) if result == 0: raise Exception(f'Port {port} is unavailable on host {host}, aborting.') global_ns = self.shell.user_global_ns local_ns = self.shell.user_ns try: # pylint: disable=eval-used app = eval(appvar, global_ns, local_ns) except NameError: raise UsageError(f'Could not find App {appvar}') if not isinstance(app, App): raise UsageError(f'App is of type {type(app)} needs to be type <bowtie.App>') app._build(notebook=get_notebook_name()) # pylint: disable=protected-access self.process = Process(target=app._serve) # pylint: disable=protected-access self.process.start() time.sleep(5) clear_output() display( HTML( f'<iframe src=http://localhost:9991 width={width} height={height} ' f'frameBorder={border}></iframe>' ) )
def env(self, parameter_s=''): """List environment variables.""" if parameter_s.strip(): split = '=' if '=' in parameter_s else ' ' bits = parameter_s.split(split) if len(bits) == 1: key = parameter_s.strip() if key in os.environ: return os.environ[key] else: err = "Environment does not have key: {0}".format(key) raise UsageError(err) if len(bits) > 1: return self.set_env(parameter_s) return dict(os.environ)
def profile(self, parameter_s=''): """DEPRECATED since IPython 2.0. Raise `UsageError`. To profile code use the :magic:`prun` magic. See Also -------- prun : run code using the Python profiler (:magic:`prun`) """ raise UsageError( "The `%profile` magic has been deprecated since IPython 2.0. " "and removed in IPython 6.0. Please use the value of `get_ipython().profile` instead " "to see current profile in use. Perhaps you meant to use `%prun` to profile code?" )
def unload_ext(self, module_str): """Unload an IPython extension by its module name. Not all extensions can be unloaded, only those which define an ``unload_ipython_extension`` function. """ if not module_str: raise UsageError('Missing module name.') res = self.shell.extension_manager.unload_extension(module_str) if res == 'no unload function': print("The %s extension doesn't define how to unload it." % module_str) elif res == "not loaded": print("The %s extension is not loaded." % module_str)
def colors(self, parameter_s=""): """Switch color scheme for prompts, info system and exception handlers. Currently implemented schemes: NoColor, Linux, LightBG. Color scheme names are not case-sensitive. Examples -------- To get a plain black and white terminal:: %colors nocolor """ def color_switch_err(name): warn( "Error changing %s color schemes.\n%s" % (name, sys.exc_info()[1]), stacklevel=2, ) new_scheme = parameter_s.strip() if not new_scheme: raise UsageError("%colors: you must specify a color scheme. See '%colors?'") # local shortcut shell = self.shell # Set shell colour scheme try: shell.colors = new_scheme shell.refresh_style() except: color_switch_err("shell") # Set exception colors try: shell.InteractiveTB.set_colors(scheme=new_scheme) shell.SyntaxTB.set_colors(scheme=new_scheme) except: color_switch_err("exception") # Set info (for 'object?') colors if shell.color_info: try: shell.inspector.set_active_scheme(new_scheme) except: color_switch_err("object inspector") else: shell.inspector.set_active_scheme("NoColor")
def show_image(self, line): args = magic_arguments.parse_argstring(self.show_image, line) if not args.input: raise UsageError('--input option is mandatory') src_container, src_obj = self._parse_input_path(args.input) # invoke storlet app on get conn = get_swift_connection() response_dict = dict() resp_headers, resp_content_iter = conn.get_object( src_container, src_obj, response_dict=response_dict) img_str = '' for buf in resp_content_iter: img_str += buf show_image(img_str)
def py_from_R_repr(expr): ''' Convert expression returned from R to python ''' try: if 'read_dataframe' in expr: # imported to be used by eval from feather import read_dataframe # suppress flakes warning read_dataframe # the result is something like # [1] "{'a': 1}" return eval(eval(expr.split(' ', 1)[-1])) except Exception as e: raise UsageError('Failed to convert {} to Python object: {}'.format( expr, e))
def create_widget(self, binding, key): binding_key = binding[key] if isinstance(binding_key, str): return self.create_text_input(binding, key) elif isinstance(binding_key, bool): return self.create_checkbox_input(binding, key) elif isinstance(binding_key, dict) and binding_key.__contains__('enums'): return self.create_enum_selector(binding, key) elif isinstance(binding_key, dict) and binding_key.__contains__('candidates'): return self.create_candidate_selector(binding, key) else: raise UsageError( "Unable to create a widget for '{}' with value '{}'\n{}". format(key, binding_key, json.dumps(binding, indent=2)))
def switchdb(self, parameter_s=''): """Switches the active tango Database. Usage: switchdb <host>[(:| )<port>] <port> is optional. If not given it defaults to 10000. Examples: In [1]: switchdb homer:10005 In [2]: switchdb homer 10005 In [3]: switchdb homer""" if parameter_s == '': raise UsageError("%switchdb: Must specify a tango database name. " "See '%switchdb?'") return init_db(parameter_s)
def irm(ip, arg): """ irm path[s]... Remove file[s] or dir[s] path. Dirs are deleted recursively. """ try: paths = mglob.expand(arg.split(None, 1)[1]) except IndexError: raise UsageError("%irm paths...") import distutils.dir_util for p in paths: print "rm", p if os.path.isdir(p): distutils.dir_util.remove_tree(p, verbose=1) else: os.remove(p)
def wrapper(self, ns): data_doc_client = DatasetDocClient(AuthClient.get_access_token, os.environ['DOC_TEMPLATE_URL']) doc = extract_doc(self._df) if doc is None: return write_method(self, ns) template_doc = json.dumps(doc, indent=2) schema = self._df.schema.json() validation = data_doc_client.get_doc_validation(schema, template_doc) status = validation['status'] message = validation['message'] if status == 'ok': if message != '': print(message) return write_method(self, ns) raise UsageError("{}".format(message))