upstream/ipython Commit - r5359:80e7338b

Merge branch 'logout_button' of https://github.com/stefanv/ipython into stefanv-logout_button...

Fernando Perez -

r5359:80e7338b

parent child

IPython/frontend/html/notebook/templates/layout.html

0 created 644 +77 0

@@ -0,0 +1,77 b''
	1	<!DOCTYPE HTML>
	2	<html>
	3
	4	<head>
	5	<meta charset="utf-8">
	6
	7	<title>{% block title %}IPython Notebook{% end %}</title>
	8
	9	<link rel="stylesheet" href="static/jquery/css/themes/aristo/jquery-wijmo.css" type="text/css" />
	10	<link rel="stylesheet" href="static/css/boilerplate.css" type="text/css" />
	11	<link rel="stylesheet" href="static/css/layout.css" type="text/css" />
	12	<link rel="stylesheet" href="static/css/base.css" type="text/css"/>
	13	{% block stylesheet %}
	14	{% end %}
	15
	16	{% block meta %}
	17	{% end %}
	18
	19	</head>
	20
	21	<body {% block params %}{% end %}>
	22
	23	<div id="header">
	24	<span id="ipython_notebook"><h1>IPython Notebook</h1></span>
	25	<span id="login_widget">
	26	{% if current_user and current_user != 'anonymous' %}
	27	<button id="logout">Logout</button>
	28	{% end %}
	29	</span>
	30	{% block header %}
	31	{% end %}
	32	</div>
	33
	34	<div id="header_border"></div>
	35
	36	<div id="main_app">
	37
	38	<div id="app_hbox">
	39
	40	<div id="left_panel">
	41	{% block left_panel %}
	42	{% end %}
	43	</div>
	44
	45	<div id="content_panel">
	46	{% if message %}
	47
	48	{% for key in message %}
	49	<div class="message {{key}}">
	50	{{message[key]}}
	51	</div>
	52	{% end %}
	53	{% end %}
	54
	55	{% block content_panel %}
	56	{% end %}
	57	</div>
	58	<div id="right_panel">
	59	{% block right_panel %}
	60	{% end %}
	61	</div>
	62
	63	</div>
	64
	65	</div>
	66
	67	<script src="static/jquery/js/jquery-1.6.2.min.js" type="text/javascript" charset="utf-8"></script>
	68	<script src="static/jquery/js/jquery-ui-1.8.14.custom.min.js" type="text/javascript" charset="utf-8"></script>
	69	<script src="static/js/namespace.js" type="text/javascript" charset="utf-8"></script>
	70	<script src="static/js/loginmain.js" type="text/javascript" charset="utf-8"></script>
	71	<script src="static/js/loginwidget.js" type="text/javascript" charset="utf-8"></script>
	72	{% block script %}
	73	{% end %}
	74
	75	</body>
	76
	77	</html>

IPython/frontend/html/notebook/templates/logout.html

0 created 644 +5 0

@@ -0,0 +1,5 b''
	1	{% extends layout.html %}
	2
	3	{% block content_panel %}
	4	Proceed to the <a href="/login">login page</a>.
	5	{% end %}

IPython/frontend/html/notebook/handlers.py

0 +21 -4

             """Tornado handlers for the notebook.
             Authors:
             * Brian Granger
             """
             #-----------------------------------------------------------------------------
             #  Copyright (C) 2008-2011  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 logging
             import Cookie
             import uuid
             from tornado import web
             from tornado import websocket
             from zmq.eventloop import ioloop
             from zmq.utils import jsonapi
             from IPython.external.decorator import decorator
             from IPython.zmq.session import Session
             from IPython.lib.security import passwd_check
             try:
                 from docutils.core import publish_string
             except ImportError:
                 publish_string = None
             #-----------------------------------------------------------------------------
             # Monkeypatch for Tornado <= 2.1.1 - Remove when no longer necessary!
             #-----------------------------------------------------------------------------
             # Google Chrome, as of release 16, changed its websocket protocol number.  The
             # parts tornado cares about haven't really changed, so it's OK to continue
             # accepting Chrome connections, but as of Tornado 2.1.1 (the currently released
             # version as of Oct 30/2011) the version check fails, see the issue report:
             # https://github.com/facebook/tornado/issues/385
             # This issue has been fixed in Tornado post 2.1.1:
             # https://github.com/facebook/tornado/commit/84d7b458f956727c3b0d6710
             # Here we manually apply the same patch as above so that users of IPython can
             # continue to work with an officially released Tornado.  We make the
             # monkeypatch version check as narrow as possible to limit its effects; once
             # Tornado 2.1.1 is no longer found in the wild we'll delete this code.
             import tornado
             if tornado.version_info <= (2,1,1):
                 def _execute(self, transforms, *args, **kwargs):
                     from tornado.websocket import WebSocketProtocol8, WebSocketProtocol76
                     self.open_args = args
                     self.open_kwargs = kwargs
                     # The difference between version 8 and 13 is that in 8 the
                     # client sends a "Sec-Websocket-Origin" header and in 13 it's
                     # simply "Origin".
                     if self.request.headers.get("Sec-WebSocket-Version") in ("7", "8", "13"):
                         self.ws_connection = WebSocketProtocol8(self)
                         self.ws_connection.accept_connection()
                     elif self.request.headers.get("Sec-WebSocket-Version"):
                         self.stream.write(tornado.escape.utf8(
                             "HTTP/1.1 426 Upgrade Required\r\n"
                             "Sec-WebSocket-Version: 8\r\n\r\n"))
                         self.stream.close()
                     else:
                         self.ws_connection = WebSocketProtocol76(self)
                         self.ws_connection.accept_connection()
                 websocket.WebSocketHandler._execute = _execute
                 del _execute
             #-----------------------------------------------------------------------------
             # Decorator for disabling read-only handlers
             #-----------------------------------------------------------------------------
             @decorator
             def not_if_readonly(f, self, *args, **kwargs):
                 if self.application.read_only:
                     raise web.HTTPError(403, "Notebook server is read-only")
                 else:
                     return f(self, *args, **kwargs)
             @decorator
             def authenticate_unless_readonly(f, self, *args, **kwargs):
                 """authenticate this page *unless* readonly view is active.
                 In read-only mode, the notebook list and print view should
                 be accessible without authentication.
                 """
                 @web.authenticated
                 def auth_f(self, *args, **kwargs):
                     return f(self, *args, **kwargs)
                 if self.application.read_only:
                     return f(self, *args, **kwargs)
                 else:
                     return auth_f(self, *args, **kwargs)
             #-----------------------------------------------------------------------------
             # Top-level handlers
             #-----------------------------------------------------------------------------
-            class AuthenticatedHandler(web.RequestHandler):
+            class RequestHandler(web.RequestHandler):
+                """RequestHandler with default variable setting."""
+                def render(*args, **kwargs):
+                    kwargs.setdefault('message', '')
+                    return web.RequestHandler.render(*args, **kwargs)
+            class AuthenticatedHandler(RequestHandler):
                 """A RequestHandler with an authenticated user."""
                 def get_current_user(self):
                     user_id = self.get_secure_cookie("username")
                     # For now the user_id should not return empty, but it could eventually
                     if user_id == '':
                         user_id = 'anonymous'
                     if user_id is None:
                         # prevent extra Invalid cookie sig warnings:
                         self.clear_cookie('username')
                         if not self.application.password and not self.application.read_only:
                             user_id = 'anonymous'
                     return user_id
                 @property
                 def read_only(self):
                     if self.application.read_only:
                         if self.application.password:
                             return self.get_current_user() is None
                         else:
                             return True
                     else:
                         return False
                 @property
                 def ws_url(self):
                     """websocket url matching the current request
                     turns http[s]://host[:port] into
                             ws[s]://host[:port]
                     """
                     proto = self.request.protocol.replace('http', 'ws')
                     return "%s://%s" % (proto, self.request.host)
             class ProjectDashboardHandler(AuthenticatedHandler):
                 @authenticate_unless_readonly
                 def get(self):
                     nbm = self.application.notebook_manager
                     project = nbm.notebook_dir
                     self.render(
                         'projectdashboard.html', project=project,
                         base_project_url=u'/', base_kernel_url=u'/',
                         read_only=self.read_only,
                     )
             class LoginHandler(AuthenticatedHandler):
-                def _render(self, message=''):
+                def _render(self, message=None):
                     self.render('login.html',
                             next=self.get_argument('next', default='/'),
                             read_only=self.read_only,
                             message=message
                     )
                 def get(self):
-                    self._render()
+                    if self.current_user:
+                        self.redirect(self.get_argument('next', default='/'))
+                    else:
+                        self._render()
                 def post(self):
                     pwd = self.get_argument('password', default=u'')
                     if self.application.password:
                         if passwd_check(self.application.password, pwd):
                             self.set_secure_cookie('username', str(uuid.uuid4()))
                         else:
-                            self._render(message='Invalid password')
+                            self._render(message={'error': 'Invalid password'})
                             return
                     self.redirect(self.get_argument('next', default='/'))
+            class LogoutHandler(AuthenticatedHandler):
+                def get(self):
+                    self.clear_cookie('username')
+                    self.render('logout.html', message={'info': 'Successfully logged out.'})
             class NewHandler(AuthenticatedHandler):
                 @web.authenticated
                 def get(self):
                     nbm = self.application.notebook_manager
                     project = nbm.notebook_dir
                     notebook_id = nbm.new_notebook()
                     self.render(
                         'notebook.html', project=project,
                         notebook_id=notebook_id,
                         base_project_url=u'/', base_kernel_url=u'/',
                         kill_kernel=False,
                         read_only=False,
                     )
             class NamedNotebookHandler(AuthenticatedHandler):
                 @authenticate_unless_readonly
                 def get(self, notebook_id):
                     nbm = self.application.notebook_manager
                     project = nbm.notebook_dir
                     if not nbm.notebook_exists(notebook_id):
                         raise web.HTTPError(404, u'Notebook does not exist: %s' % notebook_id)
                     self.render(
                         'notebook.html', project=project,
                         notebook_id=notebook_id,
                         base_project_url=u'/', base_kernel_url=u'/',
                         kill_kernel=False,
                         read_only=self.read_only,
                     )
             #-----------------------------------------------------------------------------
             # Kernel handlers
             #-----------------------------------------------------------------------------
             class MainKernelHandler(AuthenticatedHandler):
                 @web.authenticated
                 def get(self):
                     km = self.application.kernel_manager
                     self.finish(jsonapi.dumps(km.kernel_ids))
                 @web.authenticated
                 def post(self):
                     km = self.application.kernel_manager
                     notebook_id = self.get_argument('notebook', default=None)
                     kernel_id = km.start_kernel(notebook_id)
                     data = {'ws_url':self.ws_url,'kernel_id':kernel_id}
                     self.set_header('Location', '/'+kernel_id)
                     self.finish(jsonapi.dumps(data))
             class KernelHandler(AuthenticatedHandler):
                 SUPPORTED_METHODS = ('DELETE')
                 @web.authenticated
                 def delete(self, kernel_id):
                     km = self.application.kernel_manager
                     km.kill_kernel(kernel_id)
                     self.set_status(204)
                     self.finish()
             class KernelActionHandler(AuthenticatedHandler):
                 @web.authenticated
                 def post(self, kernel_id, action):
                     km = self.application.kernel_manager
                     if action == 'interrupt':
                         km.interrupt_kernel(kernel_id)
                         self.set_status(204)
                     if action == 'restart':
                         new_kernel_id = km.restart_kernel(kernel_id)
                         data = {'ws_url':self.ws_url,'kernel_id':new_kernel_id}
                         self.set_header('Location', '/'+new_kernel_id)
                         self.write(jsonapi.dumps(data))
                     self.finish()
             class ZMQStreamHandler(websocket.WebSocketHandler):
                 def _reserialize_reply(self, msg_list):
                     """Reserialize a reply message using JSON.
                     This takes the msg list from the ZMQ socket, unserializes it using
                     self.session and then serializes the result using JSON. This method
                     should be used by self._on_zmq_reply to build messages that can
                     be sent back to the browser.
                     """
                     idents, msg_list = self.session.feed_identities(msg_list)
                     msg = self.session.unserialize(msg_list)
                     try:
                         msg['header'].pop('date')
                     except KeyError:
                         pass
                     try:
                         msg['parent_header'].pop('date')
                     except KeyError:
                         pass
                     msg.pop('buffers')
                     return jsonapi.dumps(msg)
                 def _on_zmq_reply(self, msg_list):
                     try:
                         msg = self._reserialize_reply(msg_list)
                     except:
                         self.application.log.critical("Malformed message: %r" % msg_list)
                     else:
                         self.write_message(msg)
             class AuthenticatedZMQStreamHandler(ZMQStreamHandler):
                 def open(self, kernel_id):
                     self.kernel_id = kernel_id.decode('ascii')
                     try:
                         cfg = self.application.ipython_app.config
                     except AttributeError:
                         # protect from the case where this is run from something other than
                         # the notebook app:
                         cfg = None
                     self.session = Session(config=cfg)
                     self.save_on_message = self.on_message
                     self.on_message = self.on_first_message
                 def get_current_user(self):
                     user_id = self.get_secure_cookie("username")
                     if user_id == '' or (user_id is None and not self.application.password):
                         user_id = 'anonymous'
                     return user_id
                 def _inject_cookie_message(self, msg):
                     """Inject the first message, which is the document cookie,
                     for authentication."""
                     if isinstance(msg, unicode):
                         # Cookie can't constructor doesn't accept unicode strings for some reason
                         msg = msg.encode('utf8', 'replace')
                     try:
                         self.request._cookies = Cookie.SimpleCookie(msg)
                     except:
                         logging.warn("couldn't parse cookie string: %s",msg, exc_info=True)
                 def on_first_message(self, msg):
                     self._inject_cookie_message(msg)
                     if self.get_current_user() is None:
                         logging.warn("Couldn't authenticate WebSocket connection")
                         raise web.HTTPError(403)
                     self.on_message = self.save_on_message
             class IOPubHandler(AuthenticatedZMQStreamHandler):
                 def initialize(self, *args, **kwargs):
                     self._kernel_alive = True
                     self._beating = False
                     self.iopub_stream = None
                     self.hb_stream = None
                 def on_first_message(self, msg):
                     try:
                         super(IOPubHandler, self).on_first_message(msg)
                     except web.HTTPError:
                         self.close()
                         return
                     km = self.application.kernel_manager
                     self.time_to_dead = km.time_to_dead
                     kernel_id = self.kernel_id
                     try:
                         self.iopub_stream = km.create_iopub_stream(kernel_id)
                         self.hb_stream = km.create_hb_stream(kernel_id)
                     except web.HTTPError:
                         # WebSockets don't response to traditional error codes so we
                         # close the connection.
                         if not self.stream.closed():
                             self.stream.close()
                         self.close()
                     else:
                         self.iopub_stream.on_recv(self._on_zmq_reply)
                         self.start_hb(self.kernel_died)
                 def on_message(self, msg):
                     pass
                 def on_close(self):
                     # This method can be called twice, once by self.kernel_died and once
                     # from the WebSocket close event. If the WebSocket connection is
                     # closed before the ZMQ streams are setup, they could be None.
                     self.stop_hb()
                     if self.iopub_stream is not None and not self.iopub_stream.closed():
                         self.iopub_stream.on_recv(None)
                         self.iopub_stream.close()
                     if self.hb_stream is not None and not self.hb_stream.closed():
                         self.hb_stream.close()
                 def start_hb(self, callback):
                     """Start the heartbeating and call the callback if the kernel dies."""
                     if not self._beating:
                         self._kernel_alive = True
                         def ping_or_dead():
                             if self._kernel_alive:
                                 self._kernel_alive = False
                                 self.hb_stream.send(b'ping')
                             else:
                                 try:
                                     callback()
                                 except:
                                     pass
                                 finally:
                                     self._hb_periodic_callback.stop()
                         def beat_received(msg):
                             self._kernel_alive = True
                         self.hb_stream.on_recv(beat_received)
                         self._hb_periodic_callback = ioloop.PeriodicCallback(ping_or_dead, self.time_to_dead*1000)
                         self._hb_periodic_callback.start()
                         self._beating= True
                 def stop_hb(self):
                     """Stop the heartbeating and cancel all related callbacks."""
                     if self._beating:
                         self._hb_periodic_callback.stop()
                         if not self.hb_stream.closed():
                             self.hb_stream.on_recv(None)
                 def kernel_died(self):
                     self.application.kernel_manager.delete_mapping_for_kernel(self.kernel_id)
                     self.write_message(
                         {'header': {'msg_type': 'status'},
                          'parent_header': {},
                          'content': {'execution_state':'dead'}
                         }
                     )
                     self.on_close()
             class ShellHandler(AuthenticatedZMQStreamHandler):
                 def initialize(self, *args, **kwargs):
                     self.shell_stream = None
                 def on_first_message(self, msg):
                     try:
                         super(ShellHandler, self).on_first_message(msg)
                     except web.HTTPError:
                         self.close()
                         return
                     km = self.application.kernel_manager
                     self.max_msg_size = km.max_msg_size
                     kernel_id = self.kernel_id
                     try:
                         self.shell_stream = km.create_shell_stream(kernel_id)
                     except web.HTTPError:
                         # WebSockets don't response to traditional error codes so we
                         # close the connection.
                         if not self.stream.closed():
                             self.stream.close()
                         self.close()
                     else:
                         self.shell_stream.on_recv(self._on_zmq_reply)
                 def on_message(self, msg):
                     if len(msg) < self.max_msg_size:
                         msg = jsonapi.loads(msg)
                         self.session.send(self.shell_stream, msg)
                 def on_close(self):
                     # Make sure the stream exists and is not already closed.
                     if self.shell_stream is not None and not self.shell_stream.closed():
                         self.shell_stream.close()
             #-----------------------------------------------------------------------------
             # Notebook web service handlers
             #-----------------------------------------------------------------------------
             class NotebookRootHandler(AuthenticatedHandler):
                 @authenticate_unless_readonly
                 def get(self):
                     nbm = self.application.notebook_manager
                     files = nbm.list_notebooks()
                     self.finish(jsonapi.dumps(files))
                 @web.authenticated
                 def post(self):
                     nbm = self.application.notebook_manager
                     body = self.request.body.strip()
                     format = self.get_argument('format', default='json')
                     name = self.get_argument('name', default=None)
                     if body:
                         notebook_id = nbm.save_new_notebook(body, name=name, format=format)
                     else:
                         notebook_id = nbm.new_notebook()
                     self.set_header('Location', '/'+notebook_id)
                     self.finish(jsonapi.dumps(notebook_id))
             class NotebookHandler(AuthenticatedHandler):
                 SUPPORTED_METHODS = ('GET', 'PUT', 'DELETE')
                 @authenticate_unless_readonly
                 def get(self, notebook_id):
                     nbm = self.application.notebook_manager
                     format = self.get_argument('format', default='json')
                     last_mod, name, data = nbm.get_notebook(notebook_id, format)
                     if format == u'json':
                         self.set_header('Content-Type', 'application/json')
                         self.set_header('Content-Disposition','attachment; filename="%s.ipynb"' % name)
                     elif format == u'py':
                         self.set_header('Content-Type', 'application/x-python')
                         self.set_header('Content-Disposition','attachment; filename="%s.py"' % name)
                     self.set_header('Last-Modified', last_mod)
                     self.finish(data)
                 @web.authenticated
                 def put(self, notebook_id):
                     nbm = self.application.notebook_manager
                     format = self.get_argument('format', default='json')
                     name = self.get_argument('name', default=None)
                     nbm.save_notebook(notebook_id, self.request.body, name=name, format=format)
                     self.set_status(204)
                     self.finish()
                 @web.authenticated
                 def delete(self, notebook_id):
                     nbm = self.application.notebook_manager
                     nbm.delete_notebook(notebook_id)
                     self.set_status(204)
                     self.finish()
             #-----------------------------------------------------------------------------
             # RST web service handlers
             #-----------------------------------------------------------------------------
             class RSTHandler(AuthenticatedHandler):
                 @web.authenticated
                 def post(self):
                     if publish_string is None:
                         raise web.HTTPError(503, u'docutils not available')
                     body = self.request.body.strip()
                     source = body
                     # template_path=os.path.join(os.path.dirname(__file__), u'templates', u'rst_template.html')
                     defaults = {'file_insertion_enabled': 0,
                                 'raw_enabled': 0,
                                 '_disable_config': 1,
                                 'stylesheet_path': 0
                                 # 'template': template_path
                     }
                     try:
                         html = publish_string(source, writer_name='html',
                                               settings_overrides=defaults
                         )
                     except:
                         raise web.HTTPError(400, u'Invalid RST')
                     print html
                     self.set_header('Content-Type', 'text/html')
                     self.finish(html)

IPython/frontend/html/notebook/notebookapp.py

0 +2 -1

             """A tornado based IPython notebook server.
             Authors:
             * Brian Granger
             """
             #-----------------------------------------------------------------------------
             #  Copyright (C) 2008-2011  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
             #-----------------------------------------------------------------------------
             # stdlib
             import errno
             import logging
             import os
             import signal
             import socket
             import sys
             import threading
             import webbrowser
             # Third party
             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 = ioloop.IOLoop
             from tornado import httpserver
             from tornado import web
             # Our own libraries
             from .kernelmanager import MappingKernelManager
-            from .handlers import (LoginHandler,
+            from .handlers import (LoginHandler, LogoutHandler,
                 ProjectDashboardHandler, NewHandler, NamedNotebookHandler,
                 MainKernelHandler, KernelHandler, KernelActionHandler, IOPubHandler,
                 ShellHandler, NotebookRootHandler, NotebookHandler, RSTHandler
             )
             from .notebookmanager import NotebookManager
             from IPython.config.application import catch_config_error
             from IPython.core.application import BaseIPythonApplication
             from IPython.core.profiledir import ProfileDir
             from IPython.zmq.session import Session, default_secure
             from IPython.zmq.zmqshell import ZMQInteractiveShell
             from IPython.zmq.ipkernel import (
                 flags as ipkernel_flags,
                 aliases as ipkernel_aliases,
                 IPKernelApp
             )
             from IPython.utils.traitlets import Dict, Unicode, Integer, List, Enum, Bool
             #-----------------------------------------------------------------------------
             # Module globals
             #-----------------------------------------------------------------------------
             _kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
             _kernel_action_regex = r"(?P<action>restart|interrupt)"
             _notebook_id_regex = r"(?P<notebook_id>\w+-\w+-\w+-\w+-\w+)"
             LOCALHOST = '127.0.0.1'
             _examples = """
             ipython notebook                       # start the notebook
             ipython notebook --profile=sympy       # use the sympy profile
             ipython notebook --pylab=inline        # pylab in inline plotting mode
             ipython notebook --certfile=mycert.pem # use SSL/TLS certificate
             ipython notebook --port=5555 --ip=*    # Listen on port 5555, all interfaces
             """
             #-----------------------------------------------------------------------------
             # The Tornado web application
             #-----------------------------------------------------------------------------
             class NotebookWebApplication(web.Application):
                 def __init__(self, ipython_app, kernel_manager, notebook_manager, log):
                     handlers = [
                         (r"/", ProjectDashboardHandler),
                         (r"/login", LoginHandler),
+                        (r"/logout", LogoutHandler),
                         (r"/new", NewHandler),
                         (r"/%s" % _notebook_id_regex, NamedNotebookHandler),
                         (r"/kernels", MainKernelHandler),
                         (r"/kernels/%s" % _kernel_id_regex, KernelHandler),
                         (r"/kernels/%s/%s" % (_kernel_id_regex, _kernel_action_regex), KernelActionHandler),
                         (r"/kernels/%s/iopub" % _kernel_id_regex, IOPubHandler),
                         (r"/kernels/%s/shell" % _kernel_id_regex, ShellHandler),
                         (r"/notebooks", NotebookRootHandler),
                         (r"/notebooks/%s" % _notebook_id_regex, NotebookHandler),
                         (r"/rstservice/render", RSTHandler)
                     ]
                     settings = dict(
                         template_path=os.path.join(os.path.dirname(__file__), "templates"),
                         static_path=os.path.join(os.path.dirname(__file__), "static"),
                         cookie_secret=os.urandom(1024),
                         login_url="/login",
                     )
                     web.Application.__init__(self, handlers, **settings)
                     self.kernel_manager = kernel_manager
                     self.log = log
                     self.notebook_manager = notebook_manager
                     self.ipython_app = ipython_app
                     self.read_only = self.ipython_app.read_only
             #-----------------------------------------------------------------------------
             # Aliases and Flags
             #-----------------------------------------------------------------------------
             flags = dict(ipkernel_flags)
             flags['no-browser']=(
                 {'NotebookApp' : {'open_browser' : False}},
                 "Don't open the notebook in a browser after startup."
             )
             flags['read-only'] = (
                 {'NotebookApp' : {'read_only' : True}},
                 """Allow read-only access to notebooks.
                 When using a password to protect the notebook server, this flag
                 allows unauthenticated clients to view the notebook list, and
                 individual notebooks, but not edit them, start kernels, or run
                 code.
                 If no password is set, the server will be entirely read-only.
                 """
             )
             # 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 = ['no-browser', 'read-only']
             aliases = dict(ipkernel_aliases)
             aliases.update({
                 'ip': 'NotebookApp.ip',
                 'port': 'NotebookApp.port',
                 'keyfile': 'NotebookApp.keyfile',
                 'certfile': 'NotebookApp.certfile',
                 'notebook-dir': 'NotebookManager.notebook_dir',
             })
             # remove ipkernel flags that are singletons, and don't make sense in
             # multi-kernel evironment:
             aliases.pop('f', None)
             notebook_aliases = [u'port', u'ip', u'keyfile', u'certfile',
                                 u'notebook-dir']
             #-----------------------------------------------------------------------------
             # NotebookApp
             #-----------------------------------------------------------------------------
             class NotebookApp(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.
                 """
                 examples = _examples
                 classes = [IPKernelApp, ZMQInteractiveShell, ProfileDir, Session,
                            MappingKernelManager, NotebookManager]
                 flags = Dict(flags)
                 aliases = Dict(aliases)
                 kernel_argv = List(Unicode)
                 log_level = Enum((0,10,20,30,40,50,'DEBUG','INFO','WARN','ERROR','CRITICAL'),
                                 default_value=logging.INFO,
                                 config=True,
                                 help="Set the log level by value or name.")
                 # Network related information.
                 ip = Unicode(LOCALHOST, config=True,
                     help="The IP address the notebook server will listen on."
                 )
                 def _ip_changed(self, name, old, new):
                     if new == u'*': self.ip = u''
                 port = Integer(8888, config=True,
                     help="The port the notebook server will listen on."
                 )
                 certfile = Unicode(u'', config=True,
                     help="""The full path to an SSL/TLS certificate file."""
                 )
                 keyfile = Unicode(u'', config=True,
                     help="""The full path to a private key file for usage with SSL/TLS."""
                 )
                 password = Unicode(u'', config=True,
                                   help="""Hashed password to use for web authentication.
                                   To generate, type in a python/IPython shell:
                                     from IPython.lib import passwd; passwd()
                                   The string should be of the form type:salt:hashed-password.
                                   """
                 )
                 open_browser = Bool(True, config=True,
                                     help="Whether to open in a browser after starting.")
                 read_only = Bool(False, config=True,
                     help="Whether to prevent editing/execution of notebooks."
                 )
                 def parse_command_line(self, argv=None):
                     super(NotebookApp, 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.lstrip('-') in notebook_flags:
                             self.kernel_argv.remove(a)
                     swallow_next = False
                     for a in argv:
                         if swallow_next:
                             self.kernel_argv.remove(a)
                             swallow_next = False
                             continue
                         if a.startswith('-'):
                             split = a.lstrip('-').split('=')
                             alias = split[0]
                             if alias in notebook_aliases:
                                 self.kernel_argv.remove(a)
                                 if len(split) == 1:
                                     # alias passed with arg via space
                                     swallow_next = True
                 def init_configurables(self):
                     # Don't let Qt or ZMQ swallow KeyboardInterupts.
                     signal.signal(signal.SIGINT, signal.SIG_DFL)
                     # force Session default to be secure
                     default_secure(self.config)
                     # Create a KernelManager and start a kernel.
                     self.kernel_manager = MappingKernelManager(
                         config=self.config, log=self.log, kernel_argv=self.kernel_argv,
                         connection_dir = self.profile_dir.security_dir,
                     )
                     self.notebook_manager = NotebookManager(config=self.config, log=self.log)
                     self.notebook_manager.list_notebooks()
                 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.
                     self.log.propagate = False
                 @catch_config_error
                 def initialize(self, argv=None):
                     super(NotebookApp, self).initialize(argv)
                     self.init_configurables()
                     self.web_app = NotebookWebApplication(
                         self, self.kernel_manager, self.notebook_manager, self.log
                     )
                     if self.certfile:
                         ssl_options = dict(certfile=self.certfile)
                         if self.keyfile:
                             ssl_options['keyfile'] = self.keyfile
                     else:
                         ssl_options = None
                     self.web_app.password = self.password
                     self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options)
                     if ssl_options is None and not self.ip:
                         self.log.critical('WARNING: the notebook server is listening on all IP addresses '
                                           'but not using any encryption or authentication. This is highly '
                                           'insecure and not recommended.')
                     # Try random ports centered around the default.
                     from random import randint
                     n = 50  # Max number of attempts, keep reasonably large.
                     for port in range(self.port, self.port+5) + [self.port + randint(-2*n, 2*n) for i in range(n-5)]:
                         try:
                             self.http_server.listen(port, self.ip)
                         except socket.error, e:
                             if e.errno != errno.EADDRINUSE:
                                 raise
                             self.log.info('The port %i is already in use, trying another random port.' % port)
                         else:
                             self.port = port
                             break
                 def start(self):
                     ip = self.ip if self.ip else '[all ip addresses on your system]'
                     proto = 'https' if self.certfile else 'http'
                     self.log.info("The IPython Notebook is running at: %s://%s:%i" % (proto,
                                                                                       ip,
                                                                                       self.port))
                     if self.open_browser:
                         ip = self.ip or '127.0.0.1'
                         b = lambda : webbrowser.open("%s://%s:%i" % (proto, ip, self.port),
                                                      new=2)
                         threading.Thread(target=b).start()
                     ioloop.IOLoop.instance().start()
             #-----------------------------------------------------------------------------
             # Main entry point
             #-----------------------------------------------------------------------------
             def launch_new_instance():
                 app = NotebookApp()
                 app.initialize()
                 app.start()

IPython/frontend/html/notebook/static/css/layout.css

0 +19 -4

             .border-box-sizing {
                 box-sizing: border-box;
                 -moz-box-sizing: border-box;
                 -webkit-box-sizing: border-box;
             }
             /* Flexible box model classes */
             /* Taken from Alex Russell http://infrequently.org/2009/08/css-3-progress/ */
             .hbox {
             	display: -webkit-box;
             	-webkit-box-orient: horizontal;
             	-webkit-box-align: stretch;
             	display: -moz-box;
             	-moz-box-orient: horizontal;
             	-moz-box-align: stretch;
             	display: box;
             	box-orient: horizontal;
             	box-align: stretch;
             }
             .hbox > * {
             	-webkit-box-flex: 0;
             	-moz-box-flex: 0;
             	box-flex: 0;
             }
             .vbox {
             	display: -webkit-box;
             	-webkit-box-orient: vertical;
             	-webkit-box-align: stretch;
             	display: -moz-box;
             	-moz-box-orient: vertical;
             	-moz-box-align: stretch;
             	display: box;
             	box-orient: vertical;
             	box-align: stretch;
             }
             .vbox > * {
             	-webkit-box-flex: 0;
             	-moz-box-flex: 0;
             	box-flex: 0;
             }
             .reverse {
             	-webkit-box-direction: reverse;
             	-moz-box-direction: reverse;
             	box-direction: reverse;
             }
             .box-flex0 {
             	-webkit-box-flex: 0;
             	-moz-box-flex: 0;
             	box-flex: 0;
             }
             .box-flex1, .box-flex {
             	-webkit-box-flex: 1;
             	-moz-box-flex: 1;
             	box-flex: 1;
             }
             .box-flex2 {
             	-webkit-box-flex: 2;
             	-moz-box-flex: 2;
             	box-flex: 2;
             }
             .box-group1 {
             	-webkit-box-flex-group: 1;
             	-moz-box-flex-group: 1;
             	box-flex-group: 1;
             }
             .box-group2 {
             	-webkit-box-flex-group: 2;
             	-moz-box-flex-group: 2;
             	box-flex-group: 2;
             }
             .start {
             	-webkit-box-pack: start;
             	-moz-box-pack: start;
             	box-pack: start;
             }
             .end {
             	-webkit-box-pack: end;
             	-moz-box-pack: end;
             	box-pack: end;
             }
             .center {
             	-webkit-box-pack: center;
             	-moz-box-pack: center;
             	box-pack: center;
             }
-            #message {
+            .message {
-                border: 1px solid red;
+                border-width: 1px;
-                background-color: #FFD3D1;
+                border-style: solid;
                 text-align: center;
                 padding: 0.5em;
-                margin: 0.5em;
+                margin: 0.5em 0;
+            }
+            .message.error {
+                background-color: #FFD3D1;
+                border-color: red;
+            }
+            .message.warning {
+                background-color: #FFD09E;
+                border-color: orange;
+            }
+            .message.info {
+                background-color: #CBFFBA;
+                border-color: green;
             }
             #content_panel {
                 margin: 0.5em;
             }

IPython/frontend/html/notebook/static/js/loginwidget.js

0 +3 -3

             //----------------------------------------------------------------------------
             //  Copyright (C) 2008-2011  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.
             //----------------------------------------------------------------------------
             //============================================================================
             // Login button
             //============================================================================
             var IPython = (function (IPython) {
                 var LoginWidget = function (selector) {
                     this.selector = selector;
                     if (this.selector !== undefined) {
                         this.element = $(selector);
                         this.style();
                         this.bind_events();
                     }
                 };
                 LoginWidget.prototype.style = function () {
-                    this.element.find('button#login').button();
+                    this.element.find('button#logout').button();
                 };
                 LoginWidget.prototype.bind_events = function () {
                     var that = this;
-                    this.element.find("button#login").click(function () {
+                    this.element.find("button#logout").click(function () {
-                        window.location = "/login?next="+location.pathname;
+                        window.location = "/logout";
                     });
                 };
                 // Set module variables
                 IPython.LoginWidget = LoginWidget;
                 return IPython;
             }(IPython));

IPython/frontend/html/notebook/templates/login.html

0 +8 -61

@@ -1,61 +1,8 b''
1	<!DOCTYPE HTML>	1	{% extends layout.html %}
2	<html>	2
3		3	{% block content_panel %}
4	<head>	4	<form action="/login?next={{url_escape(next)}}" method="post">
5	<meta charset="utf-8">	5	Password: <input type="password" name="password">
6		6	<input type="submit" value="Sign in" id="signin">
7	<title>IPython Notebook</title>	7	</form>
8		8	{% end %}
9	<link rel="stylesheet" href="static/jquery/css/themes/aristo/jquery-wijmo.css" type="text/css" />
10	<link rel="stylesheet" href="static/css/boilerplate.css" type="text/css" />
11	<link rel="stylesheet" href="static/css/layout.css" type="text/css" />
12	<link rel="stylesheet" href="static/css/base.css" type="text/css" />
13
14	<meta name="read_only" content="{{read_only}}"/>
15
16	</head>
17
18	<body>
19
20	<div id="header">
21	<span id="ipython_notebook"><h1>IPython Notebook</h1></span>
22	</div>
23
24	<div id="header_border"></div>
25
26	<div id="main_app">
27
28	<div id="app_hbox">
29
30	<div id="left_panel">
31	</div>
32
33	<div id="content_panel">
34	{% if message %}
35	<div id="message">
36	{{message}}
37	</div>
38	{% end %}
39
40	<form action="/login?next={{url_escape(next)}}" method="post">
41	Password: <input type="password" name="password">
42	<input type="submit" value="Sign in" id="signin">
43	</form>
44	</div>
45	<div id="right_panel">
46	</div>
47
48	</div>
49
50	</div>
51
52	<script src="static/jquery/js/jquery-1.6.2.min.js" type="text/javascript" charset="utf-8"></script>
53	<script src="static/jquery/js/jquery-ui-1.8.14.custom.min.js" type="text/javascript" charset="utf-8"></script>
54	<script src="static/js/namespace.js" type="text/javascript" charset="utf-8"></script>
55	<script src="static/js/loginmain.js" type="text/javascript" charset="utf-8"></script>
56
57	</body>
58
59	</html>
60
61

IPython/frontend/html/notebook/templates/notebook.html

0 +8 -2

             <!DOCTYPE HTML>
             <html>
             <head>
                 <meta charset="utf-8">
                 <title>IPython Notebook</title>
                 <!-- <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML" charset="utf-8"></script> -->
                 <script type='text/javascript' src='static/mathjax/MathJax.js?config=TeX-AMS_HTML' charset='utf-8'></script>
                 <script type="text/javascript">
                 function CheckMathJax(){
                     var div=document.getElementById("MathJaxFetchingWarning")
                     if(window.MathJax){
                         document.body.removeChild(div)
                     }
                     else{
                        div.style.display = "block";
                     }
                 }
                 if (typeof MathJax == 'undefined') {
                     console.log("No local MathJax, loading from CDN");
                     document.write(unescape("%3Cscript type='text/javascript' src='http://cdn.mathjax.org/mathjax/latest/MathJax.js%3Fconfig=TeX-AMS_HTML' charset='utf-8'%3E%3C/script%3E"));
                 }else{
                     console.log("Using local MathJax");
                 }
                 </script>
                 <link rel="stylesheet" href="static/jquery/css/themes/aristo/jquery-wijmo.css" type="text/css" />
                 <link rel="stylesheet" href="static/codemirror/lib/codemirror.css">
                 <link rel="stylesheet" href="static/codemirror/mode/markdown/markdown.css">
                 <link rel="stylesheet" href="static/codemirror/mode/rst/rst.css">
                 <link rel="stylesheet" href="static/codemirror/theme/ipython.css">
                 <link rel="stylesheet" href="static/codemirror/theme/default.css">
                 <link rel="stylesheet" href="static/prettify/prettify.css"/>
                 <link rel="stylesheet" href="static/css/boilerplate.css" type="text/css" />
                 <link rel="stylesheet" href="static/css/layout.css" type="text/css" />
                 <link rel="stylesheet" href="static/css/base.css" type="text/css" />
                 <link rel="stylesheet" href="static/css/notebook.css" type="text/css" />
                 <link rel="stylesheet" href="static/css/renderedhtml.css" type="text/css" />
                 <meta name="read_only" content="{{read_only}}"/>
             </head>
             <body onload='CheckMathJax();'
                 data-project={{project}} data-notebook-id={{notebook_id}}
                 data-base-project-url={{base_project_url}} data-base-kernel-url={{base_kernel_url}}
             >
             <div id="header">
                 <span id="ipython_notebook"><h1>IPython Notebook</h1></span>
                 <span id="save_widget">
                     <input type="text" id="notebook_name" size="20"></textarea>
                     <button id="save_notebook"><u>S</u>ave</button>
                 </span>
                 <span id="quick_help_area">
                   <button id="quick_help">Quick<u>H</u>elp</button>
                 </span>
-                <span id="login_widget" class="hidden">
-                  <button id="login">Login</button>
+                <span id="login_widget">
+                  {% comment  This is a temporary workaround to hide the logout button %}
+                  {% comment  when appropriate until notebook.html is templated %}
+                  {% if current_user and current_user != 'anonymous' %}
+                    <button id="logout">Logout</button>
+                  {% end %}
                 </span>
                 <span id="kernel_status">Idle</span>
             </div>
             <div id="MathJaxFetchingWarning"
                   style="width:80%; margin:auto;padding-top:20%;text-align: justify; display:none">
                   <p style="font-size:26px;">There was an issue trying to fetch MathJax.js
                     from the internet.</p>
                   <p style="padding:0.2em"> With a working internet connection, you can run
                 the following at a Python or IPython prompt, which will install a local
                 copy of MathJax:</p>
                     <pre style="background-color:lightblue;border:thin silver solid;padding:0.4em">
                         from IPython.external import mathjax; mathjax.install_mathjax()
                     </pre>
                     This will try to install MathJax into the directory where you installed
                     IPython. If you installed IPython to a location that requires
                     administrative privileges to write, you will need to make this call as
                     an administrator. On OSX/Linux/Unix, this can be done at the
                     command-line via:
                     <pre style="background-color:lightblue;border:thin silver solid;padding:0.4em">
                         sudo python -c "from IPython.external import mathjax; mathjax.install_mathjax()"
                     </pre>
                 </p>
             </div>
             <div id="main_app">
                 <div id="left_panel">
                     <div id="notebook_section">
                         <div class="section_header">
                             <h3>Notebook</h3>
                         </div>
                         <div class="section_content">
                             <div class="section_row">
                                 <span id="new_open" class="section_row_buttons">
                                     <button id="new_notebook">New</button>
                                     <button id="open_notebook">Open</button>
                                 </span>
                                 <span class="section_row_header">Actions</span>
                             </div>
                             <div class="section_row">
                                 <span>
                                     <select id="download_format">
                                         <option value="json">ipynb</option>
                                         <option value="py">py</option>
                                     </select>
                                 </span>
                                 <span class="section_row_buttons">
                                     <button id="download_notebook">Download</button>
                                 </span>
                             </div>
                             <div class="section_row">
                                 <span class="section_row_buttons">
                                     <span id="print_widget">
                                         <button id="print_notebook">Print</button>
                                     </span>
                                 </span>
                             </div>
                         </div>
                     </div>
                     <div id="cell_section">
                         <div class="section_header">
                             <h3>Cell</h3>
                         </div>
                         <div class="section_content">
                             <div class="section_row">
                                 <span class="section_row_buttons">
                                     <button id="delete_cell"><u>D</u>elete</button>
                                 </span>
                                 <span class="section_row_header">Actions</span>
                             </div>
                             <div class="section_row">
                                 <span id="cell_type" class="section_row_buttons">
                                     <button id="to_code"><u>C</u>ode</button>
             <!--                        <button id="to_html">HTML</button>-->
                                     <button id="to_markdown"><u>M</u>arkdown</button>
                                 </span>
                                  <span class="button_label">Format</span>
                             </div>
                             <div class="section_row">
                                 <span id="cell_output" class="section_row_buttons">
                                     <button id="toggle_output"><u>T</u>oggle</button>
                                     <button id="clear_all_output">ClearAll</button>
                                 </span>
                                 <span class="button_label">Output</span>
                             </div>
                             <div class="section_row">
                                 <span id="insert" class="section_row_buttons">
                                     <button id="insert_cell_above"><u>A</u>bove</button>
                                     <button id="insert_cell_below"><u>B</u>elow</button>
                                 </span>
                                 <span class="button_label">Insert</span>
                             </div>
                             <div class="section_row">
                                 <span id="move" class="section_row_buttons">
                                     <button id="move_cell_up">Up</button>
                                     <button id="move_cell_down">Down</button>
                                 </span>
                                 <span class="button_label">Move</span>
                             </div>
                             <div class="section_row">
                                 <span id="run_cells" class="section_row_buttons">
                                     <button id="run_selected_cell">Selected</button>
                                     <button id="run_all_cells">All</button>
                                 </span>
                                 <span class="button_label">Run</span>
                             </div>
                             <div class="section_row">
                                 <span id="autoindent_span">
                                     <input type="checkbox" id="autoindent" checked="true"></input>
                                 </span>
                                 <span class="checkbox_label" id="autoindent_label">Autoindent:</span>
                             </div>
                         </div>
                     </div>
                     <div id="kernel_section">
                         <div class="section_header">
                             <h3>Kernel</h3>
                         </div>
                         <div class="section_content">
                             <div class="section_row">
                                 <span id="int_restart" class="section_row_buttons">
                                     <button id="int_kernel"><u>I</u>nterrupt</button>
                                     <button id="restart_kernel">Restart</button>
                                 </span>
                                 <span class="section_row_header">Actions</span>
                             </div>
                             <div class="section_row">
                                 <span id="kernel_persist">
                                     {% if kill_kernel %}
                                         <input type="checkbox" id="kill_kernel" checked="true"></input>
                                     {% else %}
                                         <input type="checkbox" id="kill_kernel"></input>
                                     {% end %}
                                 </span>
                                 <span class="checkbox_label" id="kill_kernel_label">Kill kernel upon exit:</span>
                             </div>
                         </div>
                     </div>
                     <div id="help_section">
                         <div class="section_header">
                             <h3>Help</h3>
                         </div>
                         <div class="section_content">
                             <div class="section_row">
                                 <span id="help_buttons0" class="section_row_buttons">
                                     <a id="python_help" href="http://docs.python.org" target="_blank">Python</a>
                                     <a id="ipython_help" href="http://ipython.org/documentation.html" target="_blank">IPython</a>
                                 </span>
                                 <span class="section_row_header">Links</span>
                             </div>
                             <div class="section_row">
                                 <span id="help_buttons1" class="section_row_buttons">
                                     <a id="numpy_help" href="http://docs.scipy.org/doc/numpy/reference/" target="_blank">NumPy</a>
                                     <a id="scipy_help" href="http://docs.scipy.org/doc/scipy/reference/" target="_blank">SciPy</a>
                                 </span>
                             </div>
                             <div class="section_row">
                                 <span id="help_buttons2" class="section_row_buttons">
                                     <a id="matplotlib_help" href="http://matplotlib.sourceforge.net/" target="_blank">MPL</a>
                                     <a id="sympy_help" href="http://docs.sympy.org/dev/index.html" target="_blank">SymPy</a>
                                 </span>
                             </div>
                             <div class="section_row">
                                 <span class="help_string">run selected cell</span>
                                 <span class="help_string_label">Shift-Enter :</span>
                             </div>
                             <div class="section_row">
                                 <span class="help_string">run selected cell in-place</span>
                                 <span class="help_string_label">Ctrl-Enter  :</span>
                             </div>
                             <div class="section_row">
                                 <span class="help_string">show keyboard shortcuts</span>
                                 <span class="help_string_label">Ctrl-m h  :</span>
                             </div>
                         </div>
                     </div>
                 </div>
                 <div id="left_panel_splitter"></div>
                 <div id="notebook_panel">
                     <div id="notebook"></div>
                     <div id="pager_splitter"></div>
                     <div id="pager"></div>
                 </div>
             </div>
             <script src="static/jquery/js/jquery-1.6.2.min.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/jquery/js/jquery-ui-1.8.14.custom.min.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/jquery/js/jquery.autogrow.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/codemirror/lib/codemirror.js" charset="utf-8"></script>
             <script src="static/codemirror/mode/python/python.js" charset="utf-8"></script>
             <script src="static/codemirror/mode/htmlmixed/htmlmixed.js" charset="utf-8"></script>
             <script src="static/codemirror/mode/xml/xml.js" charset="utf-8"></script>
             <script src="static/codemirror/mode/javascript/javascript.js" charset="utf-8"></script>
             <script src="static/codemirror/mode/css/css.js" charset="utf-8"></script>
             <script src="static/codemirror/mode/rst/rst.js" charset="utf-8"></script>
             <script src="static/codemirror/mode/markdown/markdown.js" charset="utf-8"></script>
             <script src="static/pagedown/Markdown.Converter.js" charset="utf-8"></script>
             <script src="static/prettify/prettify.js" charset="utf-8"></script>
             <script src="static/js/namespace.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/utils.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/cell.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/codecell.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/textcell.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/kernel.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/kernelstatus.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/layout.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/savewidget.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/quickhelp.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/loginwidget.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/pager.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/panelsection.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/printwidget.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/leftpanel.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/notebook.js" type="text/javascript" charset="utf-8"></script>
             <script src="static/js/notebookmain.js" type="text/javascript" charset="utf-8"></script>
             </body>
             </html>

IPython/frontend/html/notebook/templates/projectdashboard.html

0 +28 -61

@@ -1,69 +1,36 b''
1	<!DOCTYPE HTML>	1	{% extends layout.html %}
2	<html>
3		2
4	<head>	3	{% block title %}
5	<meta charset="utf-8">	4	IPython Dashboard
		5	{% end %}
6		6
7	<title>IPython Dashboard</title>	7	{% block stylesheet %}
8
9	<link rel="stylesheet" href="static/jquery/css/themes/aristo/jquery-wijmo.css" type="text/css" />
10	<link rel="stylesheet" href="static/css/boilerplate.css" type="text/css" />
11	<link rel="stylesheet" href="static/css/layout.css" type="text/css" />
12	<link rel="stylesheet" href="static/css/base.css" type="text/css" />
13	<link rel="stylesheet" href="static/css/projectdashboard.css" type="text/css" />	8	<link rel="stylesheet" href="static/css/projectdashboard.css" type="text/css" />
		9	{% end %}
14		10
		11	{% block meta %}
15	<meta name="read_only" content="{{read_only}}"/>	12	<meta name="read_only" content="{{read_only}}"/>
16		13	{% end %}
17	</head>	14
18		15	{% block params %}
19	<body data-project={{project}} data-base-project-url={{base_project_url}}	16	data-project={{project}}
20	data-base-~~kernel~~-url={{base_~~kernel~~_url}}>	17	data-base-project-url={{base_project_url}}
21		18	data-base-kernel-url={{base_kernel_url}}
22	<div id="header">	19	{% end %}
23	<span id="ipython_notebook"><h1>IPython Notebook</h1></span>	20
24	<span id="login_widget" class="hidden">	21	{% block content_panel %}
25	<button id="login">Login</button>	22	<div id="content_toolbar">
26	</span>	23	<span id="drag_info">Drag files onto the list to import notebooks.</span>
27	</div>	24	<span id="notebooks_buttons">
28		25	<button id="new_notebook">New Notebook</button>
29	<div id="header_border"></div>	26	</span>
30
31	<div id="main_app">
32
33	<div id="app_hbox">
34
35	<div id="left_panel">
36	</div>
37
38	<div id="content_panel">
39	<div id="content_toolbar">
40	<span id="drag_info">Drag files onto the list to import notebooks.</span>
41	<span id="notebooks_buttons">
42	<button id="new_notebook">New Notebook</button>
43	</span>
44	</div>
45	<div id="notebook_list">
46	<div id="project_name"><h2>{{project}}</h2></div>
47	</div>
48
49	</div>	27	</div>
50		28	<div id="notebook_list">
51	<div id="right_panel">	29	<div id="project_name"><h2>{{project}}</h2></div>
52	</div>	30	</div>
53		31	{% end %}
54	</div>
55
56	</div>
57
58	<script src="static/jquery/js/jquery-1.6.2.min.js" type="text/javascript" charset="utf-8"></script>
59	<script src="static/jquery/js/jquery-ui-1.8.14.custom.min.js" type="text/javascript" charset="utf-8"></script>
60	<script src="static/js/namespace.js" type="text/javascript" charset="utf-8"></script>
61	<script src="static/js/notebooklist.js" type="text/javascript" charset="utf-8"></script>
62	<script src="static/js/loginwidget.js" type="text/javascript" charset="utf-8"></script>
63	<script src="static/js/projectdashboardmain.js" type="text/javascript" charset="utf-8"></script>
64
65	</body>
66
67	</html>
68
69		32
		33	{% block script %}
		34	<script src="static/js/notebooklist.js" type="text/javascript" charset="utf-8"></script>
		35	<script src="static/js/projectdashboardmain.js" type="text/javascript" charset="utf-8"></script>
		36	{% end %}

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages