ipython · ellisonbg · May 25, 2012 · Mar 23, 2012 · Mar 23, 2012 · Mar 23, 2012
diff --git a/IPython/config/application.py b/IPython/config/application.py
@@ -132,6 +132,30 @@ def _log_level_changed(self, name, old, new):
             new = getattr(logging, new)
             self.log_level = new
         self.log.setLevel(new)
+
+    log_format = Unicode("[%(name)s] %(message)s", config=True,
+        help="The Logging format template",
+    )
+    log = Instance(logging.Logger)
+    def _log_default(self):
+        """Start logging for this application.
+
+        The default is to log to stdout using a StreaHandler. The log level
+        starts at loggin.WARN, but this can be adjusted by setting the
+        ``log_level`` attribute.
+        """
+        log = logging.getLogger(self.__class__.__name__)
+        log.setLevel(self.log_level)
+        if sys.executable.endswith('pythonw.exe'):
+            # this should really go to a file, but file-logging is only
+            # hooked up in parallel applications
+            _log_handler = logging.StreamHandler(open(os.devnull, 'w'))
+        else:
+            _log_handler = logging.StreamHandler()
+        _log_formatter = logging.Formatter(self.log_format)
+        _log_handler.setFormatter(_log_formatter)
+        log.addHandler(_log_handler)
+        return log
 
     # the alias map for configurables
     aliases = Dict({'log-level' : 'Application.log_level'})
@@ -169,32 +193,11 @@ def __init__(self, **kwargs):
         if self.__class__ not in self.classes:
             self.classes.insert(0, self.__class__)
 
-        self.init_logging()
-
     def _config_changed(self, name, old, new):
         SingletonConfigurable._config_changed(self, name, old, new)
         self.log.debug('Config changed:')
         self.log.debug(repr(new))
 
-    def init_logging(self):
-        """Start logging for this application.
-
-        The default is to log to stdout using a StreaHandler. The log level
-        starts at loggin.WARN, but this can be adjusted by setting the
-        ``log_level`` attribute.
-        """
-        self.log = logging.getLogger(self.__class__.__name__)
-        self.log.setLevel(self.log_level)
-        if sys.executable.endswith('pythonw.exe'):
-            # this should really go to a file, but file-logging is only
-            # hooked up in parallel applications
-            self._log_handler = logging.StreamHandler(open(os.devnull, 'w'))
-        else:
-            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)
-
     @catch_config_error
     def initialize(self, argv=None):
         """Do the basic steps to configure me.

diff --git a/IPython/core/history.py b/IPython/core/history.py
@@ -403,8 +403,9 @@ def __init__(self, shell=None, config=None, **traits):
         self.save_flag = threading.Event()
         self.db_input_cache_lock = threading.Lock()
         self.db_output_cache_lock = threading.Lock()
-        self.save_thread = HistorySavingThread(self)
-        self.save_thread.start()
+        if self.hist_file != ':memory:':
+            self.save_thread = HistorySavingThread(self)
+            self.save_thread.start()
 
         self.new_session()
 

diff --git a/IPython/core/interactiveshell.py b/IPython/core/interactiveshell.py
@@ -717,6 +717,7 @@ def save_sys_module_state(self):
         self._orig_sys_module_state['stderr'] = sys.stderr
         self._orig_sys_module_state['excepthook'] = sys.excepthook
         self._orig_sys_modules_main_name = self.user_module.__name__
+        self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
 
     def restore_sys_module_state(self):
         """Restore the state of the sys module."""
@@ -726,7 +727,8 @@ def restore_sys_module_state(self):
         except AttributeError:
             pass
         # Reset what what done in self.init_sys_modules
-        sys.modules[self.user_module.__name__] = self._orig_sys_modules_main_name
+        if self._orig_sys_modules_main_mod is not None:
+            sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
 
     #-------------------------------------------------------------------------
     # Things related to hooks
@@ -2429,7 +2431,7 @@ def safe_run_module(self, mod_name, where):
             self.showtraceback()
             warn('Unknown failure executing module: <%s>' % mod_name)
 
-    def run_cell(self, raw_cell, store_history=False):
+    def run_cell(self, raw_cell, store_history=False, silent=False):
         """Run a complete IPython cell.
 
         Parameters
@@ -2440,9 +2442,15 @@ def run_cell(self, raw_cell, store_history=False):
           If True, the raw and translated cell will be stored in IPython's
           history. For user code calling back into IPython's machinery, this
           should be set to False.
+        silent : bool
+          If True, avoid side-effets, such as implicit displayhooks, history,
+          and logging.  silent=True forces store_history=False.
         """
         if (not raw_cell) or raw_cell.isspace():
             return
+
+        if silent:
+            store_history = False
 
         for line in raw_cell.splitlines():
             self.input_splitter.push(line)
@@ -2467,8 +2475,8 @@ def run_cell(self, raw_cell, store_history=False):
             if store_history:
                 self.history_manager.store_inputs(self.execution_count,
                                                   cell, raw_cell)
-
-            self.logger.log(cell, raw_cell)
+            if not silent:
+                self.logger.log(cell, raw_cell)
 
             if not prefilter_failed:
                 # don't run if prefilter failed
@@ -2488,12 +2496,16 @@ def run_cell(self, raw_cell, store_history=False):
                         if store_history:
                             self.execution_count += 1
                         return None
-
+
+                    interactivity = "none" if silent else "last_expr"
                     self.run_ast_nodes(code_ast.body, cell_name,
-                                       interactivity="last_expr")
-
+                                       interactivity=interactivity)
+                    
                     # Execute any registered post-execution functions.
-                    for func, status in self._post_execute.iteritems():
+                    # unless we are silent
+                    post_exec = [] if silent else self._post_execute.iteritems()
+
+                    for func, status in post_exec:
                         if self.disable_failing_post_execute and not status:
                             continue
                         try:

diff --git a/IPython/core/tests/test_interactiveshell.py b/IPython/core/tests/test_interactiveshell.py
@@ -254,6 +254,61 @@ def test_bad_var_expand(self):
         self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
         # ZeroDivisionError
         self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
+
+    def test_silent_nopostexec(self):
+        """run_cell(silent=True) doesn't invoke post-exec funcs"""
+        ip = get_ipython()
+
+        d = dict(called=False)
+        def set_called():
+            d['called'] = True
+
+        ip.register_post_execute(set_called)
+        ip.run_cell("1", silent=True)
+        self.assertFalse(d['called'])
+        # double-check that non-silent exec did what we expected
+        # silent to avoid
+        ip.run_cell("1")
+        self.assertTrue(d['called'])
+        # remove post-exec
+        ip._post_execute.pop(set_called)
+
+    def test_silent_noadvance(self):
+        """run_cell(silent=True) doesn't advance execution_count"""
+        ip = get_ipython()
+
+        ec = ip.execution_count
+        # silent should force store_history=False
+        ip.run_cell("1", store_history=True, silent=True)
+
+        self.assertEquals(ec, ip.execution_count)
+        # double-check that non-silent exec did what we expected
+        # silent to avoid
+        ip.run_cell("1", store_history=True)
+        self.assertEquals(ec+1, ip.execution_count)
+
+    def test_silent_nodisplayhook(self):
+        """run_cell(silent=True) doesn't trigger displayhook"""
+        ip = get_ipython()
+
+        d = dict(called=False)
+
+        trap = ip.display_trap
+        save_hook = trap.hook
+
+        def failing_hook(*args, **kwargs):
+            d['called'] = True
+
+        try:
+            trap.hook = failing_hook
+            ip.run_cell("1", silent=True)
+            self.assertFalse(d['called'])
+            # double-check that non-silent exec did what we expected
+            # silent to avoid
+            ip.run_cell("1")
+            self.assertTrue(d['called'])
+        finally:
+            trap.hook = save_hook
 
     @skipif(sys.version_info[0] >= 3, "softspace removed in py3")
     def test_print_softspace(self):

diff --git a/IPython/extensions/parallelmagic.py b/IPython/extensions/parallelmagic.py
@@ -211,7 +211,7 @@ def _maybe_display_output(self, result):
                 print '[stdout:%i]'%eid, stdout
 
 
-    def pxrun_cell(self, raw_cell, store_history=True):
+    def pxrun_cell(self, raw_cell, store_history=False, silent=False):
         """drop-in replacement for InteractiveShell.run_cell.
 
         This executes code remotely, instead of in the local namespace.
@@ -258,7 +258,7 @@ def pxrun_cell(self, raw_cell, store_history=True):
             return False
         else:
             try:
-                result = self.active_view.execute(cell, block=False)
+                result = self.active_view.execute(cell, silent=False, block=False)
             except:
                 ipself.showtraceback()
                 return True

diff --git a/IPython/frontend/consoleapp.py b/IPython/frontend/consoleapp.py
@@ -140,8 +140,6 @@ class IPythonConsoleApp(Configurable):
     frontend_flags = Any(app_flags)
     frontend_aliases = Any(app_aliases)
 
-    pure = CBool(False, config=True,
-        help="Use a pure Python kernel instead of an IPython kernel.")
     # create requested profiles by default, if they don't exist:
     auto_create = CBool(True)
     # connection info:
@@ -330,9 +328,7 @@ def init_kernel_manager(self):
         )
         # start the kernel
         if not self.existing:
-            kwargs = dict(ipython=not self.pure)
-            kwargs['extra_arguments'] = self.kernel_argv
-            self.kernel_manager.start_kernel(**kwargs)
+            self.kernel_manager.start_kernel(extra_arguments=self.kernel_argv)
         elif self.sshserver:
             # ssh, write new connection file
             self.kernel_manager.write_connection_file()

diff --git a/IPython/frontend/html/notebook/clustermanager.py b/IPython/frontend/html/notebook/clustermanager.py
@@ -45,8 +45,6 @@ class DummyIPClusterStart(IPClusterStart):
 
     def init_signal(self):
         pass
-    def init_logging(self):
-        pass
     def reinit_logging(self):
         pass
 

diff --git a/IPython/frontend/html/notebook/handlers.py b/IPython/frontend/html/notebook/handlers.py
@@ -30,6 +30,7 @@
 from IPython.external.decorator import decorator
 from IPython.zmq.session import Session
 from IPython.lib.security import passwd_check
+from IPython.utils.jsonutil import date_default
 
 try:
     from docutils.core import publish_string
@@ -385,13 +386,13 @@ def _reserialize_reply(self, msg_list):
         except KeyError:
             pass
         msg.pop('buffers')
-        return jsonapi.dumps(msg)
+        return jsonapi.dumps(msg, default=date_default)
 
     def _on_zmq_reply(self, msg_list):
         try:
             msg = self._reserialize_reply(msg_list)
-        except:
-            self.application.log.critical("Malformed message: %r" % msg_list)
+        except Exception:
+            self.application.log.critical("Malformed message: %r" % msg_list, exc_info=True)
         else:
             self.write_message(msg)
 

diff --git a/IPython/frontend/html/notebook/notebookapp.py b/IPython/frontend/html/notebook/notebookapp.py
@@ -390,7 +390,6 @@ def init_configurables(self):
         self.cluster_manager.update_profiles()
 
     def init_logging(self):
-        super(NotebookApp, self).init_logging()
         # This prevents double log messages because tornado use a root logger that
         # self.log is a child of. The logging module dipatches log messages to a log
         # and all of its ancenstors until propagate is set to False.
@@ -493,6 +492,7 @@ def _signal_stop(self, sig, frame):
 
     @catch_config_error
     def initialize(self, argv=None):
+        self.init_logging()
         super(NotebookApp, self).initialize(argv)
         self.init_configurables()
         self.init_webapp()

diff --git a/IPython/frontend/qt/console/qtconsoleapp.py b/IPython/frontend/qt/console/qtconsoleapp.py
@@ -101,9 +101,7 @@ def gui_excepthook(exctype, value, tb):
 # start with copy of flags
 flags = dict(flags)
 qt_flags = {
-    'pure' : ({'IPythonQtConsoleApp' : {'pure' : True}},
-            "Use a pure Python kernel instead of an IPython kernel."),
-    'plain' : ({'ConsoleWidget' : {'kind' : 'plain'}},
+    'plain' : ({'IPythonQtConsoleApp' : {'plain' : True}},
             "Disable rich text support."),
 }
 qt_flags.update(boolean_flag(
@@ -180,18 +178,14 @@ class IPythonQtConsoleApp(BaseIPythonApplication, IPythonConsoleApp):
     plain = CBool(False, config=True,
         help="Use a plaintext widget instead of rich text (plain can't print/save).")
 
-    def _pure_changed(self, name, old, new):
-        kind = 'plain' if self.plain else 'rich'
+    def _plain_changed(self, name, old, new):
+        kind = 'plain' if new else 'rich'
         self.config.ConsoleWidget.kind = kind
-        if self.pure:
-            self.widget_factory = FrontendWidget
-        elif self.plain:
+        if new:
             self.widget_factory = IPythonWidget
         else:
             self.widget_factory = RichIPythonWidget
 
-    _plain_changed = _pure_changed
-
     # the factory for creating a widget
     widget_factory = Any(RichIPythonWidget)
 
@@ -210,7 +204,7 @@ def new_frontend_master(self):
                                 config=self.config,
         )
         # start the kernel
-        kwargs = dict(ipython=not self.pure)
+        kwargs = dict()
         kwargs['extra_arguments'] = self.kernel_argv
         kernel_manager.start_kernel(**kwargs)
         kernel_manager.start_channels()
@@ -273,17 +267,13 @@ def init_qt_elements(self):
         self.window.add_tab_with_frontend(self.widget)
         self.window.init_menu_bar()
 
-        self.window.setWindowTitle('Python' if self.pure else 'IPython')
+        self.window.setWindowTitle('IPython')
 
     def init_colors(self, widget):
         """Configure the coloring of the widget"""
         # Note: This will be dramatically simplified when colors
         # are removed from the backend.
 
-        if self.pure:
-            # only IPythonWidget supports styling
-            return
-
         # parse the colors arg down to current known labels
         try:
             colors = self.config.ZMQInteractiveShell.colors

diff --git a/IPython/lib/kernel.py b/IPython/lib/kernel.py
@@ -46,11 +46,11 @@ def get_connection_file(app=None):
         If unspecified, the currently running app will be used
     """
     if app is None:
-        from IPython.zmq.kernelapp import KernelApp
-        if not KernelApp.initialized():
+        from IPython.zmq.ipkernel import IPKernelApp
+        if not IPKernelApp.initialized():
             raise RuntimeError("app not specified, and not in a running Kernel")
 
-        app = KernelApp.instance()
+        app = IPKernelApp.instance()
     return filefind(app.connection_file, ['.', app.profile_dir.security_dir])
 
 def find_connection_file(filename, profile=None):
-Original file line number
+Diff line change
@@ Expand Up / @@ -45,8 +45,6 @@ class DummyIPClusterStart(IPClusterStart): @@
         def init_signal(self):
             pass
-        def init_logging(self):
-            pass
         def reinit_logging(self):
             pass
@@ Expand Down @@