diff --git a/IPython/config/profile/ipython_config_math.py b/IPython/config/profile/ipython_config_math.py index f18448e..2238227 100644 --- a/IPython/config/profile/ipython_config_math.py +++ b/IPython/config/profile/ipython_config_math.py @@ -1,9 +1,8 @@ from ipython_config import * -EXECUTE.extend([ +Global.exec_lines.extend([ 'import cmath', 'from math import *', 'print "*** math functions available globally, cmath as a module"' - ]) diff --git a/IPython/config/profile/ipython_config_numeric.py b/IPython/config/profile/ipython_config_numeric.py index 70a731e..28031fa 100644 --- a/IPython/config/profile/ipython_config_numeric.py +++ b/IPython/config/profile/ipython_config_numeric.py @@ -1,6 +1,6 @@ from ipython_config import * -EXECUTE.extend([ +Global.exec_lines.extend([ 'import numpy', 'import scipy', 'import numpy as np', diff --git a/IPython/config/profile/ipython_config_pylab.py b/IPython/config/profile/ipython_config_pylab.py index 705b665..edf6c5d 100644 --- a/IPython/config/profile/ipython_config_pylab.py +++ b/IPython/config/profile/ipython_config_pylab.py @@ -1,7 +1,8 @@ from ipython_config_numeric import * -EXECUTE.extend([ - - +Global.exec_lines.extend([ + 'import matplotlib', + 'from matplotlib import pyplot as plt', + 'from matplotlib.pyplot import *' ]) diff --git a/IPython/config/profile/ipython_config_pysh.py b/IPython/config/profile/ipython_config_pysh.py index 1720b87..3fe3f95 100644 --- a/IPython/config/profile/ipython_config_pysh.py +++ b/IPython/config/profile/ipython_config_pysh.py @@ -1,15 +1,13 @@ from ipython_config import * -EXECUTE.insert(0, 'from IPython.extensions.InterpreterExec import *') +InteractiveShell.prompt_in2 = '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> ' +InteractiveShell.prompt_in2 = '\C_Green|\C_LightGreen\D\C_Green> ' +InteractiveShell.prompt_out = '<\#> ' -PROMPT_IN1 = '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> ' -PROMPT_IN2 = '\C_Green|\C_LightGreen\D\C_Green> ' -PROMPT_OUT = '<\#> ' +InteractiveShell.prompts_pad_left = True -PROMPTS_PAD_LEFT = True +InteractiveShell.separate_in = '' +InteractiveShell.separate_out = '' +InteractiveShell.separate_out2 = '' -SEPARATE_IN = 0 -SEPARATE_OUT = 0 -SEPARATE_OUT2 = 0 - -MULTI_LINE_SPECIALS = True \ No newline at end of file +PrefilterManager.multi_line_specials = True \ No newline at end of file diff --git a/IPython/config/profile/ipython_config_sympy.py b/IPython/config/profile/ipython_config_sympy.py index a36b833..2bf5bef 100644 --- a/IPython/config/profile/ipython_config_sympy.py +++ b/IPython/config/profile/ipython_config_sympy.py @@ -1,9 +1,9 @@ from ipython_config import * -EXECUTE.extend([ - 'from __future__ import division' - 'from sympy import *' - 'x, y, z = symbols('xyz')' - 'k, m, n = symbols('kmn', integer=True)' - 'f, g, h = map(Function, 'fgh')' +Global.exec_lines.extend([ + "from __future__ import division" + "from sympy import *" + "x, y, z = symbols('xyz')" + "k, m, n = symbols('kmn', integer=True)" + "f, g, h = map(Function, 'fgh')" ]) diff --git a/IPython/core/alias.py b/IPython/core/alias.py index 60cabc1..3dbb8cd 100644 --- a/IPython/core/alias.py +++ b/IPython/core/alias.py @@ -112,11 +112,9 @@ class AliasManager(Component): @auto_attr def shell(self): - shell = Component.get_instances( + return Component.get_instances( root=self.root, - klass='IPython.core.iplib.InteractiveShell' - )[0] - return shell + klass='IPython.core.iplib.InteractiveShell')[0] def __contains__(self, name): if name in self.alias_table: diff --git a/IPython/core/application.py b/IPython/core/application.py index 882064b..90b2f40 100644 --- a/IPython/core/application.py +++ b/IPython/core/application.py @@ -23,6 +23,7 @@ Notes # Imports #----------------------------------------------------------------------------- +import logging import os import sys import traceback @@ -53,8 +54,8 @@ class IPythonArgParseConfigLoader(ArgParseConfigLoader): help='The string name of the ipython profile to be used.', default=NoConfigDefault, metavar='Global.profile') - self.parser.add_argument('-debug',dest="Global.debug",action='store_true', - help='Debug the application startup process.', + self.parser.add_argument('-log_level',dest="Global.log_level",type=int, + help='Set the log level (0,10,20,30,40,50). Default is 30.', default=NoConfigDefault) self.parser.add_argument('-config_file',dest='Global.config_file',type=str, help='Set the config file name to override default.', @@ -72,10 +73,26 @@ class Application(object): config_file_name = 'ipython_config.py' name = 'ipython' - debug = False def __init__(self): - pass + self.init_logger() + + def init_logger(self): + self.log = logging.getLogger(self.__class__.__name__) + # This is used as the default until the command line arguments are read. + self.log.setLevel(logging.WARN) + self._log_handler = logging.StreamHandler() + self._log_formatter = logging.Formatter("[%(name)s] %(message)s") + self._log_handler.setFormatter(self._log_formatter) + self.log.addHandler(self._log_handler) + + def _set_log_level(self, level): + self.log.setLevel(level) + + def _get_log_level(self): + return self.log.level + + log_level = property(_get_log_level, _set_log_level) def start(self): """Start the application.""" @@ -103,6 +120,8 @@ class Application(object): """Create defaults that can't be set elsewhere.""" self.default_config = Config() self.default_config.Global.ipythondir = get_ipython_dir() + self.log.debug('Default config loaded:') + self.log.debug(repr(self.default_config)) def create_command_line_config(self): """Create and return a command line config loader.""" @@ -120,12 +139,14 @@ class Application(object): loader = self.create_command_line_config() self.command_line_config = loader.load_config() + try: - self.debug = self.command_line_config.Global.debug + self.log_level = self.command_line_config.Global.log_level except AttributeError: - pass # use class default - self.log("Default config loaded:", self.default_config) - self.log("Command line config loaded:", self.command_line_config) + pass # Use existing value which is set in Application.init_logger. + + self.log.debug("Command line config loaded:") + self.log.debug(repr(self.command_line_config)) def post_load_command_line_config(self): """Do actions just after loading the command line config.""" @@ -148,7 +169,7 @@ class Application(object): sys.path.append(os.path.abspath(self.ipythondir)) if not os.path.isdir(self.ipythondir): os.makedirs(self.ipythondir, mode = 0777) - self.log("IPYTHONDIR set to: %s" % self.ipythondir) + self.log.debug("IPYTHONDIR set to: %s" % self.ipythondir) def find_config_file_name(self): """Find the config file name for this application. @@ -187,18 +208,28 @@ class Application(object): ``CONFIG_FILE`` config variable is set to the resolved config file location. If not successful, an empty config is used. """ + self.log.debug("Attempting to load config file: <%s>" % self.config_file_name) loader = PyFileConfigLoader(self.config_file_name, path=self.config_file_paths) try: self.file_config = loader.load_config() self.file_config.Global.config_file = loader.full_filename except IOError: - self.log("Config file not found, skipping: %s" % \ - self.config_file_name) + self.log.warn("Config file not found, skipping: <%s>" % \ + self.config_file_name, exc_info=True) + self.file_config = Config() + except: + self.log.warn("Error loading config file: <%s>" % \ + self.config_file_name, exc_info=True) self.file_config = Config() else: - self.log("Config file loaded: %s" % loader.full_filename, - self.file_config) + self.log.debug("Config file loaded: <%s>" % loader.full_filename) + self.log.debug(repr(self.file_config)) + # We need to keeep self.log_level updated. + try: + self.log_level = self.file_config.Global.log_level + except AttributeError: + pass # Use existing value def post_load_file_config(self): """Do actions after the config file is loaded.""" @@ -211,7 +242,8 @@ class Application(object): config._merge(self.file_config) config._merge(self.command_line_config) self.master_config = config - self.log("Master config created:", self.master_config) + self.log.debug("Master config created:") + self.log.debug(repr(self.master_config)) def pre_construct(self): """Do actions after the config has been built, but before construct.""" @@ -219,7 +251,7 @@ class Application(object): def construct(self): """Construct the main components that make up this app.""" - self.log("Constructing components for application...") + self.log.debug("Constructing components for application") def post_construct(self): """Do actions after construct, but before starting the app.""" @@ -227,7 +259,7 @@ class Application(object): def start_app(self): """Actually start the app.""" - self.log("Starting application...") + self.log.debug("Starting application") #------------------------------------------------------------------------- # Utility methods @@ -235,11 +267,11 @@ class Application(object): def abort(self): """Abort the starting of the application.""" - print "Aborting application: ", self.name + self.log.critical("Aborting application: %s" % self.name, exc_info=True) sys.exit(1) def exit(self): - print "Exiting application: ", self.name + self.log.critical("Aborting application: %s" % self.name) sys.exit(1) def attempt(self, func, action='abort'): @@ -249,17 +281,7 @@ class Application(object): self.exit() except: if action == 'abort': - self.print_traceback() self.abort() elif action == 'exit': self.exit() - - def print_traceback(self): - print "Error in appliction startup: ", self.name - print - traceback.print_exc() - - def log(self, *args): - if self.debug: - for arg in args: - print "[%s] %s" % (self.name, arg) \ No newline at end of file + \ No newline at end of file diff --git a/IPython/core/builtin_trap.py b/IPython/core/builtin_trap.py index a05fc49..f528dbb 100644 --- a/IPython/core/builtin_trap.py +++ b/IPython/core/builtin_trap.py @@ -46,11 +46,9 @@ class BuiltinTrap(Component): @auto_attr def shell(self): - shell = Component.get_instances( + return Component.get_instances( root=self.root, - klass='IPython.core.iplib.InteractiveShell' - )[0] - return shell + klass='IPython.core.iplib.InteractiveShell')[0] def __enter__(self): if self._nested_level == 0: diff --git a/IPython/core/display_trap.py b/IPython/core/display_trap.py index ff41a81..2f9fc3b 100644 --- a/IPython/core/display_trap.py +++ b/IPython/core/display_trap.py @@ -48,11 +48,9 @@ class DisplayTrap(Component): @auto_attr def shell(self): - shell = Component.get_instances( + return Component.get_instances( root=self.root, - klass='IPython.core.iplib.InteractiveShell' - )[0] - return shell + klass='IPython.core.iplib.InteractiveShell')[0] def __enter__(self): if self._nested_level == 0: diff --git a/IPython/core/embed.py b/IPython/core/embed.py index bed686e..421c30c 100644 --- a/IPython/core/embed.py +++ b/IPython/core/embed.py @@ -64,10 +64,13 @@ class InteractiveShellEmbed(InteractiveShell): exit_msg = Str('') embedded = CBool(True) embedded_active = CBool(True) + # Like the base class display_banner is not configurable, but here it + # is True by default. + display_banner = CBool(True) def __init__(self, parent=None, config=None, ipythondir=None, usage=None, user_ns=None, user_global_ns=None, - banner1=None, banner2=None, + banner1=None, banner2=None, display_banner=None, custom_exceptions=((),None), exit_msg=''): self.save_sys_ipcompleter() @@ -75,7 +78,7 @@ class InteractiveShellEmbed(InteractiveShell): super(InteractiveShellEmbed,self).__init__( parent=parent, config=config, ipythondir=ipythondir, usage=usage, user_ns=user_ns, user_global_ns=user_global_ns, - banner1=banner1, banner2=banner2, + banner1=banner1, banner2=banner2, display_banner=display_banner, custom_exceptions=custom_exceptions) self.exit_msg = exit_msg @@ -148,23 +151,24 @@ class InteractiveShellEmbed(InteractiveShell): if self.has_readline: self.set_completer() - if self.banner and header: - format = '%s\n%s\n' - else: - format = '%s%s\n' - banner = format % (self.banner,header) + # self.banner is auto computed + if header: + self.old_banner2 = self.banner2 + self.banner2 = self.banner2 + '\n' + header + '\n' # Call the embedding code with a stack depth of 1 so it can skip over # our call and get the original caller's namespaces. - self.mainloop(banner, local_ns, global_ns, - stack_depth=stack_depth) + self.mainloop(local_ns, global_ns, stack_depth=stack_depth) + + self.banner2 = self.old_banner2 if self.exit_msg is not None: print self.exit_msg self.restore_sys_ipcompleter() - def mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0): + def mainloop(self, local_ns=None, global_ns=None, stack_depth=0, + display_banner=None): """Embeds IPython into a running python program. Input: @@ -221,7 +225,7 @@ class InteractiveShellEmbed(InteractiveShell): self.set_completer_frame() with nested(self.builtin_trap, self.display_trap): - self.interact(header) + self.interact(display_banner=display_banner) # now, purge out the user namespace from anything we might have added # from the caller's local namespace @@ -242,7 +246,7 @@ _embedded_shell = None def embed(header='', config=None, usage=None, banner1=None, banner2=None, - exit_msg=''): + display_banner=True, exit_msg=''): """Call this to embed IPython at the current point in your program. The first invocation of this will create an :class:`InteractiveShellEmbed` @@ -264,9 +268,13 @@ def embed(header='', config=None, usage=None, banner1=None, banner2=None, """ if config is None: config = load_default_config() + config.InteractiveShellEmbed = config.InteractiveShell global _embedded_shell if _embedded_shell is None: - _embedded_shell = InteractiveShellEmbed(config=config, - usage=usage, banner1=banner1, banner2=banner2, exit_msg=exit_msg) + _embedded_shell = InteractiveShellEmbed( + config=config, usage=usage, + banner1=banner1, banner2=banner2, + display_banner=display_banner, exit_msg=exit_msg + ) _embedded_shell(header=header, stack_depth=2) diff --git a/IPython/core/ipapp.py b/IPython/core/ipapp.py index 2c4ace6..a61abcf 100644 --- a/IPython/core/ipapp.py +++ b/IPython/core/ipapp.py @@ -23,6 +23,7 @@ Notes # Imports #----------------------------------------------------------------------------- +import logging import os import sys import warnings @@ -33,11 +34,12 @@ from IPython.core.iplib import InteractiveShell from IPython.config.loader import ( NoConfigDefault, Config, + ConfigError, PyFileConfigLoader ) from IPython.utils.ipstruct import Struct -from IPython.utils.genutils import get_ipython_dir +from IPython.utils.genutils import filefind, get_ipython_dir #----------------------------------------------------------------------------- # Utilities and helpers @@ -95,11 +97,11 @@ cl_args = ( help='Turn off auto editing of files with syntax errors.') ), (('-banner',), dict( - action='store_true', dest='InteractiveShell.display_banner', default=NoConfigDefault, + action='store_true', dest='Global.display_banner', default=NoConfigDefault, help='Display a banner upon starting IPython.') ), (('-nobanner',), dict( - action='store_false', dest='InteractiveShell.display_banner', default=NoConfigDefault, + action='store_false', dest='Global.display_banner', default=NoConfigDefault, help="Don't display a banner upon starting IPython.") ), (('-c',), dict( @@ -244,6 +246,11 @@ cl_args = ( help="Exception mode ('Plain','Context','Verbose')", metavar='InteractiveShell.xmode') ), + (('-ext',), dict( + type=str, dest='Global.extra_extension', default=NoConfigDefault, + help="The dotted module name of an IPython extension to load.", + metavar='Global.extra_extension') + ), # These are only here to get the proper deprecation warnings (('-pylab','-wthread','-qthread','-q4thread','-gthread'), dict( action='store_true', dest='Global.threaded_shell', default=NoConfigDefault, @@ -263,6 +270,14 @@ class IPythonApp(Application): name = 'ipython' config_file_name = _default_config_file_name + def create_default_config(self): + super(IPythonApp, self).create_default_config() + self.default_config.Global.display_banner=True + # Let the parent class set the default, but each time log_level + # changes from config, we need to update self.log_level as that is + # what updates the actual log level in self.log. + self.default_config.Global.log_level = self.log_level + def create_command_line_config(self): """Create and return a command line config loader.""" return IPythonAppCLConfigLoader( @@ -286,7 +301,12 @@ class IPythonApp(Application): super(IPythonApp, self).load_file_config() def post_load_file_config(self): - """Logic goes here.""" + if hasattr(self.command_line_config.Global, 'extra_extension'): + if not hasattr(self.file_config.Global, 'extensions'): + self.file_config.Global.extensions = [] + self.file_config.Global.extensions.append( + self.command_line_config.Global.extra_extension) + del self.command_line_config.Global.extra_extension def pre_construct(self): config = self.master_config @@ -318,17 +338,90 @@ class IPythonApp(Application): # I am a little hesitant to put these into InteractiveShell itself. # But that might be the place for them sys.path.insert(0, '') - # add personal ipythondir to sys.path so that users can put things in - # there for customization - sys.path.append(os.path.abspath(self.ipythondir)) - + # Create an InteractiveShell instance self.shell = InteractiveShell( parent=None, config=self.master_config ) - + + def post_construct(self): + """Do actions after construct, but before starting the app.""" + # shell.display_banner should always be False for the terminal + # based app, because we call shell.show_banner() by hand below + # so the banner shows *before* all extension loading stuff. + self.shell.display_banner = False + + if self.master_config.Global.display_banner: + self.shell.show_banner() + + # Make sure there is a space below the banner. + if self.log_level <= logging.INFO: print + + self._load_extensions() + self._run_exec_lines() + self._run_exec_files() + + def _load_extensions(self): + """Load all IPython extensions in Global.extensions. + + This uses the :meth:`InteractiveShell.load_extensions` to load all + the extensions listed in ``self.master_config.Global.extensions``. + """ + try: + if hasattr(self.master_config.Global, 'extensions'): + self.log.debug("Loading IPython extensions...") + extensions = self.master_config.Global.extensions + for ext in extensions: + try: + self.log.info("Loading IPython extension: %s" % ext) + self.shell.load_extension(ext) + except: + self.log.warn("Error in loading extension: %s" % ext) + self.shell.showtraceback() + except: + self.log.warn("Unknown error in loading extensions:") + self.shell.showtraceback() + + def _run_exec_lines(self): + """Run lines of code in Global.exec_lines in the user's namespace.""" + try: + if hasattr(self.master_config.Global, 'exec_lines'): + self.log.debug("Running code from Global.exec_lines...") + exec_lines = self.master_config.Global.exec_lines + for line in exec_lines: + try: + self.log.info("Running code in user namespace: %s" % line) + self.shell.runlines(line) + except: + self.log.warn("Error in executing line in user namespace: %s" % line) + self.shell.showtraceback() + except: + self.log.warn("Unknown error in handling Global.exec_lines:") + self.shell.showtraceback() + + def _run_exec_files(self): + try: + if hasattr(self.master_config.Global, 'exec_files'): + self.log.debug("Running files in Global.exec_files...") + exec_files = self.master_config.Global.exec_files + for fname in exec_files: + full_filename = filefind(fname, ['.', self.ipythondir]) + if os.path.isfile(full_filename): + if full_filename.endswith('.py'): + self.log.info("Running file in user namespace: %s" % full_filename) + self.shell.safe_execfile(full_filename, self.shell.user_ns) + elif full_filename.endswith('.ipy'): + self.log.info("Running file in user namespace: %s" % full_filename) + self.shell.safe_execfile_ipy(full_filename) + else: + self.log.warn("File does not have a .py or .ipy extension: <%s>" % full_filename) + except: + self.log.warn("Unknown error in handling Global.exec_files:") + self.shell.showtraceback() + def start_app(self): + self.log.debug("Starting IPython's mainloop...") self.shell.mainloop() diff --git a/IPython/core/iplib.py b/IPython/core/iplib.py index 811c958..58c526f 100644 --- a/IPython/core/iplib.py +++ b/IPython/core/iplib.py @@ -55,8 +55,9 @@ from IPython.utils.ipstruct import Struct from IPython.utils import PyColorize from IPython.utils.genutils import * from IPython.utils.genutils import get_ipython_dir -from IPython.utils.strdispatch import StrDispatch from IPython.utils.platutils import toggle_set_term_title, set_term_title +from IPython.utils.strdispatch import StrDispatch +from IPython.utils.syspathcontext import prepended_to_syspath # from IPython.utils import growl # growl.start("IPython") @@ -185,7 +186,6 @@ class InteractiveShell(Component, Magic): autoedit_syntax = CBool(False, config=True) autoindent = CBool(True, config=True) automagic = CBool(True, config=True) - display_banner = CBool(True, config=True) banner = Str('') banner1 = Str(default_banner, config=True) banner2 = Str('', config=True) @@ -197,6 +197,12 @@ class InteractiveShell(Component, Magic): confirm_exit = CBool(True, config=True) debug = CBool(False, config=True) deep_reload = CBool(False, config=True) + # This display_banner only controls whether or not self.show_banner() + # is called when mainloop/interact are called. The default is False + # because for the terminal based application, the banner behavior + # is controlled by Global.display_banner, which IPythonApp looks at + # to determine if *it* should call show_banner() by hand or not. + display_banner = CBool(False) # This isn't configurable! embedded = CBool(False) embedded_active = CBool(False) editor = Str(get_default_editor(), config=True) @@ -262,7 +268,7 @@ class InteractiveShell(Component, Magic): def __init__(self, parent=None, config=None, ipythondir=None, usage=None, user_ns=None, user_global_ns=None, - banner1=None, banner2=None, + banner1=None, banner2=None, display_banner=None, custom_exceptions=((),None)): # This is where traitlets with a config_key argument are updated @@ -274,7 +280,7 @@ class InteractiveShell(Component, Magic): self.init_instance_attrs() self.init_term_title() self.init_usage(usage) - self.init_banner(banner1, banner2) + self.init_banner(banner1, banner2, display_banner) # Create namespaces (user_ns, user_global_ns, etc.) self.init_create_namespaces(user_ns, user_global_ns) @@ -331,6 +337,12 @@ class InteractiveShell(Component, Magic): def _ipythondir_changed(self, name, new): if not os.path.isdir(new): os.makedirs(new, mode = 0777) + if not os.path.isdir(self.ipython_extension_dir): + os.makedirs(self.ipython_extension_dir, mode = 0777) + + @property + def ipython_extension_dir(self): + return os.path.join(self.ipythondir, 'extensions') @property def usable_screen_length(self): @@ -429,22 +441,6 @@ class InteractiveShell(Component, Magic): else: self.usage = usage - def init_banner(self, banner1, banner2): - if self.c: # regular python doesn't print the banner with -c - self.display_banner = False - if banner1 is not None: - self.banner1 = banner1 - if banner2 is not None: - self.banner2 = banner2 - self.compute_banner() - - def compute_banner(self): - self.banner = self.banner1 + '\n' - if self.profile: - self.banner += '\nIPython profile: %s\n' % self.profile - if self.banner2: - self.banner += '\n' + self.banner2 + '\n' - def init_encoding(self): # Get system encoding at startup time. Certain terminals (like Emacs # under Win32 have it set to None, and we need to have a known valid @@ -486,7 +482,7 @@ class InteractiveShell(Component, Magic): def init_logstart(self): if self.logplay: self.magic_logstart(self.logplay + ' append') - elif self.logfile: + elif self.logfile: self.magic_logstart(self.logfile) elif self.logstart: self.magic_logstart() @@ -532,6 +528,31 @@ class InteractiveShell(Component, Magic): warn("doctest module does not exist.") #------------------------------------------------------------------------- + # Things related to the banner + #------------------------------------------------------------------------- + + def init_banner(self, banner1, banner2, display_banner): + if banner1 is not None: + self.banner1 = banner1 + if banner2 is not None: + self.banner2 = banner2 + if display_banner is not None: + self.display_banner = display_banner + self.compute_banner() + + def show_banner(self, banner=None): + if banner is None: + banner = self.banner + self.write(banner) + + def compute_banner(self): + self.banner = self.banner1 + '\n' + if self.profile: + self.banner += '\nIPython profile: %s\n' % self.profile + if self.banner2: + self.banner += '\n' + self.banner2 + '\n' + + #------------------------------------------------------------------------- # Things related to injections into the sys module #------------------------------------------------------------------------- @@ -1673,7 +1694,7 @@ class InteractiveShell(Component, Magic): with nested(self.builtin_trap,): return eval(expr, self.user_global_ns, self.user_ns) - def mainloop(self, banner=None): + def mainloop(self, display_banner=None): """Start the mainloop. If an optional banner argument is given, it will override the @@ -1684,10 +1705,6 @@ class InteractiveShell(Component, Magic): if self.c: # Emulate Python's -c option self.exec_init_cmd() - if self.display_banner: - if banner is None: - banner = self.banner - # if you run stuff with -c , raw hist is not updated # ensure that it's in sync if len(self.input_hist) != len (self.input_hist_raw): @@ -1695,7 +1712,7 @@ class InteractiveShell(Component, Magic): while 1: try: - self.interact() + self.interact(display_banner=display_banner) #self.interact_with_readline() # XXX for testing of a readline-decoupled repl loop, call # interact_with_readline above @@ -1774,17 +1791,17 @@ class InteractiveShell(Component, Magic): line = raw_input_original().decode(self.stdin_encoding) self.interact_handle_input(line) - def interact(self, banner=None): + def interact(self, display_banner=None): """Closely emulate the interactive Python console.""" # batch run -> do not interact if self.exit_now: return - if self.display_banner: - if banner is None: - banner = self.banner - self.write(banner) + if display_banner is None: + display_banner = self.display_banner + if display_banner: + self.show_banner() more = 0 @@ -1856,128 +1873,45 @@ class InteractiveShell(Component, Magic): # We are off again... __builtin__.__dict__['__IPYTHON__active'] -= 1 - def safe_execfile(self,fname,*where,**kw): + def safe_execfile(self, fname, *where, **kw): """A safe version of the builtin execfile(). - This version will never throw an exception, and knows how to handle - ipython logs as well. + This version will never throw an exception, but instead print + helpful error messages to the screen. This only works on pure + Python files with the .py extension. - :Parameters: - fname : string - Name of the file to be executed. - - where : tuple + Parameters + ---------- + fname : string + The name of the file to be executed. + where : tuple One or two namespaces, passed to execfile() as (globals,locals). If only one is given, it is passed as both. + exit_ignore : bool (False) + If True, then don't print errors for non-zero exit statuses. + """ + kw.setdefault('exit_ignore', False) - :Keywords: - islog : boolean (False) - - quiet : boolean (True) + fname = os.path.abspath(os.path.expanduser(fname)) - exit_ignore : boolean (False) - """ + # Make sure we have a .py file + if not fname.endswith('.py'): + warn('File must end with .py to be run using execfile: <%s>' % fname) - def syspath_cleanup(): - """Internal cleanup routine for sys.path.""" - if add_dname: - try: - sys.path.remove(dname) - except ValueError: - # For some reason the user has already removed it, ignore. - pass - - fname = os.path.expanduser(fname) + # Make sure we can open the file + try: + with open(fname) as thefile: + pass + except: + warn('Could not open file <%s> for safe execution.' % fname) + return # Find things also in current directory. This is needed to mimic the # behavior of running a script from the system command line, where # Python inserts the script's directory into sys.path - dname = os.path.dirname(os.path.abspath(fname)) - add_dname = False - if dname not in sys.path: - sys.path.insert(0,dname) - add_dname = True - - try: - xfile = open(fname) - except: - print >> Term.cerr, \ - 'Could not open file <%s> for safe execution.' % fname - syspath_cleanup() - return None + dname = os.path.dirname(fname) - kw.setdefault('islog',0) - kw.setdefault('quiet',1) - kw.setdefault('exit_ignore',0) - - first = xfile.readline() - loghead = str(self.loghead_tpl).split('\n',1)[0].strip() - xfile.close() - # line by line execution - if first.startswith(loghead) or kw['islog']: - print 'Loading log file <%s> one line at a time...' % fname - if kw['quiet']: - stdout_save = sys.stdout - sys.stdout = StringIO.StringIO() - try: - globs,locs = where[0:2] - except: - try: - globs = locs = where[0] - except: - globs = locs = globals() - badblocks = [] - - # we also need to identify indented blocks of code when replaying - # logs and put them together before passing them to an exec - # statement. This takes a bit of regexp and look-ahead work in the - # file. It's easiest if we swallow the whole thing in memory - # first, and manually walk through the lines list moving the - # counter ourselves. - indent_re = re.compile('\s+\S') - xfile = open(fname) - filelines = xfile.readlines() - xfile.close() - nlines = len(filelines) - lnum = 0 - while lnum < nlines: - line = filelines[lnum] - lnum += 1 - # don't re-insert logger status info into cache - if line.startswith('#log#'): - continue - else: - # build a block of code (maybe a single line) for execution - block = line - try: - next = filelines[lnum] # lnum has already incremented - except: - next = None - while next and indent_re.match(next): - block += next - lnum += 1 - try: - next = filelines[lnum] - except: - next = None - # now execute the block of one or more lines - try: - exec block in globs,locs - except SystemExit: - pass - except: - badblocks.append(block.rstrip()) - if kw['quiet']: # restore stdout - sys.stdout.close() - sys.stdout = stdout_save - print 'Finished replaying log file <%s>' % fname - if badblocks: - print >> sys.stderr, ('\nThe following lines/blocks in file ' - '<%s> reported errors:' % fname) - - for badline in badblocks: - print >> sys.stderr, badline - else: # regular file execution + with prepended_to_syspath(dname): try: if sys.platform == 'win32' and sys.version_info < (2,5,1): # Work around a bug in Python for Windows. The bug was @@ -1997,7 +1931,7 @@ class InteractiveShell(Component, Magic): except SyntaxError: self.showsyntaxerror() warn('Failure executing file: <%s>' % fname) - except SystemExit,status: + except SystemExit, status: # Code that correctly sets the exit status flag to success (0) # shouldn't be bothered with a traceback. Note that a plain # sys.exit() does NOT set the message to 0 (it's empty) so that @@ -2005,13 +1939,8 @@ class InteractiveShell(Component, Magic): # SystemExit exception changed between Python 2.4 and 2.5, so # the checks must be done in a version-dependent way. show = False - - if sys.version_info[:2] > (2,5): - if status.message!=0 and not kw['exit_ignore']: - show = True - else: - if status.code and not kw['exit_ignore']: - show = True + if status.message!=0 and not kw['exit_ignore']: + show = True if show: self.showtraceback() warn('Failure executing file: <%s>' % fname) @@ -2019,46 +1948,82 @@ class InteractiveShell(Component, Magic): self.showtraceback() warn('Failure executing file: <%s>' % fname) - syspath_cleanup() + def safe_execfile_ipy(self, fname): + """Like safe_execfile, but for .ipy files with IPython syntax. + + Parameters + ---------- + fname : str + The name of the file to execute. The filename must have a + .ipy extension. + """ + fname = os.path.abspath(os.path.expanduser(fname)) + + # Make sure we have a .py file + if not fname.endswith('.ipy'): + warn('File must end with .py to be run using execfile: <%s>' % fname) + + # Make sure we can open the file + try: + with open(fname) as thefile: + pass + except: + warn('Could not open file <%s> for safe execution.' % fname) + return + + # Find things also in current directory. This is needed to mimic the + # behavior of running a script from the system command line, where + # Python inserts the script's directory into sys.path + dname = os.path.dirname(fname) + + with prepended_to_syspath(dname): + try: + with open(fname) as thefile: + script = thefile.read() + # self.runlines currently captures all exceptions + # raise in user code. It would be nice if there were + # versions of runlines, execfile that did raise, so + # we could catch the errors. + self.runlines(script, clean=True) + except: + self.showtraceback() + warn('Unknown failure executing file: <%s>' % fname) + + def _is_secondary_block_start(self, s): + if not s.endswith(':'): + return False + if (s.startswith('elif') or + s.startswith('else') or + s.startswith('except') or + s.startswith('finally')): + return True def cleanup_ipy_script(self, script): """Make a script safe for self.runlines() - Notes - ----- - This was copied over from the old ipapi and probably can be done - away with once we move to block based interpreter. - - - Removes empty lines Suffixes all indented blocks that end with - - unindented lines with empty lines + Currently, IPython is lines based, with blocks being detected by + empty lines. This is a problem for block based scripts that may + not have empty lines after blocks. This script adds those empty + lines to make scripts safe for running in the current line based + IPython. """ - res = [] lines = script.splitlines() - level = 0 + for l in lines: lstripped = l.lstrip() stripped = l.strip() if not stripped: continue - newlevel = len(l) - len(lstripped) - def is_secondary_block_start(s): - if not s.endswith(':'): - return False - if (s.startswith('elif') or - s.startswith('else') or - s.startswith('except') or - s.startswith('finally')): - return True - + newlevel = len(l) - len(lstripped) if level > 0 and newlevel == 0 and \ - not is_secondary_block_start(stripped): + not self._is_secondary_block_start(stripped): # add empty line res.append('') - res.append(l) level = newlevel + return '\n'.join(res) + '\n' def runlines(self, lines, clean=False): @@ -2091,7 +2056,8 @@ class InteractiveShell(Component, Magic): if line or more: # push to raw history, so hist line numbers stay in sync self.input_hist_raw.append("# " + line + "\n") - more = self.push_line(self.prefilter_manager.prefilter_lines(line,more)) + prefiltered = self.prefilter_manager.prefilter_lines(line,more) + more = self.push_line(prefiltered) # IPython's runsource returns None if there was an error # compiling the code. This allows us to stop processing right # away, so the user gets the error message at the right place. @@ -2304,7 +2270,7 @@ class InteractiveShell(Component, Magic): if line.strip(): if continue_prompt: self.input_hist_raw[-1] += '%s\n' % line - if self.has_readline: # and some config option is set? + if self.has_readline and self.readline_use: try: histlen = self.readline.get_current_history_length() if histlen > 1: @@ -2349,37 +2315,56 @@ class InteractiveShell(Component, Magic): # if batchrun and not self.interactive: # self.ask_exit() - # def load(self, mod): - # """ Load an extension. - # - # Some modules should (or must) be 'load()':ed, rather than just imported. - # - # Loading will do: - # - # - run init_ipython(ip) - # - run ipython_firstrun(ip) - # """ - # - # if mod in self.extensions: - # # just to make sure we don't init it twice - # # note that if you 'load' a module that has already been - # # imported, init_ipython gets run anyway - # - # return self.extensions[mod] - # __import__(mod) - # m = sys.modules[mod] - # if hasattr(m,'init_ipython'): - # m.init_ipython(self) - # - # if hasattr(m,'ipython_firstrun'): - # already_loaded = self.db.get('firstrun_done', set()) - # if mod not in already_loaded: - # m.ipython_firstrun(self) - # already_loaded.add(mod) - # self.db['firstrun_done'] = already_loaded - # - # self.extensions[mod] = m - # return m + #------------------------------------------------------------------------- + # IPython extensions + #------------------------------------------------------------------------- + + def load_extension(self, module_str): + """Load an IPython extension. + + An IPython extension is an importable Python module that has + a function with the signature:: + + def load_in_ipython(ipython): + # Do things with ipython + + This function is called after your extension is imported and the + currently active :class:`InteractiveShell` instance is passed as + the only argument. You can do anything you want with IPython at + that point, including defining new magic and aliases, adding new + components, etc. + + You can put your extension modules anywhere you want, as long as + they can be imported by Python's standard import mechanism. However, + to make it easy to write extensions, you can also put your extensions + in ``os.path.join(self.ipythondir, 'extensions')``. This directory + is added to ``sys.path`` automatically. + """ + from IPython.utils.syspathcontext import prepended_to_syspath + + if module_str in sys.modules: + return + + with prepended_to_syspath(self.ipython_extension_dir): + __import__(module_str) + mod = sys.modules[module_str] + self._call_load_in_ipython(mod) + + def reload_extension(self, module_str): + """Reload an IPython extension by doing reload.""" + from IPython.utils.syspathcontext import prepended_to_syspath + + with prepended_to_syspath(self.ipython_extension_dir): + if module_str in sys.modules: + mod = sys.modules[module_str] + reload(mod) + self._call_load_in_ipython(mod) + else: + self.load_extension(self, module_str) + + def _call_load_in_ipython(self, mod): + if hasattr(mod, 'load_in_ipython'): + mod.load_in_ipython(self) #------------------------------------------------------------------------- # Things related to the prefilter diff --git a/IPython/core/magic.py b/IPython/core/magic.py index 9d33b97..678e2b0 100644 --- a/IPython/core/magic.py +++ b/IPython/core/magic.py @@ -1573,7 +1573,7 @@ Currently the magic system has the following functions:\n""" return if filename.lower().endswith('.ipy'): - self.runlines(open(filename).read(), clean=True) + self.safe_execfile_ipy(filename) return # Control the response to exit() calls made by the script being run @@ -1743,25 +1743,6 @@ Currently the magic system has the following functions:\n""" return stats - def magic_runlog(self, parameter_s =''): - """Run files as logs. - - Usage:\\ - %runlog file1 file2 ... - - Run the named files (treating them as log files) in sequence inside - the interpreter, and return to the prompt. This is much slower than - %run because each line is executed in a try/except block, but it - allows running files with syntax errors in them. - - Normally IPython will guess when a file is one of its own logfiles, so - you can typically use %run even for logs. This shorthand allows you to - force any file to be treated as a log file.""" - - for f in parameter_s.split(): - self.shell.safe_execfile(f,self.shell.user_ns, - self.shell.user_ns,islog=1) - @testdec.skip_doctest def magic_timeit(self, parameter_s =''): """Time execution of a Python statement or expression diff --git a/IPython/core/page.py b/IPython/core/page.py index 7de15af..f07c1b5 100644 --- a/IPython/core/page.py +++ b/IPython/core/page.py @@ -127,12 +127,14 @@ def page(strng,start=0,screen_lines=0,pager_cmd = None): # auto-determine screen size if screen_lines <= 0: - if TERM=='xterm': + if TERM=='xterm' or TERM=='xterm-color': use_curses = USE_CURSES else: # curses causes problems on many terminals other than xterm. use_curses = False if use_curses: + import termios + import curses # There is a bug in curses, where *sometimes* it fails to properly # initialize, and then after the endwin() call is made, the # terminal is left in an unusable state. Rather than trying to diff --git a/IPython/core/prefilter.py b/IPython/core/prefilter.py index fd994a1..91983eb 100644 --- a/IPython/core/prefilter.py +++ b/IPython/core/prefilter.py @@ -32,6 +32,7 @@ from IPython.core.alias import AliasManager from IPython.core.autocall import IPyAutocall from IPython.core.component import Component from IPython.core.splitinput import split_user_input +from IPython.core.page import page from IPython.utils.traitlets import List, Int, Any, Str, CBool from IPython.utils.genutils import make_quoted_expr @@ -183,11 +184,9 @@ class PrefilterManager(Component): @auto_attr def shell(self): - shell = Component.get_instances( + return Component.get_instances( root=self.root, - klass='IPython.core.iplib.InteractiveShell' - )[0] - return shell + klass='IPython.core.iplib.InteractiveShell')[0] def init_checkers(self): self._checkers = [] @@ -319,11 +318,9 @@ class PrefilterChecker(Component): @auto_attr def shell(self): - shell = Component.get_instances( + return Component.get_instances( root=self.root, - klass='IPython.core.iplib.InteractiveShell' - )[0] - return shell + klass='IPython.core.iplib.InteractiveShell')[0] @auto_attr def prefilter_manager(self): @@ -523,11 +520,9 @@ class PrefilterHandler(Component): @auto_attr def shell(self): - shell = Component.get_instances( + return Component.get_instances( root=self.root, - klass='IPython.core.iplib.InteractiveShell' - )[0] - return shell + klass='IPython.core.iplib.InteractiveShell')[0] @auto_attr def prefilter_manager(self): diff --git a/IPython/utils/syspathcontext.py b/IPython/utils/syspathcontext.py new file mode 100644 index 0000000..65f202e --- /dev/null +++ b/IPython/utils/syspathcontext.py @@ -0,0 +1,67 @@ +#!/usr/bin/env python +# encoding: utf-8 +""" +Context managers for adding things to sys.path temporarily. + +Authors: + +* Brian Granger +""" + +#----------------------------------------------------------------------------- +# Copyright (C) 2008-2009 The IPython Development Team +# +# Distributed under the terms of the BSD License. The full license is in +# the file COPYING, distributed as part of this software. +#----------------------------------------------------------------------------- + +#----------------------------------------------------------------------------- +# Imports +#----------------------------------------------------------------------------- + + +import sys + +class appended_to_syspath(object): + """A context for appending a directory to sys.path for a second.""" + + def __init__(self, dir): + self.dir = dir + + def __enter__(self): + if self.dir not in sys.path: + sys.path.append(self.dir) + self.added = True + else: + self.added = False + + def __exit__(self, type, value, traceback): + if self.added: + try: + sys.path.remove(self.dir) + except ValueError: + pass + # Returning False causes any exceptions to be re-raised. + return False + +class prepended_to_syspath(object): + """A context for prepending a directory to sys.path for a second.""" + + def __init__(self, dir): + self.dir = dir + + def __enter__(self): + if self.dir not in sys.path: + sys.path.insert(0,self.dir) + self.added = True + else: + self.added = False + + def __exit__(self, type, value, traceback): + if self.added: + try: + sys.path.remove(self.dir) + except ValueError: + pass + # Returning False causes any exceptions to be re-raised. + return False