def load(self,fname,convert=None,recurse_key='',incpath = '.',**kw): """Load a configuration file, return the resulting Struct. Call: load_config(fname,convert=None,conflict=None,recurse_key='') - fname: file to load from. - convert: dictionary of type conversions (see read_dict()) - recurse_key: keyword in dictionary to trigger recursive file inclusions. """ if self.recdepth > self.reclimit: raise ConfigLoaderError, 'maximum recursive inclusion of rcfiles '+\ 'exceeded: ' + `self.recdepth` + \ '.\nMaybe you have a circular chain of inclusions?' self.recdepth += 1 fname = filefind(fname,incpath) data = Struct() # avoid including the same file more than once if fname in self.included: return data Xinfo = ultraTB.AutoFormattedTB(color_scheme='NoColor') if convert==None and recurse_key : convert = {qwflat:recurse_key} # for production, change warn to 0: data.merge(read_dict(fname,convert,fs=self.field_sep,strip=1, warn=0,no_empty=0,**kw)) # keep track of successfully loaded files self.included.append(fname) if recurse_key in data: for incfilename in data[recurse_key]: found=0 try: incfile = filefind(incfilename,incpath) except IOError: if os.name in ['nt','dos']: try: # Try again with '.ini' extension incfilename += '.ini' incfile = filefind(incfilename,incpath) except IOError: found = 0 else: found = 1 else: found = 0 else: found = 1 if found: try: data.merge(self.load(incfile,convert,recurse_key, incpath,**kw), self.conflict) except: Xinfo() warn('Problem loading included file: '+ `incfilename` + '. Ignoring it...') else: warn('File `%s` not found. Included by %s' % (incfilename,fname)) return data
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) return [r for r in res if r.lower().startswith(text.lower())] except ipapi.TryNext: pass return None
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) # Locking control variable. We need to use a norma lock, not an RLock # here. I'm not exactly sure why, it seems to me like it should be # the opposite, but we deadlock with an RLock. Puzzled... self.thread_ready = threading.Condition(threading.Lock()) # A queue to hold the code to be executed. A scalar variable is NOT # enough, because uses like macros cause reentrancy. self.code_queue = Queue.Queue() # Stuff to do at closing time self._kill = False on_kill = kw.get('on_kill') if on_kill is None: 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
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 magic_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. Additionally, functions defined in the interpreter at the In[] prompt or via %run currently cannot be displayed. Write these functions out to a separate file and import them. One or more -f 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. """ # Local import to avoid hard dependency. from IPython.genutils import page from IPython.ipstruct import Struct from IPython.ipapi import UsageError # Escape quote markers. opts_def = Struct(D=[''], T=[''], f=[]) parameter_s = parameter_s.replace('"', r'\"').replace("'", r"\'") opts, arg_str = self.parse_options(parameter_s, 'rf:D:T:', 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, e: raise UsageError('Could not find function %r.\n%s: %s' % (name, e.__class__.__name__, e))
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 ipapi.TryNext: pass return None
def __init__(self, name, usage=None, rc=Struct(opts=None, args=None), user_ns=None, user_global_ns=None, **kw): user_ns, b2 = self._matplotlib_config(name, user_ns) MTInteractiveShell.__init__(self, name, usage, rc, user_ns, user_global_ns, banner2=b2, **kw)
def mprun(self, parameter_s='', cell=None): """ Execute a statement under the line-by-line memory profiler from the memory_profiler module. Usage, in line mode: %mprun -f func1 -f func2 <statement> Usage, in cell mode: %%mprun -f func1 -f func2 [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 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. Additionally, functions defined in the interpreter at the In[] prompt or via %run currently cannot be displayed. Write these functions out to a separate file and import them. One or more -f options are required to get any useful results. -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. -c: If present, add the memory usage of any children process to the report. """ from io import StringIO from memory_profiler import show_results, LineProfiler # Local imports to avoid hard dependency. from distutils.version import LooseVersion import IPython ipython_version = LooseVersion(IPython.__version__) if ipython_version < '0.11': from IPython.genutils import page from IPython.ipstruct import Struct from IPython.ipapi import UsageError else: from IPython.core.page import page from IPython.utils.ipstruct import Struct from IPython.core.error import UsageError # Escape quote markers. opts_def = Struct(T=[''], f=[]) parameter_s = parameter_s.replace('"', r'\"').replace("'", r"\'") opts, arg_str = self.parse_options(parameter_s, 'rf:T:c', list_all=True) opts.merge(opts_def) global_ns = self.shell.user_global_ns local_ns = self.shell.user_ns if cell is not None: arg_str += '\n' + cell # 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)) include_children = 'c' in opts profile = LineProfiler(include_children=include_children) for func in funcs: profile(func) # Add the profiler to the builtins for @profile. 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: 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() show_results(profile, stdout_trap) output = stdout_trap.getvalue() output = output.rstrip() if ipython_version < '0.11': page(output, screen_lines=self.shell.rc.screen_length) else: page(output) print(message, ) text_file = opts.T[0] if text_file: with open(text_file, 'w') as pfile: pfile.write(output) print('\n*** Profile printout saved to text file %s. %s' % ( text_file, message)) return_value = None if 'r' in opts: return_value = profile return return_value
def load(self, fname, convert=None, recurse_key='', incpath='.', **kw): """Load a configuration file, return the resulting Struct. Call: load_config(fname,convert=None,conflict=None,recurse_key='') - fname: file to load from. - convert: dictionary of type conversions (see read_dict()) - recurse_key: keyword in dictionary to trigger recursive file inclusions. """ if self.recdepth > self.reclimit: raise ConfigLoaderError, 'maximum recursive inclusion of rcfiles '+\ 'exceeded: ' + `self.recdepth` + \ '.\nMaybe you have a circular chain of inclusions?' self.recdepth += 1 fname = filefind(fname, incpath) data = Struct() # avoid including the same file more than once if fname in self.included: return data Xinfo = ultraTB.AutoFormattedTB() if convert == None and recurse_key: convert = {qwflat: recurse_key} # for production, change warn to 0: data.merge( read_dict(fname, convert, fs=self.field_sep, strip=1, warn=0, no_empty=0, **kw)) # keep track of successfully loaded files self.included.append(fname) if recurse_key in data.keys(): for incfilename in data[recurse_key]: found = 0 try: incfile = filefind(incfilename, incpath) except IOError: if os.name in ['nt', 'dos']: try: # Try again with '.ini' extension incfilename += '.ini' incfile = filefind(incfilename, incpath) except IOError: found = 0 else: found = 1 else: found = 0 else: found = 1 if found: try: data.merge( self.load(incfile, convert, recurse_key, incpath, **kw), self.conflict) except: Xinfo() warn('Problem loading included file: ' + ` incfilename ` + '. Ignoring it...') else: warn('File `%s` not found. Included by %s' % (incfilename, fname)) return data
def make_IPython(argv=None, user_ns=None, user_global_ns=None, debug=1, rc_override=None, shell_class=InteractiveShell, embedded=False, **kw): """This is a dump of IPython into a single function. Later it will have to be broken up in a sensible manner. Arguments: - argv: a list similar to sys.argv[1:]. It should NOT contain the desired script name, b/c DPyGetOpt strips the first argument only for the real sys.argv. - user_ns: a dict to be used as the user's namespace.""" #---------------------------------------------------------------------- # Defaults and initialization # For developer debugging, deactivates crash handler and uses pdb. DEVDEBUG = False if argv is None: argv = sys.argv # __IP is the main global that lives throughout and represents the whole # application. If the user redefines it, all bets are off as to what # happens. # __IP is the name of he global which the caller will have accessible as # __IP.name. We set its name via the first parameter passed to # InteractiveShell: IP = shell_class('__IP', user_ns=user_ns, user_global_ns=user_global_ns, embedded=embedded, **kw) # Put 'help' in the user namespace try: from site import _Helper IP.user_ns['help'] = _Helper() except ImportError: warn('help() not available - check site.py') IP.user_config_ns = {} if DEVDEBUG: # For developer debugging only (global flag) from IPython import ultraTB sys.excepthook = ultraTB.VerboseTB(call_pdb=1) IP.BANNER_PARTS = [ 'Python %s\n' 'Type "copyright", "credits" or "license" ' 'for more information.\n' % (sys.version.split('\n')[0], ), "IPython %s -- An enhanced Interactive Python." % (__version__, ), """\ ? -> Introduction and overview of IPython's features. %quickref -> Quick reference. help -> Python's own help system. object? -> Details about 'object'. ?object also works, ?? prints more. """ ] IP.usage = interactive_usage # Platform-dependent suffix and directory names. We use _ipython instead # of .ipython under win32 b/c there's software that breaks with .named # directories on that platform. if os.name == 'posix': rc_suffix = '' ipdir_def = '.ipython' else: rc_suffix = '.ini' ipdir_def = '_ipython' # default directory for configuration ipythondir_def = os.path.abspath( os.environ.get('IPYTHONDIR', os.path.join(IP.home_dir, ipdir_def))) sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran # we need the directory where IPython itself is installed import IPython IPython_dir = os.path.dirname(IPython.__file__) del IPython #------------------------------------------------------------------------- # Command line handling # Valid command line options (uses DPyGetOpt syntax, like Perl's # GetOpt::Long) # Any key not listed here gets deleted even if in the file (like session # or profile). That's deliberate, to maintain the rc namespace clean. # Each set of options appears twice: under _conv only the names are # listed, indicating which type they must be converted to when reading the # ipythonrc file. And under DPyGetOpt they are listed with the regular # DPyGetOpt syntax (=s,=i,:f,etc). # Make sure there's a space before each end of line (they get auto-joined!) cmdline_opts = ( 'autocall=i autoindent! automagic! banner! cache_size|cs=i ' 'c=s classic|cl color_info! colors=s confirm_exit! ' 'debug! deep_reload! editor=s log|l messages! nosep ' 'object_info_string_level=i pdb! ' 'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s ' 'pydb! ' 'pylab_import_all! ' 'quick screen_length|sl=i prompts_pad_left=i ' 'logfile|lf=s logplay|lp=s profile|p=s ' 'readline! readline_merge_completions! ' 'readline_omit__names! ' 'rcfile=s separate_in|si=s separate_out|so=s ' 'separate_out2|so2=s xmode=s wildcards_case_sensitive! ' 'magic_docstrings system_verbose! ' 'multi_line_specials! ' 'term_title! wxversion=s ' 'autoedit_syntax!') # Options that can *only* appear at the cmd line (not in rcfiles). cmdline_only = ( 'help interact|i ipythondir=s Version upgrade ' 'gthread! qthread! q4thread! wthread! tkthread! pylab! tk! ' # 'twisted!' # disabled for now. ) # Build the actual name list to be used by DPyGetOpt opts_names = qw(cmdline_opts) + qw(cmdline_only) # Set sensible command line defaults. # This should have everything from cmdline_opts and cmdline_only opts_def = Struct( autocall=1, autoedit_syntax=0, autoindent=0, automagic=1, autoexec=[], banner=1, c='', cache_size=1000, classic=0, color_info=0, colors='NoColor', confirm_exit=1, debug=0, deep_reload=0, editor='0', gthread=0, help=0, interact=0, ipythondir=ipythondir_def, log=0, logfile='', logplay='', messages=1, multi_line_specials=1, nosep=0, object_info_string_level=0, pdb=0, pprint=0, profile='', prompt_in1='In [\\#]: ', prompt_in2=' .\\D.: ', prompt_out='Out[\\#]: ', prompts_pad_left=1, pydb=0, pylab=0, pylab_import_all=1, q4thread=0, qthread=0, quick=0, quiet=0, rcfile='ipythonrc' + rc_suffix, readline=1, readline_merge_completions=1, readline_omit__names=0, screen_length=0, separate_in='\n', separate_out='\n', separate_out2='', system_header='IPython system call: ', system_verbose=0, term_title=1, tk=0, #twisted= 0, # disabled for now upgrade=0, Version=0, wildcards_case_sensitive=1, wthread=0, wxversion='0', xmode='Context', magic_docstrings=0, # undocumented, for doc generation ) # Things that will *only* appear in rcfiles (not at the command line). # Make sure there's a space before each end of line (they get auto-joined!) rcfile_opts = { qwflat: 'include import_mod import_all execfile ', qw_lol: 'import_some ', # for things with embedded whitespace: list_strings: 'execute alias readline_parse_and_bind ', # Regular strings need no conversion: None: 'readline_remove_delims ', } # Default values for these rc_def = Struct( include=[], import_mod=[], import_all=[], import_some=[[]], execute=[], execfile=[], alias=[], readline_parse_and_bind=[], readline_remove_delims='', ) # Build the type conversion dictionary from the above tables: typeconv = rcfile_opts.copy() typeconv.update(optstr2types(cmdline_opts)) # FIXME: the None key appears in both, put that back together by hand. Ugly! typeconv[None] += ' ' + rcfile_opts[None] # Remove quotes at ends of all strings (used to protect spaces) typeconv[unquote_ends] = typeconv[None] del typeconv[None] # Build the list we'll use to make all config decisions with defaults: opts_all = opts_def.copy() opts_all.update(rc_def) # Build conflict resolver for recursive loading of config files: # - preserve means the outermost file maintains the value, it is not # overwritten if an included file has the same key. # - add_flip applies + to the two values, so it better make sense to add # those types of keys. But it flips them first so that things loaded # deeper in the inclusion chain have lower precedence. conflict = { 'preserve': ' '.join([typeconv[int], typeconv[unquote_ends]]), 'add_flip': ' '.join([typeconv[qwflat], typeconv[qw_lol], typeconv[list_strings]]) } # Now actually process the command line getopt = DPyGetOpt.DPyGetOpt() getopt.setIgnoreCase(0) getopt.parseConfiguration(opts_names) try: getopt.processArguments(argv) except DPyGetOpt.ArgumentError, exc: print cmd_line_usage warn('\nError in Arguments: "%s"' % exc) sys.exit(1)
# Now actually process the command line getopt = DPyGetOpt.DPyGetOpt() getopt.setIgnoreCase(0) getopt.parseConfiguration(opts_names) try: getopt.processArguments(argv) except DPyGetOpt.ArgumentError, exc: print cmd_line_usage warn('\nError in Arguments: "%s"' % exc) sys.exit(1) # convert the options dict to a struct for much lighter syntax later opts = Struct(getopt.optionValues) args = getopt.freeValues # this is the struct (which has default values at this point) with which # we make all decisions: opts_all.update(opts) # Options that force an immediate exit if opts_all.help: page(cmd_line_usage) sys.exit() if opts_all.Version: print __version__ sys.exit()
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 make_IPython(argv=None, user_ns=None, user_global_ns=None, debug=1, rc_override=None, shell_class=InteractiveShell, embedded=False, **kw): """This is a dump of IPython into a single function. Later it will have to be broken up in a sensible manner. Arguments: - argv: a list similar to sys.argv[1:]. It should NOT contain the desired script name, b/c DPyGetOpt strips the first argument only for the real sys.argv. - user_ns: a dict to be used as the user's namespace.""" #---------------------------------------------------------------------- # Defaults and initialization # For developer debugging, deactivates crash handler and uses pdb. DEVDEBUG = False if argv is None: argv = sys.argv # __IP is the main global that lives throughout and represents the whole # application. If the user redefines it, all bets are off as to what # happens. # __IP is the name of he global which the caller will have accessible as # __IP.name. We set its name via the first parameter passed to # InteractiveShell: IP = shell_class('__IP', user_ns=user_ns, user_global_ns=user_global_ns, embedded=embedded, **kw) # Put 'help' in the user namespace from site import _Helper IP.user_ns['help'] = _Helper() if DEVDEBUG: # For developer debugging only (global flag) from IPython import ultraTB sys.excepthook = ultraTB.VerboseTB(call_pdb=1) IP.BANNER_PARTS = [ 'Python %s\n' 'Type "copyright", "credits" or "license" ' 'for more information.\n' % (sys.version.split('\n')[0], ), "IPython %s -- An enhanced Interactive Python." % (__version__, ), """? -> Introduction to IPython's features. %magic -> Information about IPython's 'magic' % functions. help -> Python's own help system. object? -> Details about 'object'. ?object also works, ?? prints more. """ ] IP.usage = interactive_usage # Platform-dependent suffix and directory names. We use _ipython instead # of .ipython under win32 b/c there's software that breaks with .named # directories on that platform. if os.name == 'posix': rc_suffix = '' ipdir_def = '.ipython' else: rc_suffix = '.ini' ipdir_def = '_ipython' # default directory for configuration ipythondir_def = os.path.abspath( os.environ.get('IPYTHONDIR', os.path.join(IP.home_dir, ipdir_def))) sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran # we need the directory where IPython itself is installed import IPython IPython_dir = os.path.dirname(IPython.__file__) del IPython #------------------------------------------------------------------------- # Command line handling # Valid command line options (uses DPyGetOpt syntax, like Perl's # GetOpt::Long) # Any key not listed here gets deleted even if in the file (like session # or profile). That's deliberate, to maintain the rc namespace clean. # Each set of options appears twice: under _conv only the names are # listed, indicating which type they must be converted to when reading the # ipythonrc file. And under DPyGetOpt they are listed with the regular # DPyGetOpt syntax (=s,=i,:f,etc). # Make sure there's a space before each end of line (they get auto-joined!) cmdline_opts = ( 'autocall=i autoindent! automagic! banner! cache_size|cs=i ' 'c=s classic|cl color_info! colors=s confirm_exit! ' 'debug! deep_reload! editor=s log|l messages! nosep ' 'object_info_string_level=i pdb! ' 'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s ' 'quick screen_length|sl=i prompts_pad_left=i ' 'logfile|lf=s logplay|lp=s profile|p=s ' 'readline! readline_merge_completions! ' 'readline_omit__names! ' 'rcfile=s separate_in|si=s separate_out|so=s ' 'separate_out2|so2=s xmode=s wildcards_case_sensitive! ' 'magic_docstrings system_verbose! ' 'multi_line_specials! ' 'wxversion=s ' 'autoedit_syntax!') # Options that can *only* appear at the cmd line (not in rcfiles). # The "ignore" option is a kludge so that Emacs buffers don't crash, since # the 'C-c !' command in emacs automatically appends a -i option at the end. cmdline_only = ('help ignore|i ipythondir=s Version upgrade ' 'gthread! qthread! wthread! pylab! tk!') # Build the actual name list to be used by DPyGetOpt opts_names = qw(cmdline_opts) + qw(cmdline_only) # Set sensible command line defaults. # This should have everything from cmdline_opts and cmdline_only opts_def = Struct( autocall=1, autoedit_syntax=0, autoindent=0, automagic=1, banner=1, cache_size=1000, c='', classic=0, colors='NoColor', color_info=0, confirm_exit=1, debug=0, deep_reload=0, editor='0', help=0, ignore=0, ipythondir=ipythondir_def, log=0, logfile='', logplay='', multi_line_specials=1, messages=1, object_info_string_level=0, nosep=0, pdb=0, pprint=0, profile='', prompt_in1='In [\\#]: ', prompt_in2=' .\\D.: ', prompt_out='Out[\\#]: ', prompts_pad_left=1, quick=0, readline=1, readline_merge_completions=1, readline_omit__names=0, rcfile='ipythonrc' + rc_suffix, screen_length=0, separate_in='\n', separate_out='\n', separate_out2='', system_verbose=0, gthread=0, qthread=0, wthread=0, pylab=0, tk=0, upgrade=0, Version=0, xmode='Verbose', wildcards_case_sensitive=1, wxversion='0', magic_docstrings=0, # undocumented, for doc generation ) # Things that will *only* appear in rcfiles (not at the command line). # Make sure there's a space before each end of line (they get auto-joined!) rcfile_opts = { qwflat: 'include import_mod import_all execfile ', qw_lol: 'import_some ', # for things with embedded whitespace: list_strings: 'execute alias readline_parse_and_bind ', # Regular strings need no conversion: None: 'readline_remove_delims ', } # Default values for these rc_def = Struct( include=[], import_mod=[], import_all=[], import_some=[[]], execute=[], execfile=[], alias=[], readline_parse_and_bind=[], readline_remove_delims='', ) # Build the type conversion dictionary from the above tables: typeconv = rcfile_opts.copy() typeconv.update(optstr2types(cmdline_opts)) # FIXME: the None key appears in both, put that back together by hand. Ugly! typeconv[None] += ' ' + rcfile_opts[None] # Remove quotes at ends of all strings (used to protect spaces) typeconv[unquote_ends] = typeconv[None] del typeconv[None] # Build the list we'll use to make all config decisions with defaults: opts_all = opts_def.copy() opts_all.update(rc_def) # Build conflict resolver for recursive loading of config files: # - preserve means the outermost file maintains the value, it is not # overwritten if an included file has the same key. # - add_flip applies + to the two values, so it better make sense to add # those types of keys. But it flips them first so that things loaded # deeper in the inclusion chain have lower precedence. conflict = { 'preserve': ' '.join([typeconv[int], typeconv[unquote_ends]]), 'add_flip': ' '.join([typeconv[qwflat], typeconv[qw_lol], typeconv[list_strings]]) } # Now actually process the command line getopt = DPyGetOpt.DPyGetOpt() getopt.setIgnoreCase(0) getopt.parseConfiguration(opts_names) try: getopt.processArguments(argv) except: print cmd_line_usage warn('\nError in Arguments: ' + ` sys.exc_value `) sys.exit(1) # convert the options dict to a struct for much lighter syntax later opts = Struct(getopt.optionValues) args = getopt.freeValues # this is the struct (which has default values at this point) with which # we make all decisions: opts_all.update(opts) # Options that force an immediate exit if opts_all.help: page(cmd_line_usage) sys.exit() if opts_all.Version: print __version__ sys.exit() if opts_all.magic_docstrings: IP.magic_magic('-latex') sys.exit() # add personal ipythondir to sys.path so that users can put things in # there for customization sys.path.append(os.path.abspath(opts_all.ipythondir)) # Create user config directory if it doesn't exist. This must be done # *after* getting the cmd line options. if not os.path.isdir(opts_all.ipythondir): IP.user_setup(opts_all.ipythondir, rc_suffix, 'install') # upgrade user config files while preserving a copy of the originals if opts_all.upgrade: IP.user_setup(opts_all.ipythondir, rc_suffix, 'upgrade') # check mutually exclusive options in the *original* command line mutex_opts(opts, [ qw('log logfile'), qw('rcfile profile'), qw('classic profile'), qw('classic rcfile') ]) #--------------------------------------------------------------------------- # Log replay # if -logplay, we need to 'become' the other session. That basically means # replacing the current command line environment with that of the old # session and moving on. # this is needed so that later we know we're in session reload mode, as # opts_all will get overwritten: load_logplay = 0 if opts_all.logplay: load_logplay = opts_all.logplay opts_debug_save = opts_all.debug try: logplay = open(opts_all.logplay) except IOError: if opts_all.debug: IP.InteractiveTB() warn('Could not open logplay file ' + ` opts_all.logplay `) # restore state as if nothing had happened and move on, but make # sure that later we don't try to actually load the session file logplay = None load_logplay = 0 del opts_all.logplay else: try: logplay.readline() logplay.readline() # this reloads that session's command line cmd = logplay.readline()[6:] exec cmd # restore the true debug flag given so that the process of # session loading itself can be monitored. opts.debug = opts_debug_save # save the logplay flag so later we don't overwrite the log opts.logplay = load_logplay # now we must update our own structure with defaults opts_all.update(opts) # now load args cmd = logplay.readline()[6:] exec cmd logplay.close() except: logplay.close() if opts_all.debug: IP.InteractiveTB() warn("Logplay file lacking full configuration information.\n" "I'll try to read it, but some things may not work.") #------------------------------------------------------------------------- # set up output traps: catch all output from files, being run, modules # loaded, etc. Then give it to the user in a clean form at the end. msg_out = 'Output messages. ' msg_err = 'Error messages. ' msg_sep = '\n' msg = Struct(config=OutputTrap('Configuration Loader', msg_out, msg_err, msg_sep, debug, quiet_out=1), user_exec=OutputTrap('User File Execution', msg_out, msg_err, msg_sep, debug), logplay=OutputTrap('Log Loader', msg_out, msg_err, msg_sep, debug), summary='') #------------------------------------------------------------------------- # Process user ipythonrc-type configuration files # turn on output trapping and log to msg.config # remember that with debug on, trapping is actually disabled msg.config.trap_all() # look for rcfile in current or default directory try: opts_all.rcfile = filefind(opts_all.rcfile, opts_all.ipythondir) except IOError: if opts_all.debug: IP.InteractiveTB() warn('Configuration file %s not found. Ignoring request.' % (opts_all.rcfile)) # 'profiles' are a shorthand notation for config filenames if opts_all.profile: try: opts_all.rcfile = filefind( 'ipythonrc-' + opts_all.profile + rc_suffix, opts_all.ipythondir) except IOError: if opts_all.debug: IP.InteractiveTB() opts.profile = '' # remove profile from options if invalid # We won't warn anymore, primary method is ipy_profile_PROFNAME # which does trigger a warning. # load the config file rcfiledata = None if opts_all.quick: print 'Launching IPython in quick mode. No config file read.' elif opts_all.classic: print 'Launching IPython in classic mode. No config file read.' elif opts_all.rcfile: try: cfg_loader = ConfigLoader(conflict) rcfiledata = cfg_loader.load(opts_all.rcfile, typeconv, 'include', opts_all.ipythondir, purge=1, unique=conflict['preserve']) except: IP.InteractiveTB() warn('Problems loading configuration file ' + ` opts_all.rcfile ` + '\nStarting with default -bare bones- configuration.') else: warn('No valid configuration file found in either currrent directory\n' + 'or in the IPython config. directory: ' + ` opts_all.ipythondir ` + '\nProceeding with internal defaults.') #------------------------------------------------------------------------ # Set exception handlers in mode requested by user. otrap = OutputTrap(trap_out=1) # trap messages from magic_xmode IP.magic_xmode(opts_all.xmode) otrap.release_out() #------------------------------------------------------------------------ # Execute user config # Create a valid config structure with the right precedence order: # defaults < rcfile < command line. This needs to be in the instance, so # that method calls below that rely on it find it. IP.rc = rc_def.copy() # Work with a local alias inside this routine to avoid unnecessary # attribute lookups. IP_rc = IP.rc IP_rc.update(opts_def) if rcfiledata: # now we can update IP_rc.update(rcfiledata) IP_rc.update(opts) IP_rc.update(rc_override) # Store the original cmd line for reference: IP_rc.opts = opts IP_rc.args = args # create a *runtime* Struct like rc for holding parameters which may be # created and/or modified by runtime user extensions. IP.runtime_rc = Struct() # from this point on, all config should be handled through IP_rc, # opts* shouldn't be used anymore. # update IP_rc with some special things that need manual # tweaks. Basically options which affect other options. I guess this # should just be written so that options are fully orthogonal and we # wouldn't worry about this stuff! if IP_rc.classic: IP_rc.quick = 1 IP_rc.cache_size = 0 IP_rc.pprint = 0 IP_rc.prompt_in1 = '>>> ' IP_rc.prompt_in2 = '... ' IP_rc.prompt_out = '' IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0' IP_rc.colors = 'NoColor' IP_rc.xmode = 'Plain' IP.pre_config_initialization() # configure readline # Define the history file for saving commands in between sessions if IP_rc.profile: histfname = 'history-%s' % IP_rc.profile else: histfname = 'history' IP.histfile = os.path.join(opts_all.ipythondir, histfname) # update exception handlers with rc file status otrap.trap_out() # I don't want these messages ever. IP.magic_xmode(IP_rc.xmode) otrap.release_out() # activate logging if requested and not reloading a log if IP_rc.logplay: IP.magic_logstart(IP_rc.logplay + ' append') elif IP_rc.logfile: IP.magic_logstart(IP_rc.logfile) elif IP_rc.log: IP.magic_logstart() # find user editor so that it we don't have to look it up constantly if IP_rc.editor.strip() == '0': try: ed = os.environ['EDITOR'] except KeyError: if os.name == 'posix': ed = 'vi' # the only one guaranteed to be there! else: ed = 'notepad' # same in Windows! IP_rc.editor = ed # Keep track of whether this is an embedded instance or not (useful for # post-mortems). IP_rc.embedded = IP.embedded # Recursive reload try: from IPython import deep_reload if IP_rc.deep_reload: __builtin__.reload = deep_reload.reload else: __builtin__.dreload = deep_reload.reload del deep_reload except ImportError: pass # Save the current state of our namespace so that the interactive shell # can later know which variables have been created by us from config files # and loading. This way, loading a file (in any way) is treated just like # defining things on the command line, and %who works as expected. # DON'T do anything that affects the namespace beyond this point! IP.internal_ns.update(__main__.__dict__) #IP.internal_ns.update(locals()) # so our stuff doesn't show up in %who # Now run through the different sections of the users's config if IP_rc.debug: print 'Trying to execute the following configuration structure:' print '(Things listed first are deeper in the inclusion tree and get' print 'loaded first).\n' pprint(IP_rc.__dict__) for mod in IP_rc.import_mod: try: exec 'import ' + mod in IP.user_ns except: IP.InteractiveTB() import_fail_info(mod) for mod_fn in IP_rc.import_some: if mod_fn == []: break mod, fn = mod_fn[0], ','.join(mod_fn[1:]) try: exec 'from ' + mod + ' import ' + fn in IP.user_ns except: IP.InteractiveTB() import_fail_info(mod, fn) for mod in IP_rc.import_all: try: exec 'from ' + mod + ' import *' in IP.user_ns except: IP.InteractiveTB() import_fail_info(mod) for code in IP_rc.execute: try: exec code in IP.user_ns except: IP.InteractiveTB() warn('Failure executing code: ' + ` code `) # Execute the files the user wants in ipythonrc for file in IP_rc.execfile: try: file = filefind(file, sys.path + [IPython_dir]) except IOError: warn(itpl('File $file not found. Skipping it.')) else: IP.safe_execfile(os.path.expanduser(file), IP.user_ns) # finally, try importing ipy_*_conf for final configuration try: import ipy_system_conf except ImportError: if opts_all.debug: IP.InteractiveTB() warn("Could not import 'ipy_system_conf'") except: IP.InteractiveTB() import_fail_info('ipy_system_conf') if opts_all.profile: profmodname = 'ipy_profile_' + opts_all.profile try: __import__(profmodname) except ImportError: # only warn if ipythonrc-PROFNAME didn't exist if opts.profile == '': warn("Could not start with profile '%s'!\n" "('%s/%s.py' does not exist? run '%%upgrade')" % (opts_all.profile, opts_all.ipythondir, profmodname)) except: print "Error importing", profmodname IP.InteractiveTB() import_fail_info(profmodname) try: import ipy_user_conf except ImportError: if opts_all.debug: IP.InteractiveTB() warn("Could not import user config!\n " "('%s/ipy_user_conf.py' does not exist? Please run '%%upgrade')\n" % opts_all.ipythondir) except: print "Error importing ipy_user_conf" IP.InteractiveTB() import_fail_info("ipy_user_conf") # release stdout and stderr and save config log into a global summary msg.config.release_all() if IP_rc.messages: msg.summary += msg.config.summary_all() #------------------------------------------------------------------------ # Setup interactive session # Now we should be fully configured. We can then execute files or load # things only needed for interactive use. Then we'll open the shell. # Take a snapshot of the user namespace before opening the shell. That way # we'll be able to identify which things were interactively defined and # which were defined through config files. IP.user_config_ns = IP.user_ns.copy() # Force reading a file as if it were a session log. Slower but safer. if load_logplay: print 'Replaying log...' try: if IP_rc.debug: logplay_quiet = 0 else: logplay_quiet = 1 msg.logplay.trap_all() IP.safe_execfile(load_logplay, IP.user_ns, islog=1, quiet=logplay_quiet) msg.logplay.release_all() if IP_rc.messages: msg.summary += msg.logplay.summary_all() except: warn('Problems replaying logfile %s.' % load_logplay) IP.InteractiveTB() # Load remaining files in command line msg.user_exec.trap_all() # Do NOT execute files named in the command line as scripts to be loaded # by embedded instances. Doing so has the potential for an infinite # recursion if there are exceptions thrown in the process. # XXX FIXME: the execution of user files should be moved out to after # ipython is fully initialized, just as if they were run via %run at the # ipython prompt. This would also give them the benefit of ipython's # nice tracebacks. if (not embedded and IP_rc.args and not IP_rc.args[0].lower().endswith('.ipy')): name_save = IP.user_ns['__name__'] IP.user_ns['__name__'] = '__main__' # Set our own excepthook in case the user code tries to call it # directly. This prevents triggering the IPython crash handler. old_excepthook, sys.excepthook = sys.excepthook, IP.excepthook save_argv = sys.argv[1:] # save it for later restoring sys.argv = args try: IP.safe_execfile(args[0], IP.user_ns) finally: # Reset our crash handler in place sys.excepthook = old_excepthook sys.argv[:] = save_argv IP.user_ns['__name__'] = name_save msg.user_exec.release_all() if IP_rc.messages: msg.summary += msg.user_exec.summary_all() # since we can't specify a null string on the cmd line, 0 is the equivalent: if IP_rc.nosep: IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0' if IP_rc.separate_in == '0': IP_rc.separate_in = '' if IP_rc.separate_out == '0': IP_rc.separate_out = '' if IP_rc.separate_out2 == '0': IP_rc.separate_out2 = '' IP_rc.separate_in = IP_rc.separate_in.replace('\\n', '\n') IP_rc.separate_out = IP_rc.separate_out.replace('\\n', '\n') IP_rc.separate_out2 = IP_rc.separate_out2.replace('\\n', '\n') # Determine how many lines at the bottom of the screen are needed for # showing prompts, so we can know wheter long strings are to be printed or # paged: num_lines_bot = IP_rc.separate_in.count('\n') + 1 IP_rc.screen_length = IP_rc.screen_length - num_lines_bot # configure startup banner if IP_rc.c: # regular python doesn't print the banner with -c IP_rc.banner = 0 if IP_rc.banner: BANN_P = IP.BANNER_PARTS else: BANN_P = [] if IP_rc.profile: BANN_P.append('IPython profile: %s\n' % IP_rc.profile) # add message log (possibly empty) if msg.summary: BANN_P.append(msg.summary) # Final banner is a string IP.BANNER = '\n'.join(BANN_P) # Finalize the IPython instance. This assumes the rc structure is fully # in place. IP.post_config_initialization() return IP
def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1, rc_override=None,shell_class=InteractiveShell, embedded=False,**kw): """This is a dump of IPython into a single function. Later it will have to be broken up in a sensible manner. Arguments: - argv: a list similar to sys.argv[1:]. It should NOT contain the desired script name, b/c DPyGetOpt strips the first argument only for the real sys.argv. - user_ns: a dict to be used as the user's namespace.""" #---------------------------------------------------------------------- # Defaults and initialization # For developer debugging, deactivates crash handler and uses pdb. DEVDEBUG = False if argv is None: argv = sys.argv # __IP is the main global that lives throughout and represents the whole # application. If the user redefines it, all bets are off as to what # happens. # __IP is the name of he global which the caller will have accessible as # __IP.name. We set its name via the first parameter passed to # InteractiveShell: IP = shell_class('__IP',user_ns=user_ns,user_global_ns=user_global_ns, embedded=embedded,**kw) # Put 'help' in the user namespace from site import _Helper IP.user_config_ns = {} IP.user_ns['help'] = _Helper() if DEVDEBUG: # For developer debugging only (global flag) from IPython import ultraTB sys.excepthook = ultraTB.VerboseTB(call_pdb=1) IP.BANNER_PARTS = ['Python %s\n' 'Type "copyright", "credits" or "license" ' 'for more information.\n' % (sys.version.split('\n')[0],), "IPython %s -- An enhanced Interactive Python." % (__version__,), """\ ? -> Introduction and overview of IPython's features. %quickref -> Quick reference. help -> Python's own help system. object? -> Details about 'object'. ?object also works, ?? prints more. """ ] IP.usage = interactive_usage # Platform-dependent suffix and directory names. We use _ipython instead # of .ipython under win32 b/c there's software that breaks with .named # directories on that platform. if os.name == 'posix': rc_suffix = '' ipdir_def = '.ipython' else: rc_suffix = '.ini' ipdir_def = '_ipython' # default directory for configuration ipythondir_def = os.path.abspath(os.environ.get('IPYTHONDIR', os.path.join(IP.home_dir,ipdir_def))) sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran # we need the directory where IPython itself is installed import IPython IPython_dir = os.path.dirname(IPython.__file__) del IPython #------------------------------------------------------------------------- # Command line handling # Valid command line options (uses DPyGetOpt syntax, like Perl's # GetOpt::Long) # Any key not listed here gets deleted even if in the file (like session # or profile). That's deliberate, to maintain the rc namespace clean. # Each set of options appears twice: under _conv only the names are # listed, indicating which type they must be converted to when reading the # ipythonrc file. And under DPyGetOpt they are listed with the regular # DPyGetOpt syntax (=s,=i,:f,etc). # Make sure there's a space before each end of line (they get auto-joined!) cmdline_opts = ('autocall=i autoindent! automagic! banner! cache_size|cs=i ' 'c=s classic|cl color_info! colors=s confirm_exit! ' 'debug! deep_reload! editor=s log|l messages! nosep ' 'object_info_string_level=i pdb! ' 'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s ' 'pydb! ' 'pylab_import_all! ' 'quick screen_length|sl=i prompts_pad_left=i ' 'logfile|lf=s logplay|lp=s profile|p=s ' 'readline! readline_merge_completions! ' 'readline_omit__names! ' 'rcfile=s separate_in|si=s separate_out|so=s ' 'separate_out2|so2=s xmode=s wildcards_case_sensitive! ' 'magic_docstrings system_verbose! ' 'multi_line_specials! ' 'term_title! wxversion=s ' 'autoedit_syntax!') # Options that can *only* appear at the cmd line (not in rcfiles). cmdline_only = ('help interact|i ipythondir=s Version upgrade ' 'gthread! qthread! q4thread! wthread! tkthread! pylab! tk! ' 'twisted!') # Build the actual name list to be used by DPyGetOpt opts_names = qw(cmdline_opts) + qw(cmdline_only) # Set sensible command line defaults. # This should have everything from cmdline_opts and cmdline_only opts_def = Struct(autocall = 1, autoedit_syntax = 0, autoindent = 0, automagic = 1, autoexec = [], banner = 1, c = '', cache_size = 1000, classic = 0, color_info = 0, colors = 'NoColor', confirm_exit = 1, debug = 0, deep_reload = 0, editor = '0', gthread = 0, help = 0, interact = 0, ipythondir = ipythondir_def, log = 0, logfile = '', logplay = '', messages = 1, multi_line_specials = 1, nosep = 0, object_info_string_level = 0, pdb = 0, pprint = 0, profile = '', prompt_in1 = 'In [\\#]: ', prompt_in2 = ' .\\D.: ', prompt_out = 'Out[\\#]: ', prompts_pad_left = 1, pylab = 0, pylab_import_all = 1, q4thread = 0, qthread = 0, quick = 0, quiet = 0, rcfile = 'ipythonrc' + rc_suffix, readline = 1, readline_merge_completions = 1, readline_omit__names = 0, screen_length = 0, separate_in = '\n', separate_out = '\n', separate_out2 = '', system_header = 'IPython system call: ', system_verbose = 0, term_title = 1, tk = 0, twisted= 0, upgrade = 0, Version = 0, wildcards_case_sensitive = 1, wthread = 0, wxversion = '0', xmode = 'Context', magic_docstrings = 0, # undocumented, for doc generation ) # Things that will *only* appear in rcfiles (not at the command line). # Make sure there's a space before each end of line (they get auto-joined!) rcfile_opts = { qwflat: 'include import_mod import_all execfile ', qw_lol: 'import_some ', # for things with embedded whitespace: list_strings:'execute alias readline_parse_and_bind ', # Regular strings need no conversion: None:'readline_remove_delims ', } # Default values for these rc_def = Struct(include = [], import_mod = [], import_all = [], import_some = [[]], execute = [], execfile = [], alias = [], readline_parse_and_bind = [], readline_remove_delims = '', ) # Build the type conversion dictionary from the above tables: typeconv = rcfile_opts.copy() typeconv.update(optstr2types(cmdline_opts)) # FIXME: the None key appears in both, put that back together by hand. Ugly! typeconv[None] += ' ' + rcfile_opts[None] # Remove quotes at ends of all strings (used to protect spaces) typeconv[unquote_ends] = typeconv[None] del typeconv[None] # Build the list we'll use to make all config decisions with defaults: opts_all = opts_def.copy() opts_all.update(rc_def) # Build conflict resolver for recursive loading of config files: # - preserve means the outermost file maintains the value, it is not # overwritten if an included file has the same key. # - add_flip applies + to the two values, so it better make sense to add # those types of keys. But it flips them first so that things loaded # deeper in the inclusion chain have lower precedence. conflict = {'preserve': ' '.join([ typeconv[int], typeconv[unquote_ends] ]), 'add_flip': ' '.join([ typeconv[qwflat], typeconv[qw_lol], typeconv[list_strings] ]) } # Now actually process the command line getopt = DPyGetOpt.DPyGetOpt() getopt.setIgnoreCase(0) getopt.parseConfiguration(opts_names) try: getopt.processArguments(argv) except DPyGetOpt.ArgumentError, exc: print cmd_line_usage warn('\nError in Arguments: "%s"' % exc) sys.exit(1)
def magic_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. Additionally, functions defined in the interpreter at the In[] prompt or via %run currently cannot be displayed. Write these functions out to a separate file and import them. -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. """ # Local imports to avoid hard dependency. from distutils.version import LooseVersion import IPython ipython_version = LooseVersion(IPython.__version__) if ipython_version < '0.11': from IPython.genutils import page from IPython.ipstruct import Struct from IPython.ipapi import UsageError else: from IPython.core.page import page from IPython.utils.ipstruct import Struct from IPython.core.error import UsageError # Escape quote markers. opts_def = Struct(D=[''], T=[''], f=[], m=[]) parameter_s = parameter_s.replace('"', r'\"').replace("'", r"\'") opts, arg_str = self.parse_options(parameter_s, 'rsf:m:D:T:', 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)) # 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, stripzeros='s' in opts) output = stdout_trap.getvalue() output = output.rstrip() if ipython_version < '0.11': page(output, screen_lines=self.shell.rc.screen_length) else: 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