Refactoring the notebook app to support the new config system.

IPython/frontend/html/notebook/kernelmanager.py

@@ -1,179 +1,186 b''
 """A kernel manager for multiple kernels."""
 
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
 import logging
 import signal
 import sys
 import uuid
 
 import zmq
 
 from IPython.config.configurable import Configurable
 from IPython.zmq.ipkernel import launch_kernel
 from IPython.utils.traitlets import Instance, Dict, Unicode
 
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
 
 class DuplicateKernelError(Exception):
     pass
 
 
 class KernelManager(Configurable):
     """A class for managing multiple kernels."""
 
     context = Instance('zmq.Context')
     def _context_default(self):
         return zmq.Context.instance()
 
     logname = Unicode('')
     def _logname_changed(self, name, old, new):
         self.log = logging.getLogger(new)
 
     _kernels = Dict()
 
     @property
     def kernel_ids(self):
         """Return a list of the kernel ids of the active kernels."""
         return self._kernels.keys()
 
     def __len__(self):
         """Return the number of running kernels."""
         return len(self.kernel_ids)
 
     def __contains__(self, kernel_id):
         if kernel_id in self.kernel_ids:
             return True
         else:
             return False
 
     def start_kernel(self, **kwargs):
         """Start a new kernel."""
         kernel_id = str(uuid.uuid4())
         (process, shell_port, iopub_port, stdin_port, hb_port) = launch_kernel(**kwargs)
         # Store the information for contacting the kernel. This assumes the kernel is
         # running on localhost.
         d = dict(
             process = process,
             stdin_port = stdin_port,
             iopub_port = iopub_port,
             shell_port = shell_port,
             hb_port = hb_port,
             ip = '127.0.0.1'
         )
         self._kernels[kernel_id] = d
         return kernel_id
 
     def kill_kernel(self, kernel_id):
         """Kill a kernel by its kernel uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to kill.
         """
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             # Attempt to kill the kernel.
             try:
                 kernel_process.kill()
             except OSError, e:
                 # In Windows, we will get an Access Denied error if the process
                 # has already terminated. Ignore it.
                 if not (sys.platform == 'win32' and e.winerror == 5):
                     raise
             del self._kernels[kernel_id]
 
     def interrupt_kernel(self, kernel_id):
         """Interrupt (SIGINT) the kernel by its uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to interrupt.
         """
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             if sys.platform == 'win32':
                 from parentpoller import ParentPollerWindows as Poller
                 Poller.send_interrupt(kernel_process.win32_interrupt_event)
             else:
                 kernel_process.send_signal(signal.SIGINT)
 
     def signal_kernel(self, kernel_id, signum):
         """ Sends a signal to the kernel by its uuid.
 
         Note that since only SIGTERM is supported on Windows, this function
         is only useful on Unix systems.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to signal.
         """
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             kernel_process.send_signal(signum)
 
     def get_kernel_process(self, kernel_id):
         """Get the process object for a kernel by its uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
         """
         d = self._kernels.get(kernel_id)
         if d is not None:
             return d['process']
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_kernel_ports(self, kernel_id):
         """Return a dictionary of ports for a kernel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         port_dict : dict
             A dict of key, value pairs where the keys are the names
             (stdin_port,iopub_port,shell_port) and the values are the
             integer port numbers for those channels.
         """
         d = self._kernels.get(kernel_id)
         if d is not None:
             dcopy = d.copy()
             dcopy.pop('process')
             dcopy.pop('ip')
             return dcopy
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_kernel_ip(self, kernel_id):
         """Return ip address for a kernel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         ip : str
             The ip address of the kernel.
         """
         d = self._kernels.get(kernel_id)
         if d is not None:
             return d['ip']
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def create_session_manager(self, kernel_id):
         """Create a new session manager for a kernel by its uuid."""
         from sessionmanager import SessionManager
         return SessionManager(
             kernel_id=kernel_id, kernel_manager=self, 
             config=self.config, context=self.context, logname=self.logname
         )
 

IPython/frontend/html/notebook/notebookapp.py

@@ -1,131 +1,220 b''
+"""A tornado based IPython notebook server."""
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
 import logging
 import os
 
 import zmq
 
 # Install the pyzmq ioloop. This has to be done before anything else from
 # tornado is imported.
 from zmq.eventloop import ioloop
 import tornado.ioloop
 tornado.ioloop = ioloop
 
 from tornado import httpserver
 from tornado import options
 from tornado import web
 
 from kernelmanager import KernelManager
+from sessionmanager import SessionManager
 from handlers import (
     MainHandler, KernelHandler, KernelActionHandler, ZMQStreamHandler,
     NotebookRootHandler, NotebookHandler
 )
 from routers import IOPubStreamRouter, ShellStreamRouter
 
-options.define("port", default=8888, help="run on the given port", type=int)
+from IPython.core.application import BaseIPythonApplication
+from IPython.zmq.session import Session
+
+#-----------------------------------------------------------------------------
+# Module globals
+#-----------------------------------------------------------------------------
 
 _kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
 _kernel_action_regex = r"(?P<action>restart|interrupt)"
 
-
+#-----------------------------------------------------------------------------
+# The Tornado web application
+#-----------------------------------------------------------------------------
 
 class NotebookWebApplication(web.Application):
 
-    def __init__(self):
+    def __init__(self, kernel_manager, log):
         handlers = [
             (r"/", MainHandler),
             (r"/kernels", KernelHandler),
             (r"/kernels/%s/%s" % (_kernel_id_regex, _kernel_action_regex), KernelActionHandler),
             (r"/kernels/%s/iopub" % _kernel_id_regex, ZMQStreamHandler, dict(stream_name='iopub')),
             (r"/kernels/%s/shell" % _kernel_id_regex, ZMQStreamHandler, dict(stream_name='shell')),
             (r"/notebooks", NotebookRootHandler),
             (r"/notebooks/([^/]+)", NotebookHandler)
         ]
         settings = dict(
             template_path=os.path.join(os.path.dirname(__file__), "templates"),
             static_path=os.path.join(os.path.dirname(__file__), "static"),
         )
         web.Application.__init__(self, handlers, **settings)
 
-        self.context = zmq.Context()
-        self.kernel_manager = KernelManager(self.context)
-        self._session_dict = {}
+        self.kernel_manager = kernel_manager
+        self.log = log
         self._routers = {}
 
     #-------------------------------------------------------------------------
     # Methods for managing kernels and sessions
     #-------------------------------------------------------------------------
 
     @property
     def kernel_ids(self):
         return self.kernel_manager.kernel_ids
 
     def start_kernel(self):
+        # TODO: pass command line options to the kernel in start_kernel()
         kernel_id = self.kernel_manager.start_kernel()
-        logging.info("Kernel started: %s" % kernel_id)
-        self.start_session(kernel_id)
+        self.log.info("Kernel started: %s" % kernel_id)
+        self.start_session_manager(kernel_id)
         return kernel_id
 
+    def start_session_manager(self, kernel_id):
+        sm = self.kernel_manager.create_session_manager(kernel_id)
+        self._session_dict[kernel_id] = sm
+        iopub_stream = sm.get_iopub_stream()
+        shell_stream = sm.get_shell_stream()
+        iopub_router = IOPubStreamRouter(iopub_stream)
+        shell_router = ShellStreamRouter(shell_stream)
+        self._routers[(kernel_id, 'iopub')] = iopub_router
+        self._routers[(kernel_id, 'shell')] = shell_router
+        self.log.debug("Session manager started for kernel: %s" % kernel_id)
+
+    def kill_kernel(self, kernel_id):
+        sm = self._session_dict.pop(kernel_id)
+        sm.stop()
+        self.kernel_manager.kill_kernel(kernel_id)
+        self.log.info("Kernel killed: %s" % kernel_id)
+
     def interrupt_kernel(self, kernel_id):
         self.kernel_manager.interrupt_kernel(kernel_id)
-        logging.info("Kernel interrupted: %s" % kernel_id)
+        self.log.debug("Kernel interrupted: %s" % kernel_id)
 
     def restart_kernel(self, kernel_id):
         # Create the new kernel first so we can move the clients over.
         new_kernel_id = self.start_kernel()
 
         # Copy the clients over to the new routers.
         old_iopub_router = self.get_router(kernel_id, 'iopub')
         old_shell_router = self.get_router(kernel_id, 'shell')
         new_iopub_router = self.get_router(new_kernel_id, 'iopub')
         new_shell_router = self.get_router(new_kernel_id, 'shell')
         new_iopub_router.copy_clients(old_iopub_router)
         new_shell_router.copy_clients(old_shell_router)
 
         # Now shutdown the old session and the kernel.
         # TODO: This causes a hard crash in ZMQStream.close, which sets
         # self.socket to None to hastily. We will need to fix this in PyZMQ
         # itself. For now, we just leave the old kernel running :(
-        # sm = self.kernel_manager.get_session_manager(kernel_id)
-        # session_id = self._session_dict[kernel_id]
-        # sm.stop_session(session_id)
-        # self.kernel_manager.kill_kernel(kernel_id)
+        # self.kill_kernel(kernel_id)
 
-        logging.info("Kernel restarted")
+        self.log.debug("Kernel restarted: %s -> %s" % (kernel_id, new_kernel_id))
         return new_kernel_id
 
-    def start_session(self, kernel_id):
-        sm = self.kernel_manager.get_session_manager(kernel_id)
-        session_id = sm.start_session()
-        self._session_dict[kernel_id] = session_id
-        iopub_stream = sm.get_iopub_stream(session_id)
-        shell_stream = sm.get_shell_stream(session_id)
-        iopub_router = IOPubStreamRouter(iopub_stream)
-        shell_router = ShellStreamRouter(shell_stream)
-        self._routers[(kernel_id, session_id, 'iopub')] = iopub_router
-        self._routers[(kernel_id, session_id, 'shell')] = shell_router
-        logging.info("Session started: %s, %s" % (kernel_id, session_id))
-
-    def stop_session(self, kernel_id):
-        # TODO: finish this!
-        sm = self.kernel_manager.get_session_manager(kernel_id)
-        session_id = self._session_dict[kernel_id]
-
     def get_router(self, kernel_id, stream_name):
-        session_id = self._session_dict[kernel_id]
-        router = self._routers[(kernel_id, session_id, stream_name)]
+        router = self._routers[(kernel_id, stream_name)]
         return router
 
+#-----------------------------------------------------------------------------
+# Aliases and Flags
+#-----------------------------------------------------------------------------
+
+flags = dict(ipkernel_flags)
+
+# the flags that are specific to the frontend
+# these must be scrubbed before being passed to the kernel,
+# or it will raise an error on unrecognized flags
+notebook_flags = []
+
+aliases = dict(ipkernel_aliases)
+
+aliases.update(dict(
+    ip = 'IPythonNotebookApp.ip',
+    port = 'IPythonNotebookApp.port'
+    colors = 'ZMQInteractiveShell.colors',
+    editor = 'IPythonWidget.editor',
+))
+
+#-----------------------------------------------------------------------------
+# IPythonNotebookApp
+#-----------------------------------------------------------------------------
+
+class IPythonNotebookApp(BaseIPythonApplication):
+    name = 'ipython-notebook'
+    default_config_file_name='ipython_notebook_config.py'
+    
+    description = """
+        The IPython HTML Notebook.
+        
+        This launches a Tornado based HTML Notebook Server that serves up an
+        HTML5/Javascript Notebook client.
+    """
+    
+    classes = [IPKernelApp, ZMQInteractiveShell, ProfileDir, Session,
+               KernelManager, SessionManager]
+    flags = Dict(flags)
+    aliases = Dict(aliases)
+
+    kernel_argv = List(Unicode)
+
+    # connection info:
+    ip = Unicode(LOCALHOST, config=True,
+        help="The IP address the notebook server will listen on."
+    )
+
+    port = Int(8888, config=True,
+        help="The port the notebook server will listen on."
+    )
+
+    # the factory for creating a widget
+    widget_factory = Any(RichIPythonWidget)
+
+    def parse_command_line(self, argv=None):
+        super(IPythonNotebookApp, self).parse_command_line(argv)
+        if argv is None:
+            argv = sys.argv[1:]
+
+        self.kernel_argv = list(argv) # copy
+        # kernel should inherit default config file from frontend
+        self.kernel_argv.append("KernelApp.parent_appname='%s'"%self.name)
+        # scrub frontend-specific flags
+        for a in argv:
+            if a.startswith('--') and a[2:] in qt_flags:
+                self.kernel_argv.remove(a)
+
+    def init_kernel_manager(self):
+        # Don't let Qt or ZMQ swallow KeyboardInterupts.
+        signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+        # Create a KernelManager and start a kernel.
+        self.kernel_manager = KernelManager(config=self.config, log=self.log)
+
+    def initialize(self, argv=None):
+        super(IPythonNotebookApp, self).initialize(argv)
+        self.init_kernel_mananger()
+        self.web_app = NotebookWebApplication()
+        self.http_server = httpserver.HTTPServer(self.web_app)
+        self.http_server.listen(self.port)
+
+    def start(self):
+        self.log.info("The IPython Notebook is running at: http://%s:%i" % (self.ip, self.port))
+        ioloop.IOLoop.instance().start()
+
+#-----------------------------------------------------------------------------
+# Main entry point
+#-----------------------------------------------------------------------------
 
 def launch_new_instance():
-    options.parse_command_line()
-    application = NotebookWebApplication()
-    http_server = httpserver.HTTPServer(application)
-    http_server.listen(options.options.port)
-    print "IPython Notebook running at: http://127.0.0.1:8888"
-    print "The github master of tornado is required to run this server:"
-    print "    https://github.com/facebook/tornado/tree/master/tornado"
-    ioloop.IOLoop.instance().start()
-
-
-if __name__ == "__main__":
-    main()
+    app = IPythonNotebookApp()
+    app.initialize()
+    app.start()
 

IPython/frontend/html/notebook/sessionmanager.py

@@ -1,75 +1,83 b''
 """A manager for session and channels for a single kernel."""
 
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
 import zmq
 from zmq.eventloop.zmqstream import ZMQStream
 
 from IPython.utils.traitlets import Instance, Dict, CBytes, Bool
 from IPython.zmq.session import SessionFactory
 
 
 class SessionManagerRunningError(Exception):
     pass
 
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
 
 class SessionManager(SessionFactory):
     """Manages a session for a kernel.
 
     The object manages a variety of things for a connection session to
     a running kernel:
 
     * The set of channels or connected ZMQ streams to the kernel.
     * An IPython.zmq.session.Session object that manages send/recv logic
       for those channels.
     """
 
     kernel_manager = Instance('IPython.frontend.html.notebook.kernelmanager.KernelManager')
     kernel_id = CBytes(b'')
     _session_streams = Dict()
     _running = Bool(False)
 
     def __init__(self, **kwargs):
         kernel_id = kwargs.pop('kernel_id')
         super(SessionManager, self).__init__(**kwargs)
         self.kernel_id = kernel_id
         self.start()
 
     def __del__(self):
         self.stop()
 
     def start(self):
         if not self._running:
             ports = self.kernel_manager.get_kernel_ports(self.kernel_id)
             iopub_stream = self.create_connected_stream(ports['iopub_port'], zmq.SUB)
             iopub_stream.socket.setsockopt(zmq.SUBSCRIBE, b'')
             shell_stream = self.create_connected_stream(ports['shell_port'], zmq.XREQ)
             self._session_streams = dict(
                 iopub_stream = iopub_stream,
                 shell_stream = shell_stream
             )
             self._running = True
         else:
             raise SessionManagerRunningError(
                 'Session manager is already running, call stop() before start()'
             )
 
     def stop(self):
         if self._running:
             for name, stream in self._session_streams.items():
                 stream.close()
             self._session_streams = {}
             self._running = False
 
     def create_connected_stream(self, port, socket_type):
         sock = self.context.socket(socket_type)
         addr = "tcp://%s:%i" % (self.kernel_manager.get_kernel_ip(self.kernel_id), port)
         self.log.info("Connecting to: %s, %r" % (addr, socket_type))
         sock.connect(addr)
         return ZMQStream(sock)
 
     def get_iopub_stream(self):
         return self._session_streams['iopub_stream']
 
     def get_shell_stream(self):
         return self._session_streams['shell_stream']
 
 

IPython/frontend/html/notebook/tests/test_kernelsession.py

@@ -1,38 +1,39 b''
+"""Tests for the notebook kernel and session manager."""
 
 from unittest import TestCase
 
 from IPython.frontend.html.notebook.kernelmanager import KernelManager
 from IPython.frontend.html.notebook.sessionmanager import SessionManagerRunningError
 
 class TestKernelManager(TestCase):
 
     def test_km_lifecycle(self):
         km = KernelManager()
         kid = km.start_kernel()
         self.assert_(kid in km)
         self.assertEquals(len(km),1)
         km.kill_kernel(kid)
         self.assert_(not kid in km)
 
         kid = km.start_kernel()
         self.assertEquals('127.0.0.1',km.get_kernel_ip(kid))
         port_dict = km.get_kernel_ports(kid)
         self.assert_('stdin_port' in port_dict)
         self.assert_('iopub_port' in port_dict)
         self.assert_('shell_port' in port_dict)
         self.assert_('hb_port' in port_dict)
         km.get_kernel_process(kid)
 
     def test_session_manager(self):
         km = KernelManager()
         kid = km.start_kernel()
         sm = km.create_session_manager(kid)
         self.assert_(sm._running)
         sm.stop()
         self.assert_(not sm._running)
         sm.start()
         self.assertRaises(SessionManagerRunningError, sm.start)
         sm.get_iopub_stream()
         sm.get_shell_stream()
         sm.session
 

IPython/frontend/terminal/ipapp.py

@@ -1,374 +1,377 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 The :class:`~IPython.core.application.Application` object for the command
 line :command:`ipython` program.
 
 Authors
 -------
 
 * Brian Granger
 * Fernando Perez
 * Min Ragan-Kelley
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2010  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
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 import logging
 import os
 import sys
 
 from IPython.config.loader import (
     Config, PyFileConfigLoader
 )
 from IPython.config.application import boolean_flag
 from IPython.core import release
 from IPython.core import usage
 from IPython.core.crashhandler import CrashHandler
 from IPython.core.formatters import PlainTextFormatter
 from IPython.core.application import (
     ProfileDir, BaseIPythonApplication, base_flags, base_aliases
 )
 from IPython.core.shellapp import (
     InteractiveShellApp, shell_flags, shell_aliases
 )
 from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
 from IPython.lib import inputhook
 from IPython.utils import warn
 from IPython.utils.path import get_ipython_dir, check_for_old_config
 from IPython.utils.traitlets import (
     Bool, Dict, CaselessStrEnum
 )
 
 #-----------------------------------------------------------------------------
 # Globals, utilities and helpers
 #-----------------------------------------------------------------------------
 
 #: The default config file name for this application.
 default_config_file_name = u'ipython_config.py'
 
 _examples = """
 ipython --pylab            # start in pylab mode
 ipython --pylab=qt         # start in pylab mode with the qt4 backend
 ipython --log-level=DEBUG  # set logging to DEBUG
 ipython --profile=foo      # start with profile foo
 
 ipython qtconsole          # start the qtconsole GUI application
 ipython qtconsole -h       # show the help string for the qtconsole subcmd
 
 ipython profile create foo # create profile foo w/ default config files
 ipython profile -h         # show the help string for the profile subcmd
 """
 
 #-----------------------------------------------------------------------------
 # Crash handler for this application
 #-----------------------------------------------------------------------------
 
 class IPAppCrashHandler(CrashHandler):
     """sys.excepthook for IPython itself, leaves a detailed report on disk."""
 
     def __init__(self, app):
         contact_name = release.authors['Fernando'][0]
         contact_email = release.authors['Fernando'][1]
         bug_tracker = 'http://github.com/ipython/ipython/issues'
         super(IPAppCrashHandler,self).__init__(
             app, contact_name, contact_email, bug_tracker
         )
 
     def make_report(self,traceback):
         """Return a string containing a crash report."""
 
         sec_sep = self.section_sep
         # Start with parent report
         report = [super(IPAppCrashHandler, self).make_report(traceback)]
         # Add interactive-specific info we may have
         rpt_add = report.append
         try:
             rpt_add(sec_sep+"History of session input:")
             for line in self.app.shell.user_ns['_ih']:
                 rpt_add(line)
             rpt_add('\n*** Last line of input (may not be in above history):\n')
             rpt_add(self.app.shell._last_input_line+'\n')
         except:
             pass
 
         return ''.join(report)
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 flags = dict(base_flags)
 flags.update(shell_flags)
 addflag = lambda *args: flags.update(boolean_flag(*args))
 addflag('autoedit-syntax', 'TerminalInteractiveShell.autoedit_syntax',
         'Turn on auto editing of files with syntax errors.',
         'Turn off auto editing of files with syntax errors.'
 )
 addflag('banner', 'TerminalIPythonApp.display_banner',
         "Display a banner upon starting IPython.",
         "Don't display a banner upon starting IPython."
 )
 addflag('confirm-exit', 'TerminalInteractiveShell.confirm_exit',
     """Set to confirm when you try to exit IPython with an EOF (Control-D
     in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
     you can force a direct exit without any confirmation.""",
     "Don't prompt the user when exiting."
 )
 addflag('term-title', 'TerminalInteractiveShell.term_title',
     "Enable auto setting the terminal title.",
     "Disable auto setting the terminal title."
 )
 classic_config = Config()
 classic_config.InteractiveShell.cache_size = 0
 classic_config.PlainTextFormatter.pprint = False
 classic_config.InteractiveShell.prompt_in1 = '>>> '
 classic_config.InteractiveShell.prompt_in2 = '... '
 classic_config.InteractiveShell.prompt_out = ''
 classic_config.InteractiveShell.separate_in = ''
 classic_config.InteractiveShell.separate_out = ''
 classic_config.InteractiveShell.separate_out2 = ''
 classic_config.InteractiveShell.colors = 'NoColor'
 classic_config.InteractiveShell.xmode = 'Plain'
 
 flags['classic']=(
     classic_config,
     "Gives IPython a similar feel to the classic Python prompt."
 )
 # # log doesn't make so much sense this way anymore
 # paa('--log','-l',
 #     action='store_true', dest='InteractiveShell.logstart',
 #     help="Start logging to the default log file (./ipython_log.py).")
 #
 # # quick is harder to implement
 flags['quick']=(
     {'TerminalIPythonApp' : {'quick' : True}},
     "Enable quick startup with no config files."
 )
 
 flags['i'] = (
     {'TerminalIPythonApp' : {'force_interact' : True}},
     """If running code from the command line, become interactive afterwards.
     Note: can also be given simply as '-i.'"""
 )
 flags['pylab'] = (
     {'TerminalIPythonApp' : {'pylab' : 'auto'}},
     """Pre-load matplotlib and numpy for interactive use with
     the default matplotlib backend."""
 )
 
 aliases = dict(base_aliases)
 aliases.update(shell_aliases)
 
 # it's possible we don't want short aliases for *all* of these:
 aliases.update(dict(
     gui='TerminalIPythonApp.gui',
     pylab='TerminalIPythonApp.pylab',
 ))
 
 #-----------------------------------------------------------------------------
 # Main classes and functions
 #-----------------------------------------------------------------------------
 
 class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):
     name = u'ipython'
     description = usage.cl_usage
     default_config_file_name = default_config_file_name
     crash_handler_class = IPAppCrashHandler
     examples = _examples
 
     flags = Dict(flags)
     aliases = Dict(aliases)
     classes = [InteractiveShellApp, TerminalInteractiveShell, ProfileDir,
                PlainTextFormatter]
     subcommands = Dict(dict(
         qtconsole=('IPython.frontend.qt.console.qtconsoleapp.IPythonQtConsoleApp',
             """Launch the IPython Qt Console."""
         ),
+        hotebook=('IPython.frontend.html.notebook.notebookapp.IPythonNotebookApp',
+            """Launch the IPython HTML Notebook Server"""
+        ),
         profile = ("IPython.core.profileapp.ProfileApp",
             "Create and manage IPython profiles.")
     ))
     
     # *do* autocreate requested profile, but don't create the config file.
     auto_create=Bool(True)
     # configurables
     ignore_old_config=Bool(False, config=True,
         help="Suppress warning messages about legacy config files"
     )
     quick = Bool(False, config=True,
         help="""Start IPython quickly by skipping the loading of config files."""
     )
     def _quick_changed(self, name, old, new):
         if new:
             self.load_config_file = lambda *a, **kw: None
             self.ignore_old_config=True
 
     gui = CaselessStrEnum(('qt','wx','gtk'), config=True,
         help="Enable GUI event loop integration ('qt', 'wx', 'gtk')."
     )
     pylab = CaselessStrEnum(['tk', 'qt', 'wx', 'gtk', 'osx', 'auto'],
         config=True,
         help="""Pre-load matplotlib and numpy for interactive use,
         selecting a particular matplotlib backend and loop integration.
         """
     )
     display_banner = Bool(True, config=True,
         help="Whether to display a banner upon starting IPython."
     )
 
     # if there is code of files to run from the cmd line, don't interact
     # unless the --i flag (App.force_interact) is true.
     force_interact = Bool(False, config=True,
         help="""If a command or file is given via the command-line,
         e.g. 'ipython foo.py"""
     )
     def _force_interact_changed(self, name, old, new):
         if new:
             self.interact = True
     
     def _file_to_run_changed(self, name, old, new):
         if new and not self.force_interact:
                 self.interact = False
     _code_to_run_changed = _file_to_run_changed
 
     # internal, not-configurable
     interact=Bool(True)
 
 
     def parse_command_line(self, argv=None):
         """override to allow old '-pylab' flag with deprecation warning"""
 
         argv = sys.argv[1:] if argv is None else argv
 
         if '-pylab' in argv:
             # deprecated `-pylab` given,
             # warn and transform into current syntax
             argv = argv[:] # copy, don't clobber
             idx = argv.index('-pylab')
             warn.warn("`-pylab` flag has been deprecated.\n"
             "    Use `--pylab` instead, or `--pylab=foo` to specify a backend.")
             sub = '--pylab'
             if len(argv) > idx+1:
                 # check for gui arg, as in '-pylab qt'
                 gui = argv[idx+1]
                 if gui in ('wx', 'qt', 'qt4', 'gtk', 'auto'):
                     sub = '--pylab='+gui
                     argv.pop(idx+1)
             argv[idx] = sub
         
         return super(TerminalIPythonApp, self).parse_command_line(argv)
 
     def initialize(self, argv=None):
         """Do actions after construct, but before starting the app."""
         super(TerminalIPythonApp, self).initialize(argv)
         if self.subapp is not None:
             # don't bother initializing further, starting subapp
             return
         if not self.ignore_old_config:
             check_for_old_config(self.ipython_dir)
         # print self.extra_args
         if self.extra_args:
             self.file_to_run = self.extra_args[0]
         # create the shell
         self.init_shell()
         # and draw the banner
         self.init_banner()
         # Now a variety of things that happen after the banner is printed.
         self.init_gui_pylab()
         self.init_extensions()
         self.init_code()
 
     def init_shell(self):
         """initialize the InteractiveShell instance"""
         # I am a little hesitant to put these into InteractiveShell itself.
         # But that might be the place for them
         sys.path.insert(0, '')
 
         # Create an InteractiveShell instance.
         # 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 = TerminalInteractiveShell.instance(config=self.config,
                         display_banner=False, profile_dir=self.profile_dir,
                         ipython_dir=self.ipython_dir)
 
     def init_banner(self):
         """optionally display the banner"""
         if self.display_banner and self.interact:
             self.shell.show_banner()
         # Make sure there is a space below the banner.
         if self.log_level <= logging.INFO: print
 
 
     def init_gui_pylab(self):
         """Enable GUI event loop integration, taking pylab into account."""
         gui = self.gui
 
         # Using `pylab` will also require gui activation, though which toolkit
         # to use may be chosen automatically based on mpl configuration.
         if self.pylab:
             activate = self.shell.enable_pylab
             if self.pylab == 'auto':
                 gui = None
             else:
                 gui = self.pylab
         else:
             # Enable only GUI integration, no pylab
             activate = inputhook.enable_gui
 
         if gui or self.pylab:
             try:
                 self.log.info("Enabling GUI event loop integration, "
                               "toolkit=%s, pylab=%s" % (gui, self.pylab) )
                 activate(gui)
             except:
                 self.log.warn("Error in enabling GUI event loop integration:")
                 self.shell.showtraceback()
 
     def start(self):
         if self.subapp is not None:
             return self.subapp.start()
         # perform any prexec steps:
         if self.interact:
             self.log.debug("Starting IPython's mainloop...")
             self.shell.mainloop()
         else:
             self.log.debug("IPython not interactive...")
 
 
 def load_default_config(ipython_dir=None):
     """Load the default config file from the default ipython_dir.
 
     This is useful for embedded shells.
     """
     if ipython_dir is None:
         ipython_dir = get_ipython_dir()
     profile_dir = os.path.join(ipython_dir, 'profile_default')
     cl = PyFileConfigLoader(default_config_file_name, profile_dir)
     try:
         config = cl.load_config()
     except IOError:
         # no config found
         config = Config()
     return config
 
 
 def launch_new_instance():
     """Create and run a full blown IPython instance"""
     app = TerminalIPythonApp.instance()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     launch_new_instance()