def __init__(self, name, usage=None, rc=Struct(opts=None, args=None), user_ns=None, user_global_ns=None, banner2='', **kw): """Similar to the normal InteractiveShell, but with threading control""" InteractiveShell.__init__(self, name, usage, rc, user_ns, user_global_ns, banner2) # A queue to hold the code to be executed. self.code_queue = Queue.Queue() # Stuff to do at closing time self._kill = None on_kill = kw.get('on_kill', []) # Check that all things to kill are callable: for t in on_kill: if not callable(t): raise TypeError, 'on_kill must be a list of callables' self.on_kill = on_kill # thread identity of the "worker thread" (that may execute code directly) self.worker_ident = None self.reactor_started = False self.first_run = True
def highlight(self, parameter_s=''): """ Display the contents of a source code file with syntax highlighting. Requires the pygments library. Usage: %highlight [options] <file name> Options: -g {'dark', 'light'}: Specify the 'dark' or 'light' color scheme. Defaults to 'dark'. -l <lexer name>: Manually specify the language of the code using any lexer name from http://pygments.org/docs/lexers/. By default the source language is guessed from the file name. """ opts_def = Struct(l='', g='dark') opts, arg_str = self.parse_options(parameter_s, 'l:g:') opts.merge(opts_def) if opts.l: lexer = get_lexer_by_name(opts.l) else: lexer = get_lexer_for_filename(arg_str) formatter = TerminalFormatter(bg=opts.g) with open(arg_str) as f: code = f.read() print(highlight(code, lexer, formatter))
def magic_doctest_mode(self, parameter_s=''): """Toggle doctest mode on and off. This mode is intended to make IPython behave as much as possible like a plain Python shell, from the perspective of how its prompts, exceptions and output look. This makes it easy to copy and paste parts of a session into doctests. It does so by: - Changing the prompts to the classic ``>>>`` ones. - Changing the exception reporting mode to 'Plain'. - Disabling pretty-printing of output. Note that IPython also supports the pasting of code snippets that have leading '>>>' and '...' prompts in them. This means that you can paste doctests from files or docstrings (even if they have leading whitespace), and the code will execute correctly. You can then use '%history -t' to see the translated history; this will give you the input after removal of all the leading prompts and whitespace, which can be pasted back into an editor. With these features, you can switch into this mode easily whenever you need to do testing and changes to doctests, without having to leave your existing IPython session. """ from IPython.utils.ipstruct import Struct # Shorthands shell = self.shell # dstore is a data store kept in the instance metadata bag to track any # changes we make, so we can undo them later. dstore = shell.meta.setdefault('doctest_mode', Struct()) save_dstore = dstore.setdefault # save a few values we'll need to recover later mode = save_dstore('mode', False) save_dstore('rc_pprint', shell.pprint) save_dstore('xmode', shell.InteractiveTB.mode) if mode == False: # turn on shell.pprint = False shell.magic_xmode('Plain') else: # turn off shell.pprint = dstore.rc_pprint shell.magic_xmode(dstore.xmode) # Store new mode and inform on console dstore.mode = bool(1 - int(mode)) mode_label = ['OFF', 'ON'][dstore.mode] print('Doctest mode is:', mode_label) # Send the payload back so that clients can modify their prompt display payload = dict( source= 'IPython.zmq.zmqshell.ZMQInteractiveShell.magic_doctest_mode', mode=dstore.mode) self.payload_manager.write_payload(payload)
class ColorScheme: """Generic color scheme class. Just a name and a Struct.""" def __init__(self,__scheme_name_,colordict=None,**colormap): self.name = __scheme_name_ if colordict is None: self.colors = Struct(**colormap) else: self.colors = Struct(colordict) def copy(self,name=None): """Return a full copy of the object, optionally renaming it.""" if name is None: name = self.name return ColorScheme(name, self.colors.dict())
class ColorScheme: """Generic color scheme class. Just a name and a Struct.""" def __init__(self, __scheme_name_, colordict=None, **colormap): self.name = __scheme_name_ if colordict is None: self.colors = Struct(**colormap) else: self.colors = Struct(colordict) def copy(self, name=None): """Return a full copy of the object, optionally renaming it.""" if name is None: name = self.name return ColorScheme(name, self.colors.dict())
def _save_file(code, opts, namespace): # read arguments opts.merge(Struct(f=None)) file_name = opts.f if not file_name: return "Usage: %%save_file -f file_name" file_name = file_name[0] with open(file_name, 'w') as fileName: fileName.write(code) print("Saved cell to {}".format(file_name)) return
def dispatch_custom_completer(self, text): #print "Custom! '%s' %s" % (text, self.custom_completers) # dbg line = self.full_lbuf if not line.strip(): return None event = Struct() event.line = line event.symbol = text cmd = line.split(None, 1)[0] event.command = cmd #print "\ncustom:{%s]\n" % event # dbg # for foo etc, try also to find completer for %foo if not cmd.startswith(self.magic_escape): try_magic = self.custom_completers.s_matches(self.magic_escape + cmd) else: try_magic = [] for c in itertools.chain( self.custom_completers.s_matches(cmd), try_magic, self.custom_completers.flat_matches(self.lbuf)): #print "try",c # dbg try: res = c(event) # first, try case sensitive match withcase = [r for r in res if r.startswith(text)] if withcase: return withcase # if none, then case insensitive ones are ok too return [r for r in res if r.lower().startswith(text.lower())] except TryNext: pass return None
def highlight_html(self, parameter_s=''): """ Display the contents of a source code file with syntax highlighting. You must be in an environment that can display HTML output. Requires the pygments library. Usage: %highlight [options] <file name> Options: -n: Show line numbers. -s <style name>: An available Pygments style, default is 'default'. -l <lexer name>: Manually specify the language of the code using any lexer name from http://pygments.org/docs/lexers/. By default the source language is guessed from the file name. """ opts_def = Struct(l='', s='default') opts, arg_str = self.parse_options(parameter_s, 'l:s:n') opts.merge(opts_def) if opts.l: lexer = get_lexer_by_name(opts.l) else: lexer = get_lexer_for_filename(arg_str) if 'n' in opts: linenos = 'table' else: linenos = False formatter = HtmlFormatter(style=opts.s, cssclass='pygments' + str(uuid.uuid4()), linenos=linenos) with open(arg_str) as f: code = f.read() html_code = highlight(code, lexer, formatter) css = formatter.get_style_defs() html = HTML_TEMPLATE.format(css, html_code) display(HTML(html))
def run_notebook(self, nb, vars={}): if len(nb['worksheets']) == 0: nb['worksheets'] = [NotebookNode({'cells': [], 'metadata': {}})] start = nb['worksheets'][0]['cells'] start.insert( 0, Struct( **{ 'cell_type': 'code', 'language': 'python', 'outputs': [], 'collapsed': False, 'prompt_number': -1, 'input': 'qtipy=%s' % vars, 'metadata': {}, })) self.runner.nb = nb try: self.runner.run_notebook() except: self.latest_run['success'] = False raise else: self.latest_run['success'] = True finally: ext = dict( html='html', slides='slides', latex='latex', markdown='md', python='py', rst='rst', ) output, resources = IPyexport( IPyexporter_map[self.config.get('output_format')], self.runner.nb) output_path = vars['output_path'] + 'notebook.%s' % ext[ self.config.get('output_format')] logging.info("Exporting updated notebook to %s" % output_path) with open(output_path, "w") as f: f.write(output)
def init_db(parameter_s=''): ip = get_ipapi() user_ns = get_user_ns() global _DB_SYMB old_db = user_ns.get(_DB_SYMB) db = __get_db(parameter_s) if old_db is not None and hasattr(old_db, "_db_cache"): old_junk = old_db._db_cache["junk"].keys() for e in old_junk: del user_ns[e] else: old_junk = () if db is None: return os.environ["TANGO_HOST"] = "%s:%s" % (db.get_db_host(), db.get_db_port()) # Initialize device and server information query = "SELECT name, alias, server, class FROM device order by name" r = db.command_inout("DbMySqlSelect", query) row_nb, column_nb = r[0][-2], r[0][-1] data = r[1] assert row_nb == len(data) / column_nb devices, aliases, servers, klasses = data[0::4], data[1::4], data[ 2::4], data[3::4] # CD = tango.utils.CaselessDict CD = dict dev_dict, serv_dict, klass_dict, alias_dict = CD(), CD(), CD(), CD() for device, alias, server, klass in zip(devices, aliases, servers, klasses): dev_lower = device.lower() # hide dserver devices if dev_lower.startswith("dserver/"): continue # hide alias that start with "_" if alias and alias[0] == "_": alias = '' # last None below is to be filled by DeviceProxy object on demand # last empty dict<str, int> where keys is attribute name and value is # the subscription id dev_dict[device] = [alias, server, klass, None, {}] serv_devs = serv_dict.get(server) if serv_devs is None: serv_dict[server] = serv_devs = [] serv_devs.append(device) klass_devs = klass_dict.get(klass) if klass_devs is None: klass_dict[klass] = klass_devs = [] klass_devs.append(device) if len(alias): alias_dict[alias] = device serv_devs.append(alias) klass_devs.append(alias) exposed_klasses = {} excluded_klasses = "DServer", for klass, devices in klass_dict.items(): if klass in excluded_klasses: continue exists = klass in user_ns if not exists or klass in old_junk: c = DeviceClassCompleter(klass, devices) ip.set_hook('complete_command', c, re_key=".*" + klass + "[^\w\.]+") exposed_klasses[klass] = tango.DeviceProxy # expose classes no user namespace user_ns.update(exposed_klasses) # Initialize attribute information query = "SELECT name, alias FROM attribute_alias order by alias" r = db.command_inout("DbMySqlSelect", query) row_nb, column_nb = r[0][-2], r[0][-1] data = r[1] assert row_nb == len(data) / column_nb attributes, aliases = data[0::2], data[1::2] attr_alias_dict = {} for attribute, alias in zip(attributes, aliases): if len(alias): attr_alias_dict[alias] = attribute device_list = tango.utils.CaselessList(dev_dict.keys()) alias_list = tango.utils.CaselessList(alias_dict.keys()) attr_alias_list = tango.utils.CaselessList(attr_alias_dict.keys()) # Build cache db_cache = Struct(devices=dev_dict, aliases=alias_dict, servers=serv_dict, klasses=klass_dict, junk=exposed_klasses, attr_aliases=attr_alias_dict, device_list=device_list, alias_list=alias_list, attr_alias_list=attr_alias_list) db._db_cache = db_cache # Add this DB to the list of known DBs (for possible use in magic commands) if db.get_db_port_num() == 10000: db_name = db.get_db_host() else: db_name = "%s:%s" % (db.get_db_host(), db.get_db_port()) return db
def doctest_mode(self, parameter_s=''): """Toggle doctest mode on and off. This mode is intended to make IPython behave as much as possible like a plain Python shell, from the perspective of how its prompts, exceptions and output look. This makes it easy to copy and paste parts of a session into doctests. It does so by: - Changing the prompts to the classic ``>>>`` ones. - Changing the exception reporting mode to 'Plain'. - Disabling pretty-printing of output. Note that IPython also supports the pasting of code snippets that have leading '>>>' and '...' prompts in them. This means that you can paste doctests from files or docstrings (even if they have leading whitespace), and the code will execute correctly. You can then use '%history -t' to see the translated history; this will give you the input after removal of all the leading prompts and whitespace, which can be pasted back into an editor. With these features, you can switch into this mode easily whenever you need to do testing and changes to doctests, without having to leave your existing IPython session. """ # Shorthands shell = self.shell pm = shell.prompt_manager meta = shell.meta disp_formatter = self.shell.display_formatter ptformatter = disp_formatter.formatters['text/plain'] # dstore is a data store kept in the instance metadata bag to track any # changes we make, so we can undo them later. dstore = meta.setdefault('doctest_mode',Struct()) save_dstore = dstore.setdefault # save a few values we'll need to recover later mode = save_dstore('mode',False) save_dstore('rc_pprint',ptformatter.pprint) save_dstore('xmode',shell.InteractiveTB.mode) save_dstore('rc_separate_out',shell.separate_out) save_dstore('rc_separate_out2',shell.separate_out2) save_dstore('rc_prompts_pad_left',pm.justify) save_dstore('rc_separate_in',shell.separate_in) save_dstore('rc_active_types',disp_formatter.active_types) save_dstore('prompt_templates',(pm.in_template, pm.in2_template, pm.out_template)) if mode == False: # turn on pm.in_template = '>>> ' pm.in2_template = '... ' pm.out_template = '' # Prompt separators like plain python shell.separate_in = '' shell.separate_out = '' shell.separate_out2 = '' pm.justify = False ptformatter.pprint = False disp_formatter.active_types = ['text/plain'] shell.magic('xmode Plain') else: # turn off pm.in_template, pm.in2_template, pm.out_template = dstore.prompt_templates shell.separate_in = dstore.rc_separate_in shell.separate_out = dstore.rc_separate_out shell.separate_out2 = dstore.rc_separate_out2 pm.justify = dstore.rc_prompts_pad_left ptformatter.pprint = dstore.rc_pprint disp_formatter.active_types = dstore.rc_active_types shell.magic('xmode ' + dstore.xmode) # Store new mode and inform dstore.mode = bool(1-int(mode)) mode_label = ['OFF','ON'][dstore.mode] print('Doctest mode is:', mode_label)
def lprun(self, parameter_s=''): """ Execute a statement under the line-by-line profiler from the line_profiler module. Usage: %lprun -f func1 -f func2 <statement> The given statement (which doesn't require quote marks) is run via the LineProfiler. Profiling is enabled for the functions specified by the -f options. The statistics will be shown side-by-side with the code through the pager once the statement has completed. Options: -f <function>: LineProfiler only profiles functions and methods it is told to profile. This option tells the profiler about these functions. Multiple -f options may be used. The argument may be any expression that gives a Python function or method object. However, one must be careful to avoid spaces that may confuse the option parser. -m <module>: Get all the functions/methods in a module One or more -f or -m options are required to get any useful results. -D <filename>: dump the raw statistics out to a pickle file on disk. The usual extension for this is ".lprof". These statistics may be viewed later by running line_profiler.py as a script. -T <filename>: dump the text-formatted statistics with the code side-by-side out to a text file. -r: return the LineProfiler object after it has completed profiling. -s: strip out all entries from the print-out that have zeros. -u: specify time unit for the print-out in seconds. """ # Escape quote markers. opts_def = Struct(D=[''], T=[''], f=[], m=[], u=None) parameter_s = parameter_s.replace('"', r'\"').replace("'", r"\'") opts, arg_str = self.parse_options(parameter_s, 'rsf:m:D:T:u:', list_all=True) opts.merge(opts_def) global_ns = self.shell.user_global_ns local_ns = self.shell.user_ns # Get the requested functions. funcs = [] for name in opts.f: try: funcs.append(eval(name, global_ns, local_ns)) except Exception as e: raise UsageError('Could not find function %r.\n%s: %s' % (name, e.__class__.__name__, e)) profile = LineProfiler(*funcs) # Get the modules, too for modname in opts.m: try: mod = __import__(modname, fromlist=['']) profile.add_module(mod) except Exception as e: raise UsageError('Could not find module %r.\n%s: %s' % (modname, e.__class__.__name__, e)) if opts.u is not None: try: output_unit = float(opts.u[0]) except Exception as e: raise TypeError("Timer unit setting must be a float.") else: output_unit = None # Add the profiler to the builtins for @profile. if PY3: import builtins else: import __builtin__ as builtins if 'profile' in builtins.__dict__: had_profile = True old_profile = builtins.__dict__['profile'] else: had_profile = False old_profile = None builtins.__dict__['profile'] = profile try: try: profile.runctx(arg_str, global_ns, local_ns) message = '' except SystemExit: message = """*** SystemExit exception caught in code being profiled.""" except KeyboardInterrupt: message = ( "*** KeyboardInterrupt exception caught in code being " "profiled.") finally: if had_profile: builtins.__dict__['profile'] = old_profile # Trap text output. stdout_trap = StringIO() profile.print_stats(stdout_trap, output_unit=output_unit, stripzeros='s' in opts) output = stdout_trap.getvalue() output = output.rstrip() page(output) print(message, end="") dump_file = opts.D[0] if dump_file: profile.dump_stats(dump_file) print('\n*** Profile stats pickled to file %r. %s' % (dump_file, message)) text_file = opts.T[0] if text_file: pfile = open(text_file, 'w') pfile.write(output) pfile.close() print('\n*** Profile printout saved to text file %r. %s' % (text_file, message)) return_value = None if 'r' in opts: return_value = profile return return_value
def _run_with_profiler(self, code, opts, namespace): """ Run `code` with profiler. Used by ``%prun`` and ``%run -p``. Parameters ---------- code : str Code to be executed. opts : Struct Options parsed by `self.parse_options`. namespace : dict A dictionary for Python namespace (e.g., `self.shell.user_ns`). """ # Fill default values for unspecified options: opts.merge(Struct(D=[''], l=[], s=['time'], T=[''])) prof = profile.Profile() try: prof = prof.runctx(code, namespace, namespace) sys_exit = '' except SystemExit: sys_exit = """*** SystemExit exception caught in code being profiled.""" stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s) lims = opts.l if lims: lims = [] # rebuild lims with ints/floats/strings for lim in opts.l: try: lims.append(int(lim)) except ValueError: try: lims.append(float(lim)) except ValueError: lims.append(lim) # Trap output. stdout_trap = StringIO() stats_stream = stats.stream try: stats.stream = stdout_trap stats.print_stats(*lims) finally: stats.stream = stats_stream output = stdout_trap.getvalue() output = output.rstrip() if 'q' not in opts: page.page(output) print sys_exit, dump_file = opts.D[0] text_file = opts.T[0] if dump_file: dump_file = unquote_filename(dump_file) prof.dump_stats(dump_file) print '\n*** Profile stats marshalled to file',\ repr(dump_file)+'.',sys_exit if text_file: text_file = unquote_filename(text_file) pfile = open(text_file, 'w') pfile.write(output) pfile.close() print '\n*** Profile printout saved to text file',\ repr(text_file)+'.',sys_exit if 'r' in opts: return stats else: return None
def __init__(self,__scheme_name_,colordict=None,**colormap): self.name = __scheme_name_ if colordict is None: self.colors = Struct(**colormap) else: self.colors = Struct(colordict)
class Magics(object): """Base class for implementing magic functions. Shell functions which can be reached as %function_name. All magic functions should accept a string, which they can parse for their own needs. This can make some functions easier to type, eg `%cd ../` vs. `%cd("../")` Classes providing magic functions need to subclass this class, and they MUST: - Use the method decorators `@line_magic` and `@cell_magic` to decorate individual methods as magic functions, AND - Use the class decorator `@magics_class` to ensure that the magic methods are properly registered at the instance level upon instance initialization. See :mod:`magic_functions` for examples of actual implementation classes. """ # Dict holding all command-line options for each magic. options_table = None # Dict for the mapping of magic names to methods, set by class decorator magics = None # Flag to check that the class decorator was properly applied registered = False # Instance of IPython shell shell = None def __init__(self, shell): if not (self.__class__.registered): raise ValueError('Magics subclass without registration - ' 'did you forget to apply @magics_class?') self.shell = shell self.options_table = {} # The method decorators are run when the instance doesn't exist yet, so # they can only record the names of the methods they are supposed to # grab. Only now, that the instance exists, can we create the proper # mapping to bound methods. So we read the info off the original names # table and replace each method name by the actual bound method. # But we mustn't clobber the *class* mapping, in case of multiple instances. class_magics = self.magics self.magics = {} for mtype in magic_kinds: tab = self.magics[mtype] = {} cls_tab = class_magics[mtype] for magic_name, meth_name in cls_tab.iteritems(): if isinstance(meth_name, basestring): # it's a method name, grab it tab[magic_name] = getattr(self, meth_name) else: # it's the real thing tab[magic_name] = meth_name def arg_err(self, func): """Print docstring if incorrect arguments were passed""" print 'Error in arguments:' print oinspect.getdoc(func) def format_latex(self, strng): """Format a string for latex inclusion.""" # Characters that need to be escaped for latex: escape_re = re.compile(r'(%|_|\$|#|&)', re.MULTILINE) # Magic command names as headers: cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC, re.MULTILINE) # Magic commands cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC, re.MULTILINE) # Paragraph continue par_re = re.compile(r'\\$', re.MULTILINE) # The "\n" symbol newline_re = re.compile(r'\\n') # Now build the string for output: #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng) strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:', strng) strng = cmd_re.sub(r'\\texttt{\g<cmd>}', strng) strng = par_re.sub(r'\\\\', strng) strng = escape_re.sub(r'\\\1', strng) strng = newline_re.sub(r'\\textbackslash{}n', strng) return strng def parse_options(self, arg_str, opt_str, *long_opts, **kw): """Parse options passed to an argument string. The interface is similar to that of getopt(), but it returns back a Struct with the options as keys and the stripped argument string still as a string. arg_str is quoted as a true sys.argv vector by using shlex.split. This allows us to easily expand variables, glob files, quote arguments, etc. Options: -mode: default 'string'. If given as 'list', the argument string is returned as a list (split on whitespace) instead of a string. -list_all: put all option values in lists. Normally only options appearing more than once are put in a list. -posix (True): whether to split the input line in POSIX mode or not, as per the conventions outlined in the shlex module from the standard library.""" # inject default options at the beginning of the input line caller = sys._getframe(1).f_code.co_name arg_str = '%s %s' % (self.options_table.get(caller, ''), arg_str) mode = kw.get('mode', 'string') if mode not in ['string', 'list']: raise ValueError, 'incorrect mode given: %s' % mode # Get options list_all = kw.get('list_all', 0) posix = kw.get('posix', os.name == 'posix') strict = kw.get('strict', True) # Check if we have more than one argument to warrant extra processing: odict = {} # Dictionary with options args = arg_str.split() if len(args) >= 1: # If the list of inputs only has 0 or 1 thing in it, there's no # need to look for options argv = arg_split(arg_str, posix, strict) # Do regular option processing try: opts, args = getopt(argv, opt_str, long_opts) except GetoptError, e: raise UsageError('%s ( allowed: "%s" %s)' % (e.msg, opt_str, " ".join(long_opts))) for o, a in opts: if o.startswith('--'): o = o[2:] else: o = o[1:] try: odict[o].append(a) except AttributeError: odict[o] = [odict[o], a] except KeyError: if list_all: odict[o] = [a] else: odict[o] = a # Prepare opts,args for return opts = Struct(odict) if mode == 'string': args = ' '.join(args) return opts, args
def fake_open(arg): open_called_with.append(arg) return Struct(show=lambda: show_called_with.append(None))
def __init__(self, __scheme_name_, colordict=None, **colormap): self.name = __scheme_name_ if colordict is None: self.colors = Struct(**colormap) else: self.colors = Struct(colordict)
def load_config(config): import itango import IPython.utils.coloransi d = { "version": str(common.get_pytango_version()), "pyver": str(common.get_python_version()), "ipyver": str(common.get_ipython_version()), "pytangover": str(common.get_pytango_version()) } d.update(IPython.utils.coloransi.TermColors.__dict__) so = Struct( tango_banner= """%(Blue)shint: Try typing: mydev = Device("%(LightBlue)s<tab>%(Normal)s\n""" ) so = config.get("tango_options", so) # ------------------------------------ # Application # ------------------------------------ app = config.Application app.log_level = 30 # ------------------------------------ # InteractiveShell # ------------------------------------ i_shell = config.InteractiveShell i_shell.colors = 'Linux' # ------------------------------------ # PromptManager (ipython >= 0.12) # ------------------------------------ prompt = config.PromptManager prompt.in_template = 'ITango [\\#]: ' prompt.out_template = 'Result [\\#]: ' # ------------------------------------ # InteractiveShellApp # ------------------------------------ i_shell_app = config.InteractiveShellApp extensions = getattr(i_shell_app, 'extensions', []) extensions.append('itango') i_shell_app.extensions = extensions # ------------------------------------ # TerminalIPythonApp: options for the IPython terminal (and not Qt Console) # ------------------------------------ term_app = config.TerminalIPythonApp term_app.display_banner = True #term_app.nosep = False #term_app.classic = True # ------------------------------------ # IPKernelApp: options for the Qt Console # ------------------------------------ #kernel_app = config.IPKernelApp ipython_widget = config.IPythonWidget ipython_widget.in_prompt = 'ITango [<span class="in-prompt-number">%i</span>]: ' ipython_widget.out_prompt = 'Result [<span class="out-prompt-number">%i</span>]: ' #zmq_i_shell = config.ZMQInteractiveShell # ------------------------------------ # TerminalInteractiveShell # ------------------------------------ term_i_shell = config.TerminalInteractiveShell banner = """\ %(Purple)sITango %(version)s%(Normal)s -- An interactive %(Purple)sTango%(Normal)s client. Running on top of Python %(pyver)s, IPython %(ipyver)s and PyTango %(pytangover)s help -> ITango's help system. object? -> Details about 'object'. ?object also works, ?? prints more. """ banner = banner % d banner = banner.format(**d) tango_banner = so.tango_banner % d tango_banner = tango_banner.format(**d) all_banner = "\n".join((banner, tango_banner)) term_i_shell.banner1 = banner term_i_shell.banner2 = tango_banner # ------------------------------------ # FrontendWidget # ------------------------------------ frontend_widget = config.ITangoConsole frontend_widget.banner = all_banner
def prun(self, parameter_s='', cell=None, user_mode=True, opts=None, arg_lst=None, prog_ns=None): """Run a statement through the python code profiler. Usage, in line mode: %prun [options] statement Usage, in cell mode: %%prun [options] [statement] code... code... In cell mode, the additional code lines are appended to the (possibly empty) statement in the first line. Cell mode allows you to easily profile multiline blocks without having to put them in a separate function. The given statement (which doesn't require quote marks) is run via the python profiler in a manner similar to the profile.run() function. Namespaces are internally managed to work correctly; profile.run cannot be used in IPython because it makes certain assumptions about namespaces which do not hold under IPython. Options: -l <limit>: you can place restrictions on what or how much of the profile gets printed. The limit value can be: * A string: only information for function names containing this string is printed. * An integer: only these many lines are printed. * A float (between 0 and 1): this fraction of the report is printed (for example, use a limit of 0.4 to see the topmost 40% only). You can combine several limits with repeated use of the option. For example, '-l __init__ -l 5' will print only the topmost 5 lines of information about class constructors. -r: return the pstats.Stats object generated by the profiling. This object has all the information about the profile in it, and you can later use it for further analysis or in other functions. -s <key>: sort profile by given key. You can provide more than one key by using the option several times: '-s key1 -s key2 -s key3...'. The default sorting key is 'time'. The following is copied verbatim from the profile documentation referenced below: When more than one key is provided, additional keys are used as secondary criteria when the there is equality in all keys selected before them. Abbreviations can be used for any key names, as long as the abbreviation is unambiguous. The following are the keys currently defined: Valid Arg Meaning "calls" call count "cumulative" cumulative time "file" file name "module" file name "pcalls" primitive call count "line" line number "name" function name "nfl" name/file/line "stdname" standard name "time" internal time Note that all sorts on statistics are in descending order (placing most time consuming items first), where as name, file, and line number searches are in ascending order (i.e., alphabetical). The subtle distinction between "nfl" and "stdname" is that the standard name is a sort of the name as printed, which means that the embedded line numbers get compared in an odd way. For example, lines 3, 20, and 40 would (if the file names were the same) appear in the string order "20" "3" and "40". In contrast, "nfl" does a numeric compare of the line numbers. In fact, sort_stats("nfl") is the same as sort_stats("name", "file", "line"). -T <filename>: save profile results as shown on screen to a text file. The profile is still shown on screen. -D <filename>: save (via dump_stats) profile statistics to given filename. This data is in a format understood by the pstats module, and is generated by a call to the dump_stats() method of profile objects. The profile is still shown on screen. -q: suppress output to the pager. Best used with -T and/or -D above. If you want to run complete programs under the profiler's control, use '%run -p [prof_opts] filename.py [args to program]' where prof_opts contains profiler specific options as described here. You can read the complete documentation for the profile module with:: In [1]: import profile; profile.help() """ opts_def = Struct(D=[''], l=[], s=['time'], T=['']) if user_mode: # regular user call opts, arg_str = self.parse_options(parameter_s, 'D:l:rs:T:q', list_all=True, posix=False) namespace = self.shell.user_ns if cell is not None: arg_str += '\n' + cell else: # called to run a program by %run -p try: filename = get_py_filename(arg_lst[0]) except IOError as e: try: msg = str(e) except UnicodeError: msg = e.message error(msg) return arg_str = 'execfile(filename,prog_ns)' namespace = { 'execfile': self.shell.safe_execfile, 'prog_ns': prog_ns, 'filename': filename } opts.merge(opts_def) prof = profile.Profile() try: prof = prof.runctx(arg_str, namespace, namespace) sys_exit = '' except SystemExit: sys_exit = """*** SystemExit exception caught in code being profiled.""" stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s) lims = opts.l if lims: lims = [] # rebuild lims with ints/floats/strings for lim in opts.l: try: lims.append(int(lim)) except ValueError: try: lims.append(float(lim)) except ValueError: lims.append(lim) # Trap output. stdout_trap = StringIO() stats_stream = stats.stream try: stats.stream = stdout_trap stats.print_stats(*lims) finally: stats.stream = stats_stream output = stdout_trap.getvalue() output = output.rstrip() if 'q' not in opts: page.page(output) print sys_exit, dump_file = opts.D[0] text_file = opts.T[0] if dump_file: dump_file = unquote_filename(dump_file) prof.dump_stats(dump_file) print '\n*** Profile stats marshalled to file',\ repr(dump_file)+'.',sys_exit if text_file: text_file = unquote_filename(text_file) pfile = open(text_file, 'w') pfile.write(output) pfile.close() print '\n*** Profile printout saved to text file',\ repr(text_file)+'.',sys_exit if 'r' in opts: return stats else: return None
def parse_options(self, arg_str, opt_str, *long_opts, **kw): """Parse options passed to an argument string. The interface is similar to that of :func:`getopt.getopt`, but it returns a :class:`~IPython.utils.struct.Struct` with the options as keys and the stripped argument string still as a string. arg_str is quoted as a true sys.argv vector by using shlex.split. This allows us to easily expand variables, glob files, quote arguments, etc. Parameters ---------- arg_str : str The arguments to parse. opt_str : str The options specification. mode : str, default 'string' If given as 'list', the argument string is returned as a list (split on whitespace) instead of a string. list_all : bool, default False Put all option values in lists. Normally only options appearing more than once are put in a list. posix : bool, default True Whether to split the input line in POSIX mode or not, as per the conventions outlined in the :mod:`shlex` module from the standard library. """ # inject default options at the beginning of the input line caller = sys._getframe(1).f_code.co_name arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str) mode = kw.get('mode','string') if mode not in ['string','list']: raise ValueError('incorrect mode given: %s' % mode) # Get options list_all = kw.get('list_all',0) posix = kw.get('posix', os.name == 'posix') strict = kw.get('strict', True) # Check if we have more than one argument to warrant extra processing: odict = {} # Dictionary with options args = arg_str.split() if len(args) >= 1: # If the list of inputs only has 0 or 1 thing in it, there's no # need to look for options argv = arg_split(arg_str, posix, strict) # Do regular option processing try: opts,args = getopt(argv, opt_str, long_opts) except GetoptError as e: raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str, " ".join(long_opts))) for o,a in opts: if o.startswith('--'): o = o[2:] else: o = o[1:] try: odict[o].append(a) except AttributeError: odict[o] = [odict[o],a] except KeyError: if list_all: odict[o] = [a] else: odict[o] = a # Prepare opts,args for return opts = Struct(odict) if mode == 'string': args = ' '.join(args) return opts,args
def doctest_mode(self, parameter_s=""): """Toggle doctest mode on and off. This mode is intended to make IPython behave as much as possible like a plain Python shell, from the perspective of how its prompts, exceptions and output look. This makes it easy to copy and paste parts of a session into doctests. It does so by: - Changing the prompts to the classic ``>>>`` ones. - Changing the exception reporting mode to 'Plain'. - Disabling pretty-printing of output. Note that IPython also supports the pasting of code snippets that have leading '>>>' and '...' prompts in them. This means that you can paste doctests from files or docstrings (even if they have leading whitespace), and the code will execute correctly. You can then use '%history -t' to see the translated history; this will give you the input after removal of all the leading prompts and whitespace, which can be pasted back into an editor. With these features, you can switch into this mode easily whenever you need to do testing and changes to doctests, without having to leave your existing IPython session. """ # Shorthands shell = self.shell meta = shell.meta disp_formatter = self.shell.display_formatter ptformatter = disp_formatter.formatters["text/plain"] # dstore is a data store kept in the instance metadata bag to track any # changes we make, so we can undo them later. dstore = meta.setdefault("doctest_mode", Struct()) save_dstore = dstore.setdefault # save a few values we'll need to recover later mode = save_dstore("mode", False) save_dstore("rc_pprint", ptformatter.pprint) save_dstore("xmode", shell.InteractiveTB.mode) save_dstore("rc_separate_out", shell.separate_out) save_dstore("rc_separate_out2", shell.separate_out2) save_dstore("rc_separate_in", shell.separate_in) save_dstore("rc_active_types", disp_formatter.active_types) if not mode: # turn on # Prompt separators like plain python shell.separate_in = "" shell.separate_out = "" shell.separate_out2 = "" ptformatter.pprint = False disp_formatter.active_types = ["text/plain"] shell.magic("xmode Plain") else: # turn off shell.separate_in = dstore.rc_separate_in shell.separate_out = dstore.rc_separate_out shell.separate_out2 = dstore.rc_separate_out2 ptformatter.pprint = dstore.rc_pprint disp_formatter.active_types = dstore.rc_active_types shell.magic("xmode " + dstore.xmode) # mode here is the state before we switch; switch_doctest_mode takes # the mode we're switching to. shell.switch_doctest_mode(not mode) # Store new mode and inform dstore.mode = bool(not mode) mode_label = ["OFF", "ON"][dstore.mode] print("Doctest mode is:", mode_label)