jupyter_notebook imports

jupyter_notebook/__main__.py

@@ -1,3 +1,3
 if __name__ == '__main__':
-    from IPython.html import notebookapp as app
+    from jupyter_notebook import notebookapp as app
     app.launch_new_instance()

jupyter_notebook/base/handlers.py

@@ -1,528 +1,528
 """Base Tornado handlers for the notebook server."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import functools
 import json
 import logging
 import os
 import re
 import sys
 import traceback
 try:
     # py3
     from http.client import responses
 except ImportError:
     from httplib import responses
 
 from jinja2 import TemplateNotFound
 from tornado import web
 
 from tornado import gen
 from tornado.log import app_log
 
 
 import IPython
 from IPython.utils.sysinfo import get_sys_info
 
 from IPython.config import Application
 from IPython.utils.path import filefind
 from IPython.utils.py3compat import string_types
-from IPython.html.utils import is_hidden, url_path_join, url_escape
+from jupyter_notebook.utils import is_hidden, url_path_join, url_escape
 
-from IPython.html.services.security import csp_report_uri
+from jupyter_notebook.services.security import csp_report_uri
 
 #-----------------------------------------------------------------------------
 # Top-level handlers
 #-----------------------------------------------------------------------------
 non_alphanum = re.compile(r'[^A-Za-z0-9]')
 
 sys_info = json.dumps(get_sys_info())
 
 class AuthenticatedHandler(web.RequestHandler):
     """A RequestHandler with an authenticated user."""
 
     def set_default_headers(self):
         headers = self.settings.get('headers', {})
 
         if "Content-Security-Policy" not in headers:
             headers["Content-Security-Policy"] = (
                     "frame-ancestors 'self'; "
                     # Make sure the report-uri is relative to the base_url
                     "report-uri " + url_path_join(self.base_url, csp_report_uri) + ";"
             )
 
         # Allow for overriding headers
         for header_name,value in headers.items() :
             try:
                 self.set_header(header_name, value)
             except Exception as e:
                 # tornado raise Exception (not a subclass)
                 # if method is unsupported (websocket and Access-Control-Allow-Origin
                 # for example, so just ignore)
                 self.log.debug(e)
     
     def clear_login_cookie(self):
         self.clear_cookie(self.cookie_name)
     
     def get_current_user(self):
         if self.login_handler is None:
             return 'anonymous'
         return self.login_handler.get_user(self)
 
     @property
     def cookie_name(self):
         default_cookie_name = non_alphanum.sub('-', 'username-{}'.format(
             self.request.host
         ))
         return self.settings.get('cookie_name', default_cookie_name)
     
     @property
     def logged_in(self):
         """Is a user currently logged in?"""
         user = self.get_current_user()
         return (user and not user == 'anonymous')
 
     @property
     def login_handler(self):
         """Return the login handler for this application, if any."""
         return self.settings.get('login_handler_class', None)
 
     @property
     def login_available(self):
         """May a user proceed to log in?
 
         This returns True if login capability is available, irrespective of
         whether the user is already logged in or not.
 
         """
         if self.login_handler is None:
             return False
         return bool(self.login_handler.login_available(self.settings))
 
 
 class IPythonHandler(AuthenticatedHandler):
     """IPython-specific extensions to authenticated handling
     
     Mostly property shortcuts to IPython-specific settings.
     """
     
     @property
     def config(self):
         return self.settings.get('config', None)
     
     @property
     def log(self):
         """use the IPython log by default, falling back on tornado's logger"""
         if Application.initialized():
             return Application.instance().log
         else:
             return app_log
 
     @property
     def jinja_template_vars(self):
         """User-supplied values to supply to jinja templates."""
         return self.settings.get('jinja_template_vars', {})
     
     #---------------------------------------------------------------
     # URLs
     #---------------------------------------------------------------
     
     @property
     def version_hash(self):
         """The version hash to use for cache hints for static files"""
         return self.settings.get('version_hash', '')
     
     @property
     def mathjax_url(self):
         return self.settings.get('mathjax_url', '')
     
     @property
     def base_url(self):
         return self.settings.get('base_url', '/')
 
     @property
     def default_url(self):
         return self.settings.get('default_url', '')
 
     @property
     def ws_url(self):
         return self.settings.get('websocket_url', '')
 
     @property
     def contents_js_source(self):
         self.log.debug("Using contents: %s", self.settings.get('contents_js_source',
             'services/contents'))
         return self.settings.get('contents_js_source', 'services/contents')
     
     #---------------------------------------------------------------
     # Manager objects
     #---------------------------------------------------------------
     
     @property
     def kernel_manager(self):
         return self.settings['kernel_manager']
 
     @property
     def contents_manager(self):
         return self.settings['contents_manager']
     
     @property
     def cluster_manager(self):
         return self.settings['cluster_manager']
     
     @property
     def session_manager(self):
         return self.settings['session_manager']
     
     @property
     def terminal_manager(self):
         return self.settings['terminal_manager']
     
     @property
     def kernel_spec_manager(self):
         return self.settings['kernel_spec_manager']
 
     @property
     def config_manager(self):
         return self.settings['config_manager']
 
     #---------------------------------------------------------------
     # CORS
     #---------------------------------------------------------------
     
     @property
     def allow_origin(self):
         """Normal Access-Control-Allow-Origin"""
         return self.settings.get('allow_origin', '')
     
     @property
     def allow_origin_pat(self):
         """Regular expression version of allow_origin"""
         return self.settings.get('allow_origin_pat', None)
     
     @property
     def allow_credentials(self):
         """Whether to set Access-Control-Allow-Credentials"""
         return self.settings.get('allow_credentials', False)
     
     def set_default_headers(self):
         """Add CORS headers, if defined"""
         super(IPythonHandler, self).set_default_headers()
         if self.allow_origin:
             self.set_header("Access-Control-Allow-Origin", self.allow_origin)
         elif self.allow_origin_pat:
             origin = self.get_origin()
             if origin and self.allow_origin_pat.match(origin):
                 self.set_header("Access-Control-Allow-Origin", origin)
         if self.allow_credentials:
             self.set_header("Access-Control-Allow-Credentials", 'true')
     
     def get_origin(self):
         # Handle WebSocket Origin naming convention differences
         # 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 "Origin" in self.request.headers:
             origin = self.request.headers.get("Origin")
         else:
             origin = self.request.headers.get("Sec-Websocket-Origin", None)
         return origin
     
     #---------------------------------------------------------------
     # template rendering
     #---------------------------------------------------------------
     
     def get_template(self, name):
         """Return the jinja template object for a given name"""
         return self.settings['jinja2_env'].get_template(name)
     
     def render_template(self, name, **ns):
         ns.update(self.template_namespace)
         template = self.get_template(name)
         return template.render(**ns)
     
     @property
     def template_namespace(self):
         return dict(
             base_url=self.base_url,
             default_url=self.default_url,
             ws_url=self.ws_url,
             logged_in=self.logged_in,
             login_available=self.login_available,
             static_url=self.static_url,
             sys_info=sys_info,
             contents_js_source=self.contents_js_source,
             version_hash=self.version_hash,
             **self.jinja_template_vars
         )
     
     def get_json_body(self):
         """Return the body of the request as JSON data."""
         if not self.request.body:
             return None
         # Do we need to call body.decode('utf-8') here?
         body = self.request.body.strip().decode(u'utf-8')
         try:
             model = json.loads(body)
         except Exception:
             self.log.debug("Bad JSON: %r", body)
             self.log.error("Couldn't parse JSON", exc_info=True)
             raise web.HTTPError(400, u'Invalid JSON in body of request')
         return model
 
     def write_error(self, status_code, **kwargs):
         """render custom error pages"""
         exc_info = kwargs.get('exc_info')
         message = ''
         status_message = responses.get(status_code, 'Unknown HTTP Error')
         if exc_info:
             exception = exc_info[1]
             # get the custom message, if defined
             try:
                 message = exception.log_message % exception.args
             except Exception:
                 pass
             
             # construct the custom reason, if defined
             reason = getattr(exception, 'reason', '')
             if reason:
                 status_message = reason
         
         # build template namespace
         ns = dict(
             status_code=status_code,
             status_message=status_message,
             message=message,
             exception=exception,
         )
         
         self.set_header('Content-Type', 'text/html')
         # render the template
         try:
             html = self.render_template('%s.html' % status_code, **ns)
         except TemplateNotFound:
             self.log.debug("No template for %d", status_code)
             html = self.render_template('error.html', **ns)
         
         self.write(html)
         
 
 
 class Template404(IPythonHandler):
     """Render our 404 template"""
     def prepare(self):
         raise web.HTTPError(404)
 
 
 class AuthenticatedFileHandler(IPythonHandler, web.StaticFileHandler):
     """static files should only be accessible when logged in"""
 
     @web.authenticated
     def get(self, path):
         if os.path.splitext(path)[1] == '.ipynb':
             name = path.rsplit('/', 1)[-1]
             self.set_header('Content-Type', 'application/json')
             self.set_header('Content-Disposition','attachment; filename="%s"' % name)
         
         return web.StaticFileHandler.get(self, path)
     
     def set_headers(self):
         super(AuthenticatedFileHandler, self).set_headers()
         # disable browser caching, rely on 304 replies for savings
         if "v" not in self.request.arguments:
             self.add_header("Cache-Control", "no-cache")
     
     def compute_etag(self):
         return None
     
     def validate_absolute_path(self, root, absolute_path):
         """Validate and return the absolute path.
         
         Requires tornado 3.1
         
         Adding to tornado's own handling, forbids the serving of hidden files.
         """
         abs_path = super(AuthenticatedFileHandler, self).validate_absolute_path(root, absolute_path)
         abs_root = os.path.abspath(root)
         if is_hidden(abs_path, abs_root):
             self.log.info("Refusing to serve hidden file, via 404 Error")
             raise web.HTTPError(404)
         return abs_path
 
 
 def json_errors(method):
     """Decorate methods with this to return GitHub style JSON errors.
     
     This should be used on any JSON API on any handler method that can raise HTTPErrors.
     
     This will grab the latest HTTPError exception using sys.exc_info
     and then:
     
     1. Set the HTTP status code based on the HTTPError
     2. Create and return a JSON body with a message field describing
        the error in a human readable form.
     """
     @functools.wraps(method)
     @gen.coroutine
     def wrapper(self, *args, **kwargs):
         try:
             result = yield gen.maybe_future(method(self, *args, **kwargs))
         except web.HTTPError as e:
             status = e.status_code
             message = e.log_message
             self.log.warn(message)
             self.set_status(e.status_code)
             reply = dict(message=message, reason=e.reason)
             self.finish(json.dumps(reply))
         except Exception:
             self.log.error("Unhandled error in API request", exc_info=True)
             status = 500
             message = "Unknown server error"
             t, value, tb = sys.exc_info()
             self.set_status(status)
             tb_text = ''.join(traceback.format_exception(t, value, tb))
             reply = dict(message=message, reason=None, traceback=tb_text)
             self.finish(json.dumps(reply))
         else:
             # FIXME: can use regular return in generators in py3
             raise gen.Return(result)
     return wrapper
 
 
 
 #-----------------------------------------------------------------------------
 # File handler
 #-----------------------------------------------------------------------------
 
 # to minimize subclass changes:
 HTTPError = web.HTTPError
 
 class FileFindHandler(web.StaticFileHandler):
     """subclass of StaticFileHandler for serving files from a search path"""
     
     # cache search results, don't search for files more than once
     _static_paths = {}
     
     def set_headers(self):
         super(FileFindHandler, self).set_headers()
         # disable browser caching, rely on 304 replies for savings
         if "v" not in self.request.arguments or \
                 any(self.request.path.startswith(path) for path in self.no_cache_paths):
             self.set_header("Cache-Control", "no-cache")
     
     def initialize(self, path, default_filename=None, no_cache_paths=None):
         self.no_cache_paths = no_cache_paths or []
         
         if isinstance(path, string_types):
             path = [path]
         
         self.root = tuple(
             os.path.abspath(os.path.expanduser(p)) + os.sep for p in path
         )
         self.default_filename = default_filename
     
     def compute_etag(self):
         return None
     
     @classmethod
     def get_absolute_path(cls, roots, path):
         """locate a file to serve on our static file search path"""
         with cls._lock:
             if path in cls._static_paths:
                 return cls._static_paths[path]
             try:
                 abspath = os.path.abspath(filefind(path, roots))
             except IOError:
                 # IOError means not found
                 return ''
             
             cls._static_paths[path] = abspath
             return abspath
     
     def validate_absolute_path(self, root, absolute_path):
         """check if the file should be served (raises 404, 403, etc.)"""
         if absolute_path == '':
             raise web.HTTPError(404)
         
         for root in self.root:
             if (absolute_path + os.sep).startswith(root):
                 break
         
         return super(FileFindHandler, self).validate_absolute_path(root, absolute_path)
 
 
 class ApiVersionHandler(IPythonHandler):
 
     @json_errors
     def get(self):
         # not authenticated, so give as few info as possible
         self.finish(json.dumps({"version":IPython.__version__}))
 
 
 class TrailingSlashHandler(web.RequestHandler):
     """Simple redirect handler that strips trailing slashes
     
     This should be the first, highest priority handler.
     """
     
     def get(self):
         self.redirect(self.request.uri.rstrip('/'))
     
     post = put = get
 
 
 class FilesRedirectHandler(IPythonHandler):
     """Handler for redirecting relative URLs to the /files/ handler"""
     
     @staticmethod
     def redirect_to_files(self, path):
         """make redirect logic a reusable static method
         
         so it can be called from other handlers.
         """
         cm = self.contents_manager
         if cm.dir_exists(path):
             # it's a *directory*, redirect to /tree
             url = url_path_join(self.base_url, 'tree', path)
         else:
             orig_path = path
             # otherwise, redirect to /files
             parts = path.split('/')
 
             if not cm.file_exists(path=path) and 'files' in parts:
                 # redirect without files/ iff it would 404
                 # this preserves pre-2.0-style 'files/' links
                 self.log.warn("Deprecated files/ URL: %s", orig_path)
                 parts.remove('files')
                 path = '/'.join(parts)
 
             if not cm.file_exists(path=path):
                 raise web.HTTPError(404)
 
             url = url_path_join(self.base_url, 'files', path)
         url = url_escape(url)
         self.log.debug("Redirecting %s to %s", self.request.path, url)
         self.redirect(url)
     
     def get(self, path=''):
         return self.redirect_to_files(self, path)
 
 
 #-----------------------------------------------------------------------------
 # URL pattern fragments for re-use
 #-----------------------------------------------------------------------------
 
 # path matches any number of `/foo[/bar...]` or just `/` or ''
 path_regex = r"(?P<path>(?:(?:/[^/]+)+|/?))"
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 
 default_handlers = [
     (r".*/", TrailingSlashHandler),
     (r"api", ApiVersionHandler)
 ]

jupyter_notebook/base/zmqhandlers.py

@@ -1,281 +1,281
 # coding: utf-8
 """Tornado handlers for WebSocket <-> ZMQ sockets."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import json
 import struct
 import warnings
 import sys
 
 try:
     from urllib.parse import urlparse # Py 3
 except ImportError:
     from urlparse import urlparse # Py 2
 
 import tornado
 from tornado import gen, ioloop, web
 from tornado.websocket import WebSocketHandler
 
 from IPython.kernel.zmq.session import Session
 from jupyter_client.jsonutil import date_default, extract_dates
 from IPython.utils.py3compat import cast_unicode
 
 from .handlers import IPythonHandler
 
 def serialize_binary_message(msg):
     """serialize a message as a binary blob
 
     Header:
 
     4 bytes: number of msg parts (nbufs) as 32b int
     4 * nbufs bytes: offset for each buffer as integer as 32b int
 
     Offsets are from the start of the buffer, including the header.
 
     Returns
     -------
 
     The message serialized to bytes.
 
     """
     # don't modify msg or buffer list in-place
     msg = msg.copy()
     buffers = list(msg.pop('buffers'))
     if sys.version_info < (3, 4):
         buffers = [x.tobytes() for x in buffers]
     bmsg = json.dumps(msg, default=date_default).encode('utf8')
     buffers.insert(0, bmsg)
     nbufs = len(buffers)
     offsets = [4 * (nbufs + 1)]
     for buf in buffers[:-1]:
         offsets.append(offsets[-1] + len(buf))
     offsets_buf = struct.pack('!' + 'I' * (nbufs + 1), nbufs, *offsets)
     buffers.insert(0, offsets_buf)
     return b''.join(buffers)
 
 
 def deserialize_binary_message(bmsg):
     """deserialize a message from a binary blog
 
     Header:
 
     4 bytes: number of msg parts (nbufs) as 32b int
     4 * nbufs bytes: offset for each buffer as integer as 32b int
 
     Offsets are from the start of the buffer, including the header.
 
     Returns
     -------
 
     message dictionary
     """
     nbufs = struct.unpack('!i', bmsg[:4])[0]
     offsets = list(struct.unpack('!' + 'I' * nbufs, bmsg[4:4*(nbufs+1)]))
     offsets.append(None)
     bufs = []
     for start, stop in zip(offsets[:-1], offsets[1:]):
         bufs.append(bmsg[start:stop])
     msg = json.loads(bufs[0].decode('utf8'))
     msg['header'] = extract_dates(msg['header'])
     msg['parent_header'] = extract_dates(msg['parent_header'])
     msg['buffers'] = bufs[1:]
     return msg
 
 # ping interval for keeping websockets alive (30 seconds)
 WS_PING_INTERVAL = 30000
 
 if os.environ.get('IPYTHON_ALLOW_DRAFT_WEBSOCKETS_FOR_PHANTOMJS', False):
     warnings.warn("""Allowing draft76 websocket connections!
     This should only be done for testing with phantomjs!""")
-    from IPython.html import allow76
+    from jupyter_notebook import allow76
     WebSocketHandler = allow76.AllowDraftWebSocketHandler
     # draft 76 doesn't support ping
     WS_PING_INTERVAL = 0
 
 class ZMQStreamHandler(WebSocketHandler):
     
     if tornado.version_info < (4,1):
         """Backport send_error from tornado 4.1 to 4.0"""
         def send_error(self, *args, **kwargs):
             if self.stream is None:
                 super(WebSocketHandler, self).send_error(*args, **kwargs)
             else:
                 # If we get an uncaught exception during the handshake,
                 # we have no choice but to abruptly close the connection.
                 # TODO: for uncaught exceptions after the handshake,
                 # we can close the connection more gracefully.
                 self.stream.close()
 
     
     def check_origin(self, origin):
         """Check Origin == Host or Access-Control-Allow-Origin.
         
         Tornado >= 4 calls this method automatically, raising 403 if it returns False.
         """
         if self.allow_origin == '*':
             return True
 
         host = self.request.headers.get("Host")
 
         # If no header is provided, assume we can't verify origin
         if origin is None:
             self.log.warn("Missing Origin header, rejecting WebSocket connection.")
             return False
         if host is None:
             self.log.warn("Missing Host header, rejecting WebSocket connection.")
             return False
         
         origin = origin.lower()
         origin_host = urlparse(origin).netloc
         
         # OK if origin matches host
         if origin_host == host:
             return True
         
         # Check CORS headers
         if self.allow_origin:
             allow = self.allow_origin == origin
         elif self.allow_origin_pat:
             allow = bool(self.allow_origin_pat.match(origin))
         else:
             # No CORS headers deny the request
             allow = False
         if not allow:
             self.log.warn("Blocking Cross Origin WebSocket Attempt.  Origin: %s, Host: %s",
                 origin, host,
             )
         return allow
 
     def clear_cookie(self, *args, **kwargs):
         """meaningless for websockets"""
         pass
 
     def _reserialize_reply(self, msg_list, channel=None):
         """Reserialize a reply message using JSON.
 
         This takes the msg list from the ZMQ socket, deserializes 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.deserialize(msg_list)
         if channel:
             msg['channel'] = channel
         if msg['buffers']:
             buf = serialize_binary_message(msg)
             return buf
         else:
             smsg = json.dumps(msg, default=date_default)
             return cast_unicode(smsg)
 
     def _on_zmq_reply(self, stream, msg_list):
         # Sometimes this gets triggered when the on_close method is scheduled in the
         # eventloop but hasn't been called.
         if self.stream.closed() or stream.closed():
             self.log.warn("zmq message arrived on closed channel")
             self.close()
             return
         channel = getattr(stream, 'channel', None)
         try:
             msg = self._reserialize_reply(msg_list, channel=channel)
         except Exception:
             self.log.critical("Malformed message: %r" % msg_list, exc_info=True)
         else:
             self.write_message(msg, binary=isinstance(msg, bytes))
 
 class AuthenticatedZMQStreamHandler(ZMQStreamHandler, IPythonHandler):
     ping_callback = None
     last_ping = 0
     last_pong = 0
     
     @property
     def ping_interval(self):
         """The interval for websocket keep-alive pings.
         
         Set ws_ping_interval = 0 to disable pings.
         """
         return self.settings.get('ws_ping_interval', WS_PING_INTERVAL)
     
     @property
     def ping_timeout(self):
         """If no ping is received in this many milliseconds,
         close the websocket connection (VPNs, etc. can fail to cleanly close ws connections).
         Default is max of 3 pings or 30 seconds.
         """
         return self.settings.get('ws_ping_timeout',
             max(3 * self.ping_interval, WS_PING_INTERVAL)
         )
 
     def set_default_headers(self):
         """Undo the set_default_headers in IPythonHandler
         
         which doesn't make sense for websockets
         """
         pass
     
     def pre_get(self):
         """Run before finishing the GET request
         
         Extend this method to add logic that should fire before
         the websocket finishes completing.
         """
         # authenticate the request before opening the websocket
         if self.get_current_user() is None:
             self.log.warn("Couldn't authenticate WebSocket connection")
             raise web.HTTPError(403)
         
         if self.get_argument('session_id', False):
             self.session.session = cast_unicode(self.get_argument('session_id'))
         else:
             self.log.warn("No session ID specified")
     
     @gen.coroutine
     def get(self, *args, **kwargs):
         # pre_get can be a coroutine in subclasses
         # assign and yield in two step to avoid tornado 3 issues
         res = self.pre_get()
         yield gen.maybe_future(res)
         super(AuthenticatedZMQStreamHandler, self).get(*args, **kwargs)
     
     def initialize(self):
         self.log.debug("Initializing websocket connection %s", self.request.path)
         self.session = Session(config=self.config)
     
     def open(self, *args, **kwargs):
         self.log.debug("Opening websocket %s", self.request.path)
         
         # start the pinging
         if self.ping_interval > 0:
             loop = ioloop.IOLoop.current()
             self.last_ping = loop.time()  # Remember time of last ping
             self.last_pong = self.last_ping
             self.ping_callback = ioloop.PeriodicCallback(
                 self.send_ping, self.ping_interval, io_loop=loop,
             )
             self.ping_callback.start()
 
     def send_ping(self):
         """send a ping to keep the websocket alive"""
         if self.stream.closed() and self.ping_callback is not None:
             self.ping_callback.stop()
             return
         
         # check for timeout on pong.  Make sure that we really have sent a recent ping in
         # case the machine with both server and client has been suspended since the last ping.
         now = ioloop.IOLoop.current().time()
         since_last_pong = 1e3 * (now - self.last_pong)
         since_last_ping = 1e3 * (now - self.last_ping)
         if since_last_ping < 2*self.ping_interval and since_last_pong > self.ping_timeout:
             self.log.warn("WebSocket ping timeout after %i ms.", since_last_pong)
             self.close()
             return
 
         self.ping(b'')
         self.last_ping = now
 
     def on_pong(self, data):
         self.last_pong = ioloop.IOLoop.current().time()

jupyter_notebook/files/handlers.py

@@ -1,55 +1,55
 """Serve files directly from the ContentsManager."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import mimetypes
 import json
 import base64
 
 from tornado import web
 
-from IPython.html.base.handlers import IPythonHandler
+from jupyter_notebook.base.handlers import IPythonHandler
 
 class FilesHandler(IPythonHandler):
     """serve files via ContentsManager"""
 
     @web.authenticated
     def get(self, path):
         cm = self.contents_manager
         if cm.is_hidden(path):
             self.log.info("Refusing to serve hidden file, via 404 Error")
             raise web.HTTPError(404)
         
         path = path.strip('/')
         if '/' in path:
             _, name = path.rsplit('/', 1)
         else:
             name = path
         
         model = cm.get(path, type='file')
         
         if self.get_argument("download", False):
             self.set_header('Content-Disposition','attachment; filename="%s"' % name)
         
         # get mimetype from filename
         if name.endswith('.ipynb'):
             self.set_header('Content-Type', 'application/json')
         else:
             cur_mime = mimetypes.guess_type(name)[0]
             if cur_mime is not None:
                 self.set_header('Content-Type', cur_mime)
         
         if model['format'] == 'base64':
             b64_bytes = model['content'].encode('ascii')
             self.write(base64.decodestring(b64_bytes))
         elif model['format'] == 'json':
             self.write(json.dumps(model['content']))
         else:
             self.write(model['content'])
         self.flush()
 
 default_handlers = [
     (r"/files/(.*)", FilesHandler),
 ]
  No newline at end of file

jupyter_notebook/nbconvert/tests/test_nbconvert_handlers.py

@@ -1,132 +1,132
 # coding: utf-8
 import base64
 import io
 import json
 import os
 from os.path import join as pjoin
 import shutil
 
 import requests
 
-from IPython.html.utils import url_path_join
-from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
+from jupyter_notebook.utils import url_path_join
+from jupyter_notebook.tests.launchnotebook import NotebookTestBase, assert_http_error
 from IPython.nbformat import write
 from IPython.nbformat.v4 import (
     new_notebook, new_markdown_cell, new_code_cell, new_output,
 )
 
 from IPython.testing.decorators import onlyif_cmds_exist
 
 
 class NbconvertAPI(object):
     """Wrapper for nbconvert API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, path, body=None, params=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'nbconvert', path),
                 data=body, params=params,
         )
         response.raise_for_status()
         return response
 
     def from_file(self, format, path, name, download=False):
         return self._req('GET', url_path_join(format, path, name),
                          params={'download':download})
 
     def from_post(self, format, nbmodel):
         body = json.dumps(nbmodel)
         return self._req('POST', format, body)
 
     def list_formats(self):
         return self._req('GET', '')
 
 png_green_pixel = base64.encodestring(b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00'
 b'\x00\x00\x01\x00\x00x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDAT'
 b'\x08\xd7c\x90\xfb\xcf\x00\x00\x02\\\x01\x1e.~d\x87\x00\x00\x00\x00IEND\xaeB`\x82'
 ).decode('ascii')
 
 class APITest(NotebookTestBase):
     def setUp(self):
         nbdir = self.notebook_dir.name
         
         if not os.path.isdir(pjoin(nbdir, 'foo')):
             os.mkdir(pjoin(nbdir, 'foo'))
         
         nb = new_notebook()
         
         nb.cells.append(new_markdown_cell(u'Created by test ³'))
         cc1 = new_code_cell(source=u'print(2*6)')
         cc1.outputs.append(new_output(output_type="stream", text=u'12'))
         cc1.outputs.append(new_output(output_type="execute_result",
             data={'image/png' : png_green_pixel},
             execution_count=1,
         ))
         nb.cells.append(cc1)
         
         with io.open(pjoin(nbdir, 'foo', 'testnb.ipynb'), 'w',
                      encoding='utf-8') as f:
             write(nb, f, version=4)
 
         self.nbconvert_api = NbconvertAPI(self.base_url())
 
     def tearDown(self):
         nbdir = self.notebook_dir.name
 
         for dname in ['foo']:
             shutil.rmtree(pjoin(nbdir, dname), ignore_errors=True)
     
     @onlyif_cmds_exist('pandoc')
     def test_from_file(self):
         r = self.nbconvert_api.from_file('html', 'foo', 'testnb.ipynb')
         self.assertEqual(r.status_code, 200)
         self.assertIn(u'text/html', r.headers['Content-Type'])
         self.assertIn(u'Created by test', r.text)
         self.assertIn(u'print', r.text)
 
         r = self.nbconvert_api.from_file('python', 'foo', 'testnb.ipynb')
         self.assertIn(u'text/x-python', r.headers['Content-Type'])
         self.assertIn(u'print(2*6)', r.text)
 
     @onlyif_cmds_exist('pandoc')
     def test_from_file_404(self):
         with assert_http_error(404):
             self.nbconvert_api.from_file('html', 'foo', 'thisdoesntexist.ipynb')
 
     @onlyif_cmds_exist('pandoc')
     def test_from_file_download(self):
         r = self.nbconvert_api.from_file('python', 'foo', 'testnb.ipynb', download=True)
         content_disposition = r.headers['Content-Disposition']
         self.assertIn('attachment', content_disposition)
         self.assertIn('testnb.py', content_disposition)
 
     @onlyif_cmds_exist('pandoc')
     def test_from_file_zip(self):
         r = self.nbconvert_api.from_file('latex', 'foo', 'testnb.ipynb', download=True)
         self.assertIn(u'application/zip', r.headers['Content-Type'])
         self.assertIn(u'.zip', r.headers['Content-Disposition'])
 
     @onlyif_cmds_exist('pandoc')
     def test_from_post(self):
         nbmodel_url = url_path_join(self.base_url(), 'api/contents/foo/testnb.ipynb')
         nbmodel = requests.get(nbmodel_url).json()
         
         r = self.nbconvert_api.from_post(format='html', nbmodel=nbmodel)
         self.assertEqual(r.status_code, 200)
         self.assertIn(u'text/html', r.headers['Content-Type'])
         self.assertIn(u'Created by test', r.text)
         self.assertIn(u'print', r.text)
         
         r = self.nbconvert_api.from_post(format='python', nbmodel=nbmodel)
         self.assertIn(u'text/x-python', r.headers['Content-Type'])
         self.assertIn(u'print(2*6)', r.text)
 
     @onlyif_cmds_exist('pandoc')
     def test_from_post_zip(self):
         nbmodel_url = url_path_join(self.base_url(), 'api/contents/foo/testnb.ipynb')
         nbmodel = requests.get(nbmodel_url).json()
 
         r = self.nbconvert_api.from_post(format='latex', nbmodel=nbmodel)
         self.assertIn(u'application/zip', r.headers['Content-Type'])
         self.assertIn(u'.zip', r.headers['Content-Disposition'])

jupyter_notebook/notebookapp.py

@@ -1,1148 +1,1148
 # coding: utf-8
 """A tornado based IPython notebook server."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
 import base64
 import datetime
 import errno
 import importlib
 import io
 import json
 import logging
 import os
 import random
 import re
 import select
 import signal
 import socket
 import ssl
 import sys
 import threading
 import webbrowser
 
 
 from jinja2 import Environment, FileSystemLoader
 
 # Install the pyzmq ioloop. This has to be done before anything else from
 # tornado is imported.
 from zmq.eventloop import ioloop
 ioloop.install()
 
 # check for tornado 3.1.0
 msg = "The IPython Notebook requires tornado >= 4.0"
 try:
     import tornado
 except ImportError:
     raise ImportError(msg)
 try:
     version_info = tornado.version_info
 except AttributeError:
     raise ImportError(msg + ", but you have < 1.1.0")
 if version_info < (4,0):
     raise ImportError(msg + ", but you have %s" % tornado.version)
 
 from tornado import httpserver
 from tornado import web
 from tornado.log import LogFormatter, app_log, access_log, gen_log
 
-from IPython.html import (
+from jupyter_notebook import (
     DEFAULT_STATIC_FILES_PATH,
     DEFAULT_TEMPLATE_PATH_LIST,
 )
 from .base.handlers import Template404
 from .log import log_request
 from .services.kernels.kernelmanager import MappingKernelManager
 from .services.config import ConfigManager
 from .services.contents.manager import ContentsManager
 from .services.contents.filemanager import FileContentsManager
 from .services.clusters.clustermanager import ClusterManager
 from .services.sessions.sessionmanager import SessionManager
 
 from .auth.login import LoginHandler
 from .auth.logout import LogoutHandler
 from .base.handlers import IPythonHandler, FileFindHandler
 
 from IPython.config import Config
 from IPython.config.application import catch_config_error, boolean_flag
 from IPython.core.application import (
     BaseIPythonApplication, base_flags, base_aliases,
 )
 from IPython.core.profiledir import ProfileDir
 from IPython.kernel import KernelManager
 from IPython.kernel.kernelspec import KernelSpecManager, NoSuchKernel, NATIVE_KERNEL_NAME
 from IPython.kernel.zmq.session import Session
 from IPython.nbformat.sign import NotebookNotary
 from IPython.utils.importstring import import_item
 from IPython.utils import submodule
 from IPython.utils.traitlets import (
     Dict, Unicode, Integer, List, Bool, Bytes, Instance,
     TraitError, Type,
 )
 from IPython.utils import py3compat
 from IPython.utils.path import filefind, get_ipython_dir
 from IPython.utils.sysinfo import get_sys_info
 
 from .nbextensions import SYSTEM_NBEXTENSIONS_DIRS
 from .utils import url_path_join, check_pid
 
 #-----------------------------------------------------------------------------
 # Module globals
 #-----------------------------------------------------------------------------
 
 _examples = """
 ipython notebook                       # start the notebook
 ipython notebook --profile=sympy       # use the sympy profile
 ipython notebook --certfile=mycert.pem # use SSL/TLS certificate
 """
 
 #-----------------------------------------------------------------------------
 # Helper functions
 #-----------------------------------------------------------------------------
 
 def random_ports(port, n):
     """Generate a list of n random ports near the given port.
 
     The first 5 ports will be sequential, and the remaining n-5 will be
     randomly selected in the range [port-2*n, port+2*n].
     """
     for i in range(min(5, n)):
         yield port + i
     for i in range(n-5):
         yield max(1, port + random.randint(-2*n, 2*n))
 
 def load_handlers(name):
     """Load the (URL pattern, handler) tuples for each component."""
-    name = 'IPython.html.' + name
+    name = 'jupyter_notebook.' + name
     mod = __import__(name, fromlist=['default_handlers'])
     return mod.default_handlers
 
 #-----------------------------------------------------------------------------
 # The Tornado web application
 #-----------------------------------------------------------------------------
 
 class NotebookWebApplication(web.Application):
 
     def __init__(self, ipython_app, kernel_manager, contents_manager,
                  cluster_manager, session_manager, kernel_spec_manager,
                  config_manager, log,
                  base_url, default_url, settings_overrides, jinja_env_options):
 
         settings = self.init_settings(
             ipython_app, kernel_manager, contents_manager, cluster_manager,
             session_manager, kernel_spec_manager, config_manager, log, base_url,
             default_url, settings_overrides, jinja_env_options)
         handlers = self.init_handlers(settings)
 
         super(NotebookWebApplication, self).__init__(handlers, **settings)
 
     def init_settings(self, ipython_app, kernel_manager, contents_manager,
                       cluster_manager, session_manager, kernel_spec_manager,
                       config_manager,
                       log, base_url, default_url, settings_overrides,
                       jinja_env_options=None):
 
         _template_path = settings_overrides.get(
             "template_path",
             ipython_app.template_file_path,
         )
         if isinstance(_template_path, str):
             _template_path = (_template_path,)
         template_path = [os.path.expanduser(path) for path in _template_path]
 
         jenv_opt = jinja_env_options if jinja_env_options else {}
         env = Environment(loader=FileSystemLoader(template_path), **jenv_opt)
         
         sys_info = get_sys_info()
         if sys_info['commit_source'] == 'repository':
             # don't cache (rely on 304) when working from master
             version_hash = ''
         else:
             # reset the cache on server restart
             version_hash = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
 
         settings = dict(
             # basics
             log_function=log_request,
             base_url=base_url,
             default_url=default_url,
             template_path=template_path,
             static_path=ipython_app.static_file_path,
             static_handler_class = FileFindHandler,
             static_url_prefix = url_path_join(base_url,'/static/'),
             static_handler_args = {
                 # don't cache custom.js
                 'no_cache_paths': [url_path_join(base_url, 'static', 'custom')],
             },
             version_hash=version_hash,
             
             # authentication
             cookie_secret=ipython_app.cookie_secret,
             login_url=url_path_join(base_url,'/login'),
             login_handler_class=ipython_app.login_handler_class,
             logout_handler_class=ipython_app.logout_handler_class,
             password=ipython_app.password,
 
             # managers
             kernel_manager=kernel_manager,
             contents_manager=contents_manager,
             cluster_manager=cluster_manager,
             session_manager=session_manager,
             kernel_spec_manager=kernel_spec_manager,
             config_manager=config_manager,
 
             # IPython stuff
             jinja_template_vars=ipython_app.jinja_template_vars,
             nbextensions_path=ipython_app.nbextensions_path,
             websocket_url=ipython_app.websocket_url,
             mathjax_url=ipython_app.mathjax_url,
             config=ipython_app.config,
             jinja2_env=env,
             terminals_available=False,  # Set later if terminals are available
         )
 
         # allow custom overrides for the tornado web app.
         settings.update(settings_overrides)
         return settings
 
     def init_handlers(self, settings):
         """Load the (URL pattern, handler) tuples for each component."""
         
         # Order matters. The first handler to match the URL will handle the request.
         handlers = []
         handlers.extend(load_handlers('tree.handlers'))
         handlers.extend([(r"/login", settings['login_handler_class'])])
         handlers.extend([(r"/logout", settings['logout_handler_class'])])
         handlers.extend(load_handlers('files.handlers'))
         handlers.extend(load_handlers('notebook.handlers'))
         handlers.extend(load_handlers('nbconvert.handlers'))
         handlers.extend(load_handlers('kernelspecs.handlers'))
         handlers.extend(load_handlers('edit.handlers'))
         handlers.extend(load_handlers('services.config.handlers'))
         handlers.extend(load_handlers('services.kernels.handlers'))
         handlers.extend(load_handlers('services.contents.handlers'))
         handlers.extend(load_handlers('services.clusters.handlers'))
         handlers.extend(load_handlers('services.sessions.handlers'))
         handlers.extend(load_handlers('services.nbconvert.handlers'))
         handlers.extend(load_handlers('services.kernelspecs.handlers'))
         handlers.extend(load_handlers('services.security.handlers'))
         handlers.append(
             (r"/nbextensions/(.*)", FileFindHandler, {
                 'path': settings['nbextensions_path'],
                 'no_cache_paths': ['/'], # don't cache anything in nbextensions
             }),
         )
         # register base handlers last
         handlers.extend(load_handlers('base.handlers'))
         # set the URL that will be redirected from `/`
         handlers.append(
             (r'/?', web.RedirectHandler, {
                 'url' : settings['default_url'],
                 'permanent': False, # want 302, not 301
             })
         )
         # prepend base_url onto the patterns that we match
         new_handlers = []
         for handler in handlers:
             pattern = url_path_join(settings['base_url'], handler[0])
             new_handler = tuple([pattern] + list(handler[1:]))
             new_handlers.append(new_handler)
         # add 404 on the end, which will catch everything that falls through
         new_handlers.append((r'(.*)', Template404))
         return new_handlers
 
 
 class NbserverListApp(BaseIPythonApplication):
     
     description="List currently running notebook servers in this profile."
     
     flags = dict(
         json=({'NbserverListApp': {'json': True}},
               "Produce machine-readable JSON output."),
     )
     
     json = Bool(False, config=True,
           help="If True, each line of output will be a JSON object with the "
                   "details from the server info file.")
 
     def start(self):
         if not self.json:
             print("Currently running servers:")
         for serverinfo in list_running_servers(self.profile):
             if self.json:
                 print(json.dumps(serverinfo))
             else:
                 print(serverinfo['url'], "::", serverinfo['notebook_dir'])
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 flags = dict(base_flags)
 flags['no-browser']=(
     {'NotebookApp' : {'open_browser' : False}},
     "Don't open the notebook in a browser after startup."
 )
 flags['pylab']=(
     {'NotebookApp' : {'pylab' : 'warn'}},
     "DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib."
 )
 flags['no-mathjax']=(
     {'NotebookApp' : {'enable_mathjax' : False}},
     """Disable MathJax
     
     MathJax is the javascript library IPython uses to render math/LaTeX. It is
     very large, so you may want to disable it if you have a slow internet
     connection, or for offline use of the notebook.
     
     When disabled, equations etc. will appear as their untransformed TeX source.
     """
 )
 
 # Add notebook manager flags
 flags.update(boolean_flag('script', 'FileContentsManager.save_script',
                'DEPRECATED, IGNORED',
                'DEPRECATED, IGNORED'))
 
 aliases = dict(base_aliases)
 
 aliases.update({
     'ip': 'NotebookApp.ip',
     'port': 'NotebookApp.port',
     'port-retries': 'NotebookApp.port_retries',
     'transport': 'KernelManager.transport',
     'keyfile': 'NotebookApp.keyfile',
     'certfile': 'NotebookApp.certfile',
     'notebook-dir': 'NotebookApp.notebook_dir',
     'browser': 'NotebookApp.browser',
     'pylab': 'NotebookApp.pylab',
 })
 
 #-----------------------------------------------------------------------------
 # NotebookApp
 #-----------------------------------------------------------------------------
 
 class NotebookApp(BaseIPythonApplication):
 
     name = 'ipython-notebook'
     
     description = """
         The IPython HTML Notebook.
         
         This launches a Tornado based HTML Notebook Server that serves up an
         HTML5/Javascript Notebook client.
     """
     examples = _examples
     aliases = aliases
     flags = flags
     
     classes = [
         KernelManager, ProfileDir, Session, MappingKernelManager,
         ContentsManager, FileContentsManager, NotebookNotary,
         KernelSpecManager,
     ]
     flags = Dict(flags)
     aliases = Dict(aliases)
     
     subcommands = dict(
         list=(NbserverListApp, NbserverListApp.description.splitlines()[0]),
     )
 
     _log_formatter_cls = LogFormatter
 
     def _log_level_default(self):
         return logging.INFO
 
     def _log_datefmt_default(self):
         """Exclude date from default date format"""
         return "%H:%M:%S"
     
     def _log_format_default(self):
         """override default log format to include time"""
         return u"%(color)s[%(levelname)1.1s %(asctime)s.%(msecs).03d %(name)s]%(end_color)s %(message)s"
 
     # create requested profiles by default, if they don't exist:
     auto_create = Bool(True)
 
     # file to be opened in the notebook server
     file_to_run = Unicode('', config=True)
 
     # Network related information
     
     allow_origin = Unicode('', config=True,
         help="""Set the Access-Control-Allow-Origin header
         
         Use '*' to allow any origin to access your server.
         
         Takes precedence over allow_origin_pat.
         """
     )
     
     allow_origin_pat = Unicode('', config=True,
         help="""Use a regular expression for the Access-Control-Allow-Origin header
         
         Requests from an origin matching the expression will get replies with:
         
             Access-Control-Allow-Origin: origin
         
         where `origin` is the origin of the request.
         
         Ignored if allow_origin is set.
         """
     )
     
     allow_credentials = Bool(False, config=True,
         help="Set the Access-Control-Allow-Credentials: true header"
     )
     
     default_url = Unicode('/tree', config=True,
         help="The default URL to redirect to from `/`"
     )
     
     ip = Unicode('localhost', config=True,
         help="The IP address the notebook server will listen on."
     )
     def _ip_default(self):
         """Return localhost if available, 127.0.0.1 otherwise.
         
         On some (horribly broken) systems, localhost cannot be bound.
         """
         s = socket.socket()
         try:
             s.bind(('localhost', 0))
         except socket.error as e:
             self.log.warn("Cannot bind to localhost, using 127.0.0.1 as default ip\n%s", e)
             return '127.0.0.1'
         else:
             s.close()
             return 'localhost'
 
     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."
     )
     port_retries = Integer(50, config=True,
         help="The number of additional ports to try if the specified port is not available."
     )
 
     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."""
     )
     
     cookie_secret_file = Unicode(config=True,
         help="""The file where the cookie secret is stored."""
     )
     def _cookie_secret_file_default(self):
         if self.profile_dir is None:
             return ''
         return os.path.join(self.profile_dir.security_dir, 'notebook_cookie_secret')
     
     cookie_secret = Bytes(b'', config=True,
         help="""The random bytes used to secure cookies.
         By default this is a new random number every time you start the Notebook.
         Set it to a value in a config file to enable logins to persist across server sessions.
         
         Note: Cookie secrets should be kept private, do not share config files with
         cookie_secret stored in plaintext (you can read the value from a file).
         """
     )
     def _cookie_secret_default(self):
         if os.path.exists(self.cookie_secret_file):
             with io.open(self.cookie_secret_file, 'rb') as f:
                 return f.read()
         else:
             secret = base64.encodestring(os.urandom(1024))
             self._write_cookie_secret_file(secret)
             return secret
     
     def _write_cookie_secret_file(self, secret):
         """write my secret to my secret_file"""
         self.log.info("Writing notebook server cookie secret to %s", self.cookie_secret_file)
         with io.open(self.cookie_secret_file, 'wb') as f:
             f.write(secret)
         try:
             os.chmod(self.cookie_secret_file, 0o600)
         except OSError:
             self.log.warn(
                 "Could not set permissions on %s",
                 self.cookie_secret_file
             )
 
     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.
                         The specific browser used is platform dependent and
                         determined by the python standard library `webbrowser`
                         module, unless it is overridden using the --browser
                         (NotebookApp.browser) configuration option.
                         """)
 
     browser = Unicode(u'', config=True,
                       help="""Specify what command to use to invoke a web
                       browser when opening the notebook. If not specified, the
                       default browser will be determined by the `webbrowser`
                       standard library module, which allows setting of the
                       BROWSER environment variable to override it.
                       """)
     
     webapp_settings = Dict(config=True,
         help="DEPRECATED, use tornado_settings"
     )
     def _webapp_settings_changed(self, name, old, new):
         self.log.warn("\n    webapp_settings is deprecated, use tornado_settings.\n")
         self.tornado_settings = new
     
     tornado_settings = Dict(config=True,
             help="Supply overrides for the tornado.web.Application that the "
                  "IPython notebook uses.")
     
     ssl_options = Dict(config=True,
             help="""Supply SSL options for the tornado HTTPServer.
             See the tornado docs for details.""")
     
     jinja_environment_options = Dict(config=True, 
             help="Supply extra arguments that will be passed to Jinja environment.")
 
     jinja_template_vars = Dict(
         config=True,
         help="Extra variables to supply to jinja templates when rendering.",
     )
     
     enable_mathjax = Bool(True, config=True,
         help="""Whether to enable MathJax for typesetting math/TeX
 
         MathJax is the javascript library IPython uses to render math/LaTeX. It is
         very large, so you may want to disable it if you have a slow internet
         connection, or for offline use of the notebook.
 
         When disabled, equations etc. will appear as their untransformed TeX source.
         """
     )
     def _enable_mathjax_changed(self, name, old, new):
         """set mathjax url to empty if mathjax is disabled"""
         if not new:
             self.mathjax_url = u''
 
     base_url = Unicode('/', config=True,
                                help='''The base URL for the notebook server.
 
                                Leading and trailing slashes can be omitted,
                                and will automatically be added.
                                ''')
     def _base_url_changed(self, name, old, new):
         if not new.startswith('/'):
             self.base_url = '/'+new
         elif not new.endswith('/'):
             self.base_url = new+'/'
     
     base_project_url = Unicode('/', config=True, help="""DEPRECATED use base_url""")
     def _base_project_url_changed(self, name, old, new):
         self.log.warn("base_project_url is deprecated, use base_url")
         self.base_url = new
 
     extra_static_paths = List(Unicode, config=True,
         help="""Extra paths to search for serving static files.
         
         This allows adding javascript/css to be available from the notebook server machine,
         or overriding individual files in the IPython"""
     )
     def _extra_static_paths_default(self):
         return [os.path.join(self.profile_dir.location, 'static')]
     
     @property
     def static_file_path(self):
         """return extra paths + the default location"""
         return self.extra_static_paths + [DEFAULT_STATIC_FILES_PATH]
 
     extra_template_paths = List(Unicode, config=True,
         help="""Extra paths to search for serving jinja templates.
 
-        Can be used to override templates from IPython.html.templates."""
+        Can be used to override templates from jupyter_notebook.templates."""
     )
     def _extra_template_paths_default(self):
         return []
 
     @property
     def template_file_path(self):
         """return extra paths + the default locations"""
         return self.extra_template_paths + DEFAULT_TEMPLATE_PATH_LIST
 
     extra_nbextensions_path = List(Unicode, config=True,
         help="""extra paths to look for Javascript notebook extensions"""
     )
     
     @property
     def nbextensions_path(self):
         """The path to look for Javascript notebook extensions"""
         return self.extra_nbextensions_path + [os.path.join(get_ipython_dir(), 'nbextensions')] + SYSTEM_NBEXTENSIONS_DIRS
 
     websocket_url = Unicode("", config=True,
         help="""The base URL for websockets,
         if it differs from the HTTP server (hint: it almost certainly doesn't).
         
         Should be in the form of an HTTP origin: ws[s]://hostname[:port]
         """
     )
     mathjax_url = Unicode("", config=True,
         help="""The url for MathJax.js."""
     )
     def _mathjax_url_default(self):
         if not self.enable_mathjax:
             return u''
         static_url_prefix = self.tornado_settings.get("static_url_prefix",
                          url_path_join(self.base_url, "static")
         )
         
         # try local mathjax, either in nbextensions/mathjax or static/mathjax
         for (url_prefix, search_path) in [
             (url_path_join(self.base_url, "nbextensions"), self.nbextensions_path),
             (static_url_prefix, self.static_file_path),
         ]:
             self.log.debug("searching for local mathjax in %s", search_path)
             try:
                 mathjax = filefind(os.path.join('mathjax', 'MathJax.js'), search_path)
             except IOError:
                 continue
             else:
                 url = url_path_join(url_prefix, u"mathjax/MathJax.js")
                 self.log.info("Serving local MathJax from %s at %s", mathjax, url)
                 return url
         
         # no local mathjax, serve from CDN
         url = u"https://cdn.mathjax.org/mathjax/latest/MathJax.js"
         self.log.info("Using MathJax from CDN: %s", url)
         return url
     
     def _mathjax_url_changed(self, name, old, new):
         if new and not self.enable_mathjax:
             # enable_mathjax=False overrides mathjax_url
             self.mathjax_url = u''
         else:
             self.log.info("Using MathJax: %s", new)
 
     contents_manager_class = Type(
         default_value=FileContentsManager,
         klass=ContentsManager,
         config=True,
         help='The notebook manager class to use.'
     )
     kernel_manager_class = Type(
         default_value=MappingKernelManager,
         config=True,
         help='The kernel manager class to use.'
     )
     session_manager_class = Type(
         default_value=SessionManager,
         config=True,
         help='The session manager class to use.'
     )
     cluster_manager_class = Type(
         default_value=ClusterManager,
         config=True,
         help='The cluster manager class to use.'
     )
 
     config_manager_class = Type(
         default_value=ConfigManager,
         config = True,
         help='The config manager class to use'
     )
 
     kernel_spec_manager = Instance(KernelSpecManager, allow_none=True)
 
     kernel_spec_manager_class = Type(
         default_value=KernelSpecManager,
         config=True,
         help="""
         The kernel spec manager class to use. Should be a subclass
         of `IPython.kernel.kernelspec.KernelSpecManager`.
 
         The Api of KernelSpecManager is provisional and might change
         without warning between this version of IPython and the next stable one.
         """
     )
 
     login_handler_class = Type(
         default_value=LoginHandler,
         klass=web.RequestHandler,
         config=True,
         help='The login handler class to use.',
     )
 
     logout_handler_class = Type(
         default_value=LogoutHandler,
         klass=web.RequestHandler,
         config=True,
         help='The logout handler class to use.',
     )
 
     trust_xheaders = Bool(False, config=True,
         help=("Whether to trust or not X-Scheme/X-Forwarded-Proto and X-Real-Ip/X-Forwarded-For headers"
               "sent by the upstream reverse proxy. Necessary if the proxy handles SSL")
     )
 
     info_file = Unicode()
 
     def _info_file_default(self):
         info_file = "nbserver-%s.json"%os.getpid()
         return os.path.join(self.profile_dir.security_dir, info_file)
     
     pylab = Unicode('disabled', config=True,
         help="""
         DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib.
         """
     )
     def _pylab_changed(self, name, old, new):
         """when --pylab is specified, display a warning and exit"""
         if new != 'warn':
             backend = ' %s' % new
         else:
             backend = ''
         self.log.error("Support for specifying --pylab on the command line has been removed.")
         self.log.error(
             "Please use `%pylab{0}` or `%matplotlib{0}` in the notebook itself.".format(backend)
         )
         self.exit(1)
 
     notebook_dir = Unicode(config=True,
         help="The directory to use for notebooks and kernels."
     )
 
     def _notebook_dir_default(self):
         if self.file_to_run:
             return os.path.dirname(os.path.abspath(self.file_to_run))
         else:
             return py3compat.getcwd()
 
     def _notebook_dir_changed(self, name, old, new):
         """Do a bit of validation of the notebook dir."""
         if not os.path.isabs(new):
             # If we receive a non-absolute path, make it absolute.
             self.notebook_dir = os.path.abspath(new)
             return
         if not os.path.isdir(new):
             raise TraitError("No such notebook dir: %r" % new)
         
         # setting App.notebook_dir implies setting notebook and kernel dirs as well
         self.config.FileContentsManager.root_dir = new
         self.config.MappingKernelManager.root_dir = new
 
     server_extensions = List(Unicode(), config=True,
         help=("Python modules to load as notebook server extensions. "
               "This is an experimental API, and may change in future releases.")
     )
 
     reraise_server_extension_failures = Bool(
         False,
         config=True,
         help="Reraise exceptions encountered loading server extensions?",
     )
 
     def parse_command_line(self, argv=None):
         super(NotebookApp, self).parse_command_line(argv)
         
         if self.extra_args:
             arg0 = self.extra_args[0]
             f = os.path.abspath(arg0)
             self.argv.remove(arg0)
             if not os.path.exists(f):
                 self.log.critical("No such file or directory: %s", f)
                 self.exit(1)
             
             # Use config here, to ensure that it takes higher priority than
             # anything that comes from the profile.
             c = Config()
             if os.path.isdir(f):
                 c.NotebookApp.notebook_dir = f
             elif os.path.isfile(f):
                 c.NotebookApp.file_to_run = f
             self.update_config(c)
 
     def init_configurables(self):
         self.kernel_spec_manager = self.kernel_spec_manager_class(
             parent=self,
             ipython_dir=self.ipython_dir,
         )
         self.kernel_manager = self.kernel_manager_class(
             parent=self,
             log=self.log,
             connection_dir=self.profile_dir.security_dir,
             kernel_spec_manager=self.kernel_spec_manager,
         )
         self.contents_manager = self.contents_manager_class(
             parent=self,
             log=self.log,
         )
         self.session_manager = self.session_manager_class(
             parent=self,
             log=self.log,
             kernel_manager=self.kernel_manager,
             contents_manager=self.contents_manager,
         )
         self.cluster_manager = self.cluster_manager_class(
             parent=self,
             log=self.log,
         )
 
         self.config_manager = self.config_manager_class(
             parent=self,
             log=self.log,
             profile_dir=self.profile_dir.location,
         )
 
     def init_logging(self):
         # 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
         
         for log in app_log, access_log, gen_log:
             # consistent log output name (NotebookApp instead of tornado.access, etc.)
             log.name = self.log.name
         # hook up tornado 3's loggers to our app handlers
         logger = logging.getLogger('tornado')
         logger.propagate = True
         logger.parent = self.log
         logger.setLevel(self.log.level)
     
     def init_webapp(self):
         """initialize tornado webapp and httpserver"""
         self.tornado_settings['allow_origin'] = self.allow_origin
         if self.allow_origin_pat:
             self.tornado_settings['allow_origin_pat'] = re.compile(self.allow_origin_pat)
         self.tornado_settings['allow_credentials'] = self.allow_credentials
         # ensure default_url starts with base_url
         if not self.default_url.startswith(self.base_url):
             self.default_url = url_path_join(self.base_url, self.default_url)
         
         self.web_app = NotebookWebApplication(
             self, self.kernel_manager, self.contents_manager,
             self.cluster_manager, self.session_manager, self.kernel_spec_manager,
             self.config_manager,
             self.log, self.base_url, self.default_url, self.tornado_settings,
             self.jinja_environment_options
         )
         ssl_options = self.ssl_options
         if self.certfile:
             ssl_options['certfile'] = self.certfile
         if self.keyfile:
             ssl_options['keyfile'] = self.keyfile
         if not ssl_options:
             # None indicates no SSL config
             ssl_options = None
         else:
             # Disable SSLv3, since its use is discouraged.
             ssl_options['ssl_version']=ssl.PROTOCOL_TLSv1
         self.login_handler_class.validate_security(self, ssl_options=ssl_options)
         self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options,
                                                  xheaders=self.trust_xheaders)
 
         success = None
         for port in random_ports(self.port, self.port_retries+1):
             try:
                 self.http_server.listen(port, self.ip)
             except socket.error as e:
                 if e.errno == errno.EADDRINUSE:
                     self.log.info('The port %i is already in use, trying another random port.' % port)
                     continue
                 elif e.errno in (errno.EACCES, getattr(errno, 'WSAEACCES', errno.EACCES)):
                     self.log.warn("Permission to listen on port %i denied" % port)
                     continue
                 else:
                     raise
             else:
                 self.port = port
                 success = True
                 break
         if not success:
             self.log.critical('ERROR: the notebook server could not be started because '
                               'no available port could be found.')
             self.exit(1)
     
     @property
     def display_url(self):
         ip = self.ip if self.ip else '[all ip addresses on your system]'
         return self._url(ip)
 
     @property
     def connection_url(self):
         ip = self.ip if self.ip else 'localhost'
         return self._url(ip)
 
     def _url(self, ip):
         proto = 'https' if self.certfile else 'http'
         return "%s://%s:%i%s" % (proto, ip, self.port, self.base_url)
 
     def init_terminals(self):
         try:
             from .terminal import initialize
             initialize(self.web_app)
             self.web_app.settings['terminals_available'] = True
         except ImportError as e:
             log = self.log.debug if sys.platform == 'win32' else self.log.warn
             log("Terminals not available (error was %s)", e)
 
     def init_signal(self):
         if not sys.platform.startswith('win'):
             signal.signal(signal.SIGINT, self._handle_sigint)
         signal.signal(signal.SIGTERM, self._signal_stop)
         if hasattr(signal, 'SIGUSR1'):
             # Windows doesn't support SIGUSR1
             signal.signal(signal.SIGUSR1, self._signal_info)
         if hasattr(signal, 'SIGINFO'):
             # only on BSD-based systems
             signal.signal(signal.SIGINFO, self._signal_info)
     
     def _handle_sigint(self, sig, frame):
         """SIGINT handler spawns confirmation dialog"""
         # register more forceful signal handler for ^C^C case
         signal.signal(signal.SIGINT, self._signal_stop)
         # request confirmation dialog in bg thread, to avoid
         # blocking the App
         thread = threading.Thread(target=self._confirm_exit)
         thread.daemon = True
         thread.start()
     
     def _restore_sigint_handler(self):
         """callback for restoring original SIGINT handler"""
         signal.signal(signal.SIGINT, self._handle_sigint)
     
     def _confirm_exit(self):
         """confirm shutdown on ^C
         
         A second ^C, or answering 'y' within 5s will cause shutdown,
         otherwise original SIGINT handler will be restored.
         
         This doesn't work on Windows.
         """
         info = self.log.info
         info('interrupted')
         print(self.notebook_info())
         sys.stdout.write("Shutdown this notebook server (y/[n])? ")
         sys.stdout.flush()
         r,w,x = select.select([sys.stdin], [], [], 5)
         if r:
             line = sys.stdin.readline()
             if line.lower().startswith('y') and 'n' not in line.lower():
                 self.log.critical("Shutdown confirmed")
                 ioloop.IOLoop.current().stop()
                 return
         else:
             print("No answer for 5s:", end=' ')
         print("resuming operation...")
         # no answer, or answer is no:
         # set it back to original SIGINT handler
         # use IOLoop.add_callback because signal.signal must be called
         # from main thread
         ioloop.IOLoop.current().add_callback(self._restore_sigint_handler)
     
     def _signal_stop(self, sig, frame):
         self.log.critical("received signal %s, stopping", sig)
         ioloop.IOLoop.current().stop()
 
     def _signal_info(self, sig, frame):
         print(self.notebook_info())
     
     def init_components(self):
         """Check the components submodule, and warn if it's unclean"""
         status = submodule.check_submodule_status()
         if status == 'missing':
             self.log.warn("components submodule missing, running `git submodule update`")
             submodule.update_submodules(submodule.ipython_parent())
         elif status == 'unclean':
             self.log.warn("components submodule unclean, you may see 404s on static/components")
             self.log.warn("run `setup.py submodule` or `git submodule update` to update")
     
     def init_kernel_specs(self):
         """Check that the IPython kernel is present, if available"""
         try:
             self.kernel_spec_manager.get_kernel_spec(NATIVE_KERNEL_NAME)
         except NoSuchKernel:
             try:
                 import ipython_kernel
             except ImportError:
                 self.log.warn("IPython kernel not available")
             else:
                 self.log.warn("Installing IPython kernel spec")
                 self.kernel_spec_manager.install_native_kernel_spec(user=True)
         
 
     def init_server_extensions(self):
         """Load any extensions specified by config.
 
         Import the module, then call the load_jupyter_server_extension function,
         if one exists.
         
         The extension API is experimental, and may change in future releases.
         """
         for modulename in self.server_extensions:
             try:
                 mod = importlib.import_module(modulename)
                 func = getattr(mod, 'load_jupyter_server_extension', None)
                 if func is not None:
                     func(self)
             except Exception:
                 if self.reraise_server_extension_failures:
                     raise
                 self.log.warn("Error loading server extension %s", modulename,
                               exc_info=True)
     
     @catch_config_error
     def initialize(self, argv=None):
         super(NotebookApp, self).initialize(argv)
         self.init_logging()
         self.init_configurables()
         self.init_components()
         self.init_webapp()
         self.init_kernel_specs()
         self.init_terminals()
         self.init_signal()
         self.init_server_extensions()
 
     def cleanup_kernels(self):
         """Shutdown all kernels.
         
         The kernels will shutdown themselves when this process no longer exists,
         but explicit shutdown allows the KernelManagers to cleanup the connection files.
         """
         self.log.info('Shutting down kernels')
         self.kernel_manager.shutdown_all()
 
     def notebook_info(self):
         "Return the current working directory and the server url information"
         info = self.contents_manager.info_string() + "\n"
         info += "%d active kernels \n" % len(self.kernel_manager._kernels)
         return info + "The IPython Notebook is running at: %s" % self.display_url
 
     def server_info(self):
         """Return a JSONable dict of information about this server."""
         return {'url': self.connection_url,
                 'hostname': self.ip if self.ip else 'localhost',
                 'port': self.port,
                 'secure': bool(self.certfile),
                 'base_url': self.base_url,
                 'notebook_dir': os.path.abspath(self.notebook_dir),
                 'pid': os.getpid()
                }
 
     def write_server_info_file(self):
         """Write the result of server_info() to the JSON file info_file."""
         with open(self.info_file, 'w') as f:
             json.dump(self.server_info(), f, indent=2)
 
     def remove_server_info_file(self):
         """Remove the nbserver-<pid>.json file created for this server.
         
         Ignores the error raised when the file has already been removed.
         """
         try:
             os.unlink(self.info_file)
         except OSError as e:
             if e.errno != errno.ENOENT:
                 raise
 
     def start(self):
         """ Start the IPython Notebook server app, after initialization
         
         This method takes no arguments so all configuration and initialization
         must be done prior to calling this method."""
         if self.subapp is not None:
             return self.subapp.start()
 
         info = self.log.info
         for line in self.notebook_info().split("\n"):
             info(line)
         info("Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).")
 
         self.write_server_info_file()
 
         if self.open_browser or self.file_to_run:
             try:
                 browser = webbrowser.get(self.browser or None)
             except webbrowser.Error as e:
                 self.log.warn('No web browser found: %s.' % e)
                 browser = None
             
             if self.file_to_run:
                 if not os.path.exists(self.file_to_run):
                     self.log.critical("%s does not exist" % self.file_to_run)
                     self.exit(1)
 
                 relpath = os.path.relpath(self.file_to_run, self.notebook_dir)
                 uri = url_path_join('notebooks', *relpath.split(os.sep))
             else:
                 uri = 'tree'
             if browser:
                 b = lambda : browser.open(url_path_join(self.connection_url, uri),
                                           new=2)
                 threading.Thread(target=b).start()
         
         self.io_loop = ioloop.IOLoop.current()
         if sys.platform.startswith('win'):
             # add no-op to wake every 5s
             # to handle signals that may be ignored by the inner loop
             pc = ioloop.PeriodicCallback(lambda : None, 5000)
             pc.start()
         try:
             self.io_loop.start()
         except KeyboardInterrupt:
             info("Interrupted...")
         finally:
             self.cleanup_kernels()
             self.remove_server_info_file()
     
     def stop(self):
         def _stop():
             self.http_server.stop()
             self.io_loop.stop()
         self.io_loop.add_callback(_stop)
 
 
 def list_running_servers(profile='default'):
     """Iterate over the server info files of running notebook servers.
     
     Given a profile name, find nbserver-* files in the security directory of
     that profile, and yield dicts of their information, each one pertaining to
     a currently running notebook server instance.
     """
     pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), name=profile)
     for file in os.listdir(pd.security_dir):
         if file.startswith('nbserver-'):
             with io.open(os.path.join(pd.security_dir, file), encoding='utf-8') as f:
                 info = json.load(f)
 
             # Simple check whether that process is really still running
             # Also remove leftover files from IPython 2.x without a pid field
             if ('pid' in info) and check_pid(info['pid']):
                 yield info
             else:
                 # If the process has died, try to delete its info file
                 try:
                     os.unlink(file)
                 except OSError:
                     pass  # TODO: This should warn or log or something
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 launch_new_instance = NotebookApp.launch_instance
 

jupyter_notebook/services/config/tests/test_config_api.py

@@ -1,68 +1,68
 # coding: utf-8
 """Test the config webservice API."""
 
 import json
 
 import requests
 
-from IPython.html.utils import url_path_join
-from IPython.html.tests.launchnotebook import NotebookTestBase
+from jupyter_notebook.utils import url_path_join
+from jupyter_notebook.tests.launchnotebook import NotebookTestBase
 
 
 class ConfigAPI(object):
     """Wrapper for notebook API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, section, body=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'api/config', section),
                 data=body,
         )
         response.raise_for_status()
         return response
 
     def get(self, section):
         return self._req('GET', section)
 
     def set(self, section, values):
         return self._req('PUT', section, json.dumps(values))
 
     def modify(self, section, values):
         return self._req('PATCH', section, json.dumps(values))
 
 class APITest(NotebookTestBase):
     """Test the config web service API"""
     def setUp(self):
         self.config_api = ConfigAPI(self.base_url())
 
     def test_create_retrieve_config(self):
         sample = {'foo': 'bar', 'baz': 73}
         r = self.config_api.set('example', sample)
         self.assertEqual(r.status_code, 204)
 
         r = self.config_api.get('example')
         self.assertEqual(r.status_code, 200)
         self.assertEqual(r.json(), sample)
 
     def test_modify(self):
         sample = {'foo': 'bar', 'baz': 73,
                   'sub': {'a': 6, 'b': 7}, 'sub2': {'c': 8}}
         self.config_api.set('example', sample)
 
         r = self.config_api.modify('example', {'foo': None,  # should delete foo
                                                'baz': 75,
                                                'wib': [1,2,3],
                                                'sub': {'a': 8, 'b': None, 'd': 9},
                                                'sub2': {'c': None}  # should delete sub2
                                               })
         self.assertEqual(r.status_code, 200)
         self.assertEqual(r.json(), {'baz': 75, 'wib': [1,2,3],
                                     'sub': {'a': 8, 'd': 9}})
 
     def test_get_unknown(self):
         # We should get an empty config dictionary instead of a 404
         r = self.config_api.get('nonexistant')
         self.assertEqual(r.status_code, 200)
         self.assertEqual(r.json(), {})
 

jupyter_notebook/services/contents/fileio.py

@@ -1,256 +1,256
 """
 Utilities for file-based Contents/Checkpoints managers.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import base64
 from contextlib import contextmanager
 import errno
 import io
 import os
 import shutil
 import tempfile
 
 from tornado.web import HTTPError
 
-from IPython.html.utils import (
+from jupyter_notebook.utils import (
     to_api_path,
     to_os_path,
 )
 from IPython import nbformat
 from IPython.utils.py3compat import str_to_unicode
 
 
 def _copy_metadata(src, dst):
     """Copy the set of metadata we want for atomic_writing.
     
     Permission bits and flags. We'd like to copy file ownership as well, but we
     can't do that.
     """
     shutil.copymode(src, dst)
     st = os.stat(src)
     if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
         os.chflags(dst, st.st_flags)
 
 @contextmanager
 def atomic_writing(path, text=True, encoding='utf-8', **kwargs):
     """Context manager to write to a file only if the entire write is successful.
     
     This works by creating a temporary file in the same directory, and renaming
     it over the old file if the context is exited without an error. If other
     file names are hard linked to the target file, this relationship will not be
     preserved.
     
     On Windows, there is a small chink in the atomicity: the target file is
     deleted before renaming the temporary file over it. This appears to be
     unavoidable.
     
     Parameters
     ----------
     path : str
       The target file to write to.
      
     text : bool, optional
       Whether to open the file in text mode (i.e. to write unicode). Default is
       True.
     
     encoding : str, optional
       The encoding to use for files opened in text mode. Default is UTF-8.
      
     **kwargs
       Passed to :func:`io.open`.
     """
     # realpath doesn't work on Windows: http://bugs.python.org/issue9949
     # Luckily, we only need to resolve the file itself being a symlink, not
     # any of its directories, so this will suffice:
     if os.path.islink(path):
         path = os.path.join(os.path.dirname(path), os.readlink(path))
 
     dirname, basename = os.path.split(path)
     tmp_dir = tempfile.mkdtemp(prefix=basename, dir=dirname)
     tmp_path = os.path.join(tmp_dir, basename)
     if text:
         fileobj = io.open(tmp_path, 'w', encoding=encoding, **kwargs)
     else:
         fileobj = io.open(tmp_path, 'wb', **kwargs)
 
     try:
         yield fileobj
     except:
         fileobj.close()
         shutil.rmtree(tmp_dir)
         raise
 
     # Flush to disk
     fileobj.flush()
     os.fsync(fileobj.fileno())
 
     # Written successfully, now rename it
     fileobj.close()
 
     # Copy permission bits, access time, etc.
     try:
         _copy_metadata(path, tmp_path)
     except OSError:
         # e.g. the file didn't already exist. Ignore any failure to copy metadata
         pass
 
     if os.name == 'nt' and os.path.exists(path):
         # Rename over existing file doesn't work on Windows
         os.remove(path)
 
     os.rename(tmp_path, path)
     shutil.rmtree(tmp_dir)
 
 
 class FileManagerMixin(object):
     """
     Mixin for ContentsAPI classes that interact with the filesystem.
 
     Provides facilities for reading, writing, and copying both notebooks and
     generic files.
 
     Shared by FileContentsManager and FileCheckpoints.
 
     Note
     ----
     Classes using this mixin must provide the following attributes:
 
     root_dir : unicode
         A directory against against which API-style paths are to be resolved.
 
     log : logging.Logger
     """
 
     @contextmanager
     def open(self, os_path, *args, **kwargs):
         """wrapper around io.open that turns permission errors into 403"""
         with self.perm_to_403(os_path):
             with io.open(os_path, *args, **kwargs) as f:
                 yield f
 
     @contextmanager
     def atomic_writing(self, os_path, *args, **kwargs):
         """wrapper around atomic_writing that turns permission errors to 403"""
         with self.perm_to_403(os_path):
             with atomic_writing(os_path, *args, **kwargs) as f:
                 yield f
 
     @contextmanager
     def perm_to_403(self, os_path=''):
         """context manager for turning permission errors into 403."""
         try:
             yield
         except (OSError, IOError) as e:
             if e.errno in {errno.EPERM, errno.EACCES}:
                 # make 403 error message without root prefix
                 # this may not work perfectly on unicode paths on Python 2,
                 # but nobody should be doing that anyway.
                 if not os_path:
                     os_path = str_to_unicode(e.filename or 'unknown file')
                 path = to_api_path(os_path, root=self.root_dir)
                 raise HTTPError(403, u'Permission denied: %s' % path)
             else:
                 raise
 
     def _copy(self, src, dest):
         """copy src to dest
 
         like shutil.copy2, but log errors in copystat
         """
         shutil.copyfile(src, dest)
         try:
             shutil.copystat(src, dest)
         except OSError:
             self.log.debug("copystat on %s failed", dest, exc_info=True)
 
     def _get_os_path(self, path):
         """Given an API path, return its file system path.
 
         Parameters
         ----------
         path : string
             The relative API path to the named file.
 
         Returns
         -------
         path : string
             Native, absolute OS path to for a file.
 
         Raises
         ------
         404: if path is outside root
         """
         root = os.path.abspath(self.root_dir)
         os_path = to_os_path(path, root)
         if not (os.path.abspath(os_path) + os.path.sep).startswith(root):
             raise HTTPError(404, "%s is outside root contents directory" % path)
         return os_path
 
     def _read_notebook(self, os_path, as_version=4):
         """Read a notebook from an os path."""
         with self.open(os_path, 'r', encoding='utf-8') as f:
             try:
                 return nbformat.read(f, as_version=as_version)
             except Exception as e:
                 raise HTTPError(
                     400,
                     u"Unreadable Notebook: %s %r" % (os_path, e),
                 )
 
     def _save_notebook(self, os_path, nb):
         """Save a notebook to an os_path."""
         with self.atomic_writing(os_path, encoding='utf-8') as f:
             nbformat.write(nb, f, version=nbformat.NO_CONVERT)
 
     def _read_file(self, os_path, format):
         """Read a non-notebook file.
 
         os_path: The path to be read.
         format:
           If 'text', the contents will be decoded as UTF-8.
           If 'base64', the raw bytes contents will be encoded as base64.
           If not specified, try to decode as UTF-8, and fall back to base64
         """
         if not os.path.isfile(os_path):
             raise HTTPError(400, "Cannot read non-file %s" % os_path)
 
         with self.open(os_path, 'rb') as f:
             bcontent = f.read()
 
         if format is None or format == 'text':
             # Try to interpret as unicode if format is unknown or if unicode
             # was explicitly requested.
             try:
                 return bcontent.decode('utf8'), 'text'
             except UnicodeError:
                 if format == 'text':
                     raise HTTPError(
                         400,
                         "%s is not UTF-8 encoded" % os_path,
                         reason='bad format',
                     )
         return base64.encodestring(bcontent).decode('ascii'), 'base64'
 
     def _save_file(self, os_path, content, format):
         """Save content of a generic file."""
         if format not in {'text', 'base64'}:
             raise HTTPError(
                 400,
                 "Must specify format of file contents as 'text' or 'base64'",
             )
         try:
             if format == 'text':
                 bcontent = content.encode('utf8')
             else:
                 b64_bytes = content.encode('ascii')
                 bcontent = base64.decodestring(b64_bytes)
         except Exception as e:
             raise HTTPError(
                 400, u'Encoding error saving %s: %s' % (os_path, e)
             )
 
         with self.atomic_writing(os_path, text=False) as f:
             f.write(bcontent)

jupyter_notebook/services/contents/filemanager.py

@@ -1,473 +1,473
 """A contents manager that uses the local file system for storage."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 import io
 import os
 import shutil
 import mimetypes
 
 from tornado import web
 
 from .filecheckpoints import FileCheckpoints
 from .fileio import FileManagerMixin
 from .manager import ContentsManager
 
 from IPython import nbformat
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import Any, Unicode, Bool, TraitError
 from IPython.utils.py3compat import getcwd, string_types
 from IPython.utils import tz
-from IPython.html.utils import (
+from jupyter_notebook.utils import (
     is_hidden,
     to_api_path,
 )
 
 _script_exporter = None
 
 
 def _post_save_script(model, os_path, contents_manager, **kwargs):
     """convert notebooks to Python script after save with nbconvert
 
     replaces `ipython notebook --script`
     """
     from IPython.nbconvert.exporters.script import ScriptExporter
 
     if model['type'] != 'notebook':
         return
 
     global _script_exporter
     if _script_exporter is None:
         _script_exporter = ScriptExporter(parent=contents_manager)
     log = contents_manager.log
 
     base, ext = os.path.splitext(os_path)
     py_fname = base + '.py'
     script, resources = _script_exporter.from_filename(os_path)
     script_fname = base + resources.get('output_extension', '.txt')
     log.info("Saving script /%s", to_api_path(script_fname, contents_manager.root_dir))
     with io.open(script_fname, 'w', encoding='utf-8') as f:
         f.write(script)
 
 
 class FileContentsManager(FileManagerMixin, ContentsManager):
 
     root_dir = Unicode(config=True)
 
     def _root_dir_default(self):
         try:
             return self.parent.notebook_dir
         except AttributeError:
             return getcwd()
 
     save_script = Bool(False, config=True, help='DEPRECATED, use post_save_hook')
     def _save_script_changed(self):
         self.log.warn("""
         `--script` is deprecated. You can trigger nbconvert via pre- or post-save hooks:
 
             ContentsManager.pre_save_hook
             FileContentsManager.post_save_hook
 
         A post-save hook has been registered that calls:
 
             ipython nbconvert --to script [notebook]
 
         which behaves similarly to `--script`.
         """)
 
         self.post_save_hook = _post_save_script
 
     post_save_hook = Any(None, config=True,
         help="""Python callable or importstring thereof
 
         to be called on the path of a file just saved.
 
         This can be used to process the file on disk,
         such as converting the notebook to a script or HTML via nbconvert.
 
         It will be called as (all arguments passed by keyword)::
 
             hook(os_path=os_path, model=model, contents_manager=instance)
 
         - path: the filesystem path to the file just written
         - model: the model representing the file
         - contents_manager: this ContentsManager instance
         """
     )
     def _post_save_hook_changed(self, name, old, new):
         if new and isinstance(new, string_types):
             self.post_save_hook = import_item(self.post_save_hook)
         elif new:
             if not callable(new):
                 raise TraitError("post_save_hook must be callable")
 
     def run_post_save_hook(self, model, os_path):
         """Run the post-save hook if defined, and log errors"""
         if self.post_save_hook:
             try:
                 self.log.debug("Running post-save hook on %s", os_path)
                 self.post_save_hook(os_path=os_path, model=model, contents_manager=self)
             except Exception:
                 self.log.error("Post-save hook failed on %s", os_path, exc_info=True)
 
     def _root_dir_changed(self, name, old, new):
         """Do a bit of validation of the root_dir."""
         if not os.path.isabs(new):
             # If we receive a non-absolute path, make it absolute.
             self.root_dir = os.path.abspath(new)
             return
         if not os.path.isdir(new):
             raise TraitError("%r is not a directory" % new)
 
     def _checkpoints_class_default(self):
         return FileCheckpoints
 
     def is_hidden(self, path):
         """Does the API style path correspond to a hidden directory or file?
 
         Parameters
         ----------
         path : string
             The path to check. This is an API path (`/` separated,
             relative to root_dir).
 
         Returns
         -------
         hidden : bool
             Whether the path exists and is hidden.
         """
         path = path.strip('/')
         os_path = self._get_os_path(path=path)
         return is_hidden(os_path, self.root_dir)
 
     def file_exists(self, path):
         """Returns True if the file exists, else returns False.
 
         API-style wrapper for os.path.isfile
 
         Parameters
         ----------
         path : string
             The relative path to the file (with '/' as separator)
 
         Returns
         -------
         exists : bool
             Whether the file exists.
         """
         path = path.strip('/')
         os_path = self._get_os_path(path)
         return os.path.isfile(os_path)
 
     def dir_exists(self, path):
         """Does the API-style path refer to an extant directory?
 
         API-style wrapper for os.path.isdir
 
         Parameters
         ----------
         path : string
             The path to check. This is an API path (`/` separated,
             relative to root_dir).
 
         Returns
         -------
         exists : bool
             Whether the path is indeed a directory.
         """
         path = path.strip('/')
         os_path = self._get_os_path(path=path)
         return os.path.isdir(os_path)
 
     def exists(self, path):
         """Returns True if the path exists, else returns False.
 
         API-style wrapper for os.path.exists
 
         Parameters
         ----------
         path : string
             The API path to the file (with '/' as separator)
 
         Returns
         -------
         exists : bool
             Whether the target exists.
         """
         path = path.strip('/')
         os_path = self._get_os_path(path=path)
         return os.path.exists(os_path)
 
     def _base_model(self, path):
         """Build the common base of a contents model"""
         os_path = self._get_os_path(path)
         info = os.stat(os_path)
         last_modified = tz.utcfromtimestamp(info.st_mtime)
         created = tz.utcfromtimestamp(info.st_ctime)
         # Create the base model.
         model = {}
         model['name'] = path.rsplit('/', 1)[-1]
         model['path'] = path
         model['last_modified'] = last_modified
         model['created'] = created
         model['content'] = None
         model['format'] = None
         model['mimetype'] = None
         try:
             model['writable'] = os.access(os_path, os.W_OK)
         except OSError:
             self.log.error("Failed to check write permissions on %s", os_path)
             model['writable'] = False
         return model
 
     def _dir_model(self, path, content=True):
         """Build a model for a directory
 
         if content is requested, will include a listing of the directory
         """
         os_path = self._get_os_path(path)
 
         four_o_four = u'directory does not exist: %r' % path
 
         if not os.path.isdir(os_path):
             raise web.HTTPError(404, four_o_four)
         elif is_hidden(os_path, self.root_dir):
             self.log.info("Refusing to serve hidden directory %r, via 404 Error",
                 os_path
             )
             raise web.HTTPError(404, four_o_four)
 
         model = self._base_model(path)
         model['type'] = 'directory'
         if content:
             model['content'] = contents = []
             os_dir = self._get_os_path(path)
             for name in os.listdir(os_dir):
                 os_path = os.path.join(os_dir, name)
                 # skip over broken symlinks in listing
                 if not os.path.exists(os_path):
                     self.log.warn("%s doesn't exist", os_path)
                     continue
                 elif not os.path.isfile(os_path) and not os.path.isdir(os_path):
                     self.log.debug("%s not a regular file", os_path)
                     continue
                 if self.should_list(name) and not is_hidden(os_path, self.root_dir):
                     contents.append(self.get(
                         path='%s/%s' % (path, name),
                         content=False)
                     )
 
             model['format'] = 'json'
 
         return model
 
     def _file_model(self, path, content=True, format=None):
         """Build a model for a file
 
         if content is requested, include the file contents.
 
         format:
           If 'text', the contents will be decoded as UTF-8.
           If 'base64', the raw bytes contents will be encoded as base64.
           If not specified, try to decode as UTF-8, and fall back to base64
         """
         model = self._base_model(path)
         model['type'] = 'file'
 
         os_path = self._get_os_path(path)
 
         if content:
             content, format = self._read_file(os_path, format)
             default_mime = {
                 'text': 'text/plain',
                 'base64': 'application/octet-stream'
             }[format]
 
             model.update(
                 content=content,
                 format=format,
                 mimetype=mimetypes.guess_type(os_path)[0] or default_mime,
             )
 
         return model
 
     def _notebook_model(self, path, content=True):
         """Build a notebook model
 
         if content is requested, the notebook content will be populated
         as a JSON structure (not double-serialized)
         """
         model = self._base_model(path)
         model['type'] = 'notebook'
         if content:
             os_path = self._get_os_path(path)
             nb = self._read_notebook(os_path, as_version=4)
             self.mark_trusted_cells(nb, path)
             model['content'] = nb
             model['format'] = 'json'
             self.validate_notebook_model(model)
         return model
 
     def get(self, path, content=True, type=None, format=None):
         """ Takes a path for an entity and returns its model
 
         Parameters
         ----------
         path : str
             the API path that describes the relative path for the target
         content : bool
             Whether to include the contents in the reply
         type : str, optional
             The requested type - 'file', 'notebook', or 'directory'.
             Will raise HTTPError 400 if the content doesn't match.
         format : str, optional
             The requested format for file contents. 'text' or 'base64'.
             Ignored if this returns a notebook or directory model.
 
         Returns
         -------
         model : dict
             the contents model. If content=True, returns the contents
             of the file or directory as well.
         """
         path = path.strip('/')
 
         if not self.exists(path):
             raise web.HTTPError(404, u'No such file or directory: %s' % path)
 
         os_path = self._get_os_path(path)
         if os.path.isdir(os_path):
             if type not in (None, 'directory'):
                 raise web.HTTPError(400,
                                 u'%s is a directory, not a %s' % (path, type), reason='bad type')
             model = self._dir_model(path, content=content)
         elif type == 'notebook' or (type is None and path.endswith('.ipynb')):
             model = self._notebook_model(path, content=content)
         else:
             if type == 'directory':
                 raise web.HTTPError(400,
                                 u'%s is not a directory' % path, reason='bad type')
             model = self._file_model(path, content=content, format=format)
         return model
 
     def _save_directory(self, os_path, model, path=''):
         """create a directory"""
         if is_hidden(os_path, self.root_dir):
             raise web.HTTPError(400, u'Cannot create hidden directory %r' % os_path)
         if not os.path.exists(os_path):
             with self.perm_to_403():
                 os.mkdir(os_path)
         elif not os.path.isdir(os_path):
             raise web.HTTPError(400, u'Not a directory: %s' % (os_path))
         else:
             self.log.debug("Directory %r already exists", os_path)
 
     def save(self, model, path=''):
         """Save the file model and return the model with no content."""
         path = path.strip('/')
 
         if 'type' not in model:
             raise web.HTTPError(400, u'No file type provided')
         if 'content' not in model and model['type'] != 'directory':
             raise web.HTTPError(400, u'No file content provided')
 
         os_path = self._get_os_path(path)
         self.log.debug("Saving %s", os_path)
 
         self.run_pre_save_hook(model=model, path=path)
 
         try:
             if model['type'] == 'notebook':
                 nb = nbformat.from_dict(model['content'])
                 self.check_and_sign(nb, path)
                 self._save_notebook(os_path, nb)
                 # One checkpoint should always exist for notebooks.
                 if not self.checkpoints.list_checkpoints(path):
                     self.create_checkpoint(path)
             elif model['type'] == 'file':
                 # Missing format will be handled internally by _save_file.
                 self._save_file(os_path, model['content'], model.get('format'))
             elif model['type'] == 'directory':
                 self._save_directory(os_path, model, path)
             else:
                 raise web.HTTPError(400, "Unhandled contents type: %s" % model['type'])
         except web.HTTPError:
             raise
         except Exception as e:
             self.log.error(u'Error while saving file: %s %s', path, e, exc_info=True)
             raise web.HTTPError(500, u'Unexpected error while saving file: %s %s' % (path, e))
 
         validation_message = None
         if model['type'] == 'notebook':
             self.validate_notebook_model(model)
             validation_message = model.get('message', None)
 
         model = self.get(path, content=False)
         if validation_message:
             model['message'] = validation_message
 
         self.run_post_save_hook(model=model, os_path=os_path)
 
         return model
 
     def delete_file(self, path):
         """Delete file at path."""
         path = path.strip('/')
         os_path = self._get_os_path(path)
         rm = os.unlink
         if os.path.isdir(os_path):
             listing = os.listdir(os_path)
             # Don't delete non-empty directories.
             # A directory containing only leftover checkpoints is
             # considered empty.
             cp_dir = getattr(self.checkpoints, 'checkpoint_dir', None)
             for entry in listing:
                 if entry != cp_dir:
                     raise web.HTTPError(400, u'Directory %s not empty' % os_path)
         elif not os.path.isfile(os_path):
             raise web.HTTPError(404, u'File does not exist: %s' % os_path)
 
         if os.path.isdir(os_path):
             self.log.debug("Removing directory %s", os_path)
             with self.perm_to_403():
                 shutil.rmtree(os_path)
         else:
             self.log.debug("Unlinking file %s", os_path)
             with self.perm_to_403():
                 rm(os_path)
 
     def rename_file(self, old_path, new_path):
         """Rename a file."""
         old_path = old_path.strip('/')
         new_path = new_path.strip('/')
         if new_path == old_path:
             return
 
         new_os_path = self._get_os_path(new_path)
         old_os_path = self._get_os_path(old_path)
 
         # Should we proceed with the move?
         if os.path.exists(new_os_path):
             raise web.HTTPError(409, u'File already exists: %s' % new_path)
 
         # Move the file
         try:
             with self.perm_to_403():
                 shutil.move(old_os_path, new_os_path)
         except web.HTTPError:
             raise
         except Exception as e:
             raise web.HTTPError(500, u'Unknown error renaming file: %s %s' % (old_path, e))
 
     def info_string(self):
         return "Serving notebooks from local directory: %s" % self.root_dir
 
     def get_kernel_path(self, path, model=None):
         """Return the initial API path of  a kernel associated with a given notebook"""
         if '/' in path:
             parent_dir = path.rsplit('/', 1)[0]
         else:
             parent_dir = ''
         return parent_dir

jupyter_notebook/services/contents/handlers.py

@@ -1,342 +1,342
 """Tornado handlers for the contents web service."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
 
 from tornado import gen, web
 
-from IPython.html.utils import url_path_join, url_escape
+from jupyter_notebook.utils import url_path_join, url_escape
 from jupyter_client.jsonutil import date_default
 
-from IPython.html.base.handlers import (
+from jupyter_notebook.base.handlers import (
     IPythonHandler, json_errors, path_regex,
 )
 
 
 def sort_key(model):
     """key function for case-insensitive sort by name and type"""
     iname = model['name'].lower()
     type_key = {
         'directory' : '0',
         'notebook'  : '1',
         'file'      : '2',
     }.get(model['type'], '9')
     return u'%s%s' % (type_key, iname)
 
 
 def validate_model(model, expect_content):
     """
     Validate a model returned by a ContentsManager method.
 
     If expect_content is True, then we expect non-null entries for 'content'
     and 'format'.
     """
     required_keys = {
         "name",
         "path",
         "type",
         "writable",
         "created",
         "last_modified",
         "mimetype",
         "content",
         "format",
     }
     missing = required_keys - set(model.keys())
     if missing:
         raise web.HTTPError(
             500,
             u"Missing Model Keys: {missing}".format(missing=missing),
         )
 
     maybe_none_keys = ['content', 'format']
     if model['type'] == 'file':
         # mimetype should be populated only for file models
         maybe_none_keys.append('mimetype')
     if expect_content:
         errors = [key for key in maybe_none_keys if model[key] is None]
         if errors:
             raise web.HTTPError(
                 500,
                 u"Keys unexpectedly None: {keys}".format(keys=errors),
             )
     else:
         errors = {
             key: model[key]
             for key in maybe_none_keys
             if model[key] is not None
         }
         if errors:
             raise web.HTTPError(
                 500,
                 u"Keys unexpectedly not None: {keys}".format(keys=errors),
             )
 
 
 class ContentsHandler(IPythonHandler):
 
     SUPPORTED_METHODS = (u'GET', u'PUT', u'PATCH', u'POST', u'DELETE')
 
     def location_url(self, path):
         """Return the full URL location of a file.
 
         Parameters
         ----------
         path : unicode
             The API path of the file, such as "foo/bar.txt".
         """
         return url_escape(url_path_join(
             self.base_url, 'api', 'contents', path
         ))
 
     def _finish_model(self, model, location=True):
         """Finish a JSON request with a model, setting relevant headers, etc."""
         if location:
             location = self.location_url(model['path'])
             self.set_header('Location', location)
         self.set_header('Last-Modified', model['last_modified'])
         self.set_header('Content-Type', 'application/json')
         self.finish(json.dumps(model, default=date_default))
 
     @web.authenticated
     @json_errors
     @gen.coroutine
     def get(self, path=''):
         """Return a model for a file or directory.
 
         A directory model contains a list of models (without content)
         of the files and directories it contains.
         """
         path = path or ''
         type = self.get_query_argument('type', default=None)
         if type not in {None, 'directory', 'file', 'notebook'}:
             raise web.HTTPError(400, u'Type %r is invalid' % type)
 
         format = self.get_query_argument('format', default=None)
         if format not in {None, 'text', 'base64'}:
             raise web.HTTPError(400, u'Format %r is invalid' % format)
         content = self.get_query_argument('content', default='1')
         if content not in {'0', '1'}:
             raise web.HTTPError(400, u'Content %r is invalid' % content)
         content = int(content)
         
         model = yield gen.maybe_future(self.contents_manager.get(
             path=path, type=type, format=format, content=content,
         ))
         if model['type'] == 'directory' and content:
             # group listing by type, then by name (case-insensitive)
             # FIXME: sorting should be done in the frontends
             model['content'].sort(key=sort_key)
         validate_model(model, expect_content=content)
         self._finish_model(model, location=False)
 
     @web.authenticated
     @json_errors
     @gen.coroutine
     def patch(self, path=''):
         """PATCH renames a file or directory without re-uploading content."""
         cm = self.contents_manager
         model = self.get_json_body()
         if model is None:
             raise web.HTTPError(400, u'JSON body missing')
         model = yield gen.maybe_future(cm.update(model, path))
         validate_model(model, expect_content=False)
         self._finish_model(model)
     
     @gen.coroutine
     def _copy(self, copy_from, copy_to=None):
         """Copy a file, optionally specifying a target directory."""
         self.log.info(u"Copying {copy_from} to {copy_to}".format(
             copy_from=copy_from,
             copy_to=copy_to or '',
         ))
         model = yield gen.maybe_future(self.contents_manager.copy(copy_from, copy_to))
         self.set_status(201)
         validate_model(model, expect_content=False)
         self._finish_model(model)
 
     @gen.coroutine
     def _upload(self, model, path):
         """Handle upload of a new file to path"""
         self.log.info(u"Uploading file to %s", path)
         model = yield gen.maybe_future(self.contents_manager.new(model, path))
         self.set_status(201)
         validate_model(model, expect_content=False)
         self._finish_model(model)
     
     @gen.coroutine
     def _new_untitled(self, path, type='', ext=''):
         """Create a new, empty untitled entity"""
         self.log.info(u"Creating new %s in %s", type or 'file', path)
         model = yield gen.maybe_future(self.contents_manager.new_untitled(path=path, type=type, ext=ext))
         self.set_status(201)
         validate_model(model, expect_content=False)
         self._finish_model(model)
     
     @gen.coroutine
     def _save(self, model, path):
         """Save an existing file."""
         self.log.info(u"Saving file at %s", path)
         model = yield gen.maybe_future(self.contents_manager.save(model, path))
         validate_model(model, expect_content=False)
         self._finish_model(model)
 
     @web.authenticated
     @json_errors
     @gen.coroutine
     def post(self, path=''):
         """Create a new file in the specified path.
 
         POST creates new files. The server always decides on the name.
 
         POST /api/contents/path
           New untitled, empty file or directory.
         POST /api/contents/path
           with body {"copy_from" : "/path/to/OtherNotebook.ipynb"}
           New copy of OtherNotebook in path
         """
 
         cm = self.contents_manager
 
         if cm.file_exists(path):
             raise web.HTTPError(400, "Cannot POST to files, use PUT instead.")
 
         if not cm.dir_exists(path):
             raise web.HTTPError(404, "No such directory: %s" % path)
 
         model = self.get_json_body()
 
         if model is not None:
             copy_from = model.get('copy_from')
             ext = model.get('ext', '')
             type = model.get('type', '')
             if copy_from:
                 yield self._copy(copy_from, path)
             else:
                 yield self._new_untitled(path, type=type, ext=ext)
         else:
             yield self._new_untitled(path)
 
     @web.authenticated
     @json_errors
     @gen.coroutine
     def put(self, path=''):
         """Saves the file in the location specified by name and path.
 
         PUT is very similar to POST, but the requester specifies the name,
         whereas with POST, the server picks the name.
 
         PUT /api/contents/path/Name.ipynb
           Save notebook at ``path/Name.ipynb``. Notebook structure is specified
           in `content` key of JSON request body. If content is not specified,
           create a new empty notebook.
         """
         model = self.get_json_body()
         if model:
             if model.get('copy_from'):
                 raise web.HTTPError(400, "Cannot copy with PUT, only POST")
             exists = yield gen.maybe_future(self.contents_manager.file_exists(path))
             if exists:
                 yield gen.maybe_future(self._save(model, path))
             else:
                 yield gen.maybe_future(self._upload(model, path))
         else:
             yield gen.maybe_future(self._new_untitled(path))
 
     @web.authenticated
     @json_errors
     @gen.coroutine
     def delete(self, path=''):
         """delete a file in the given path"""
         cm = self.contents_manager
         self.log.warn('delete %s', path)
         yield gen.maybe_future(cm.delete(path))
         self.set_status(204)
         self.finish()
 
 
 class CheckpointsHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('GET', 'POST')
 
     @web.authenticated
     @json_errors
     @gen.coroutine
     def get(self, path=''):
         """get lists checkpoints for a file"""
         cm = self.contents_manager
         checkpoints = yield gen.maybe_future(cm.list_checkpoints(path))
         data = json.dumps(checkpoints, default=date_default)
         self.finish(data)
 
     @web.authenticated
     @json_errors
     @gen.coroutine
     def post(self, path=''):
         """post creates a new checkpoint"""
         cm = self.contents_manager
         checkpoint = yield gen.maybe_future(cm.create_checkpoint(path))
         data = json.dumps(checkpoint, default=date_default)
         location = url_path_join(self.base_url, 'api/contents',
             path, 'checkpoints', checkpoint['id'])
         self.set_header('Location', url_escape(location))
         self.set_status(201)
         self.finish(data)
 
 
 class ModifyCheckpointsHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('POST', 'DELETE')
 
     @web.authenticated
     @json_errors
     @gen.coroutine
     def post(self, path, checkpoint_id):
         """post restores a file from a checkpoint"""
         cm = self.contents_manager
         yield gen.maybe_future(cm.restore_checkpoint(checkpoint_id, path))
         self.set_status(204)
         self.finish()
 
     @web.authenticated
     @json_errors
     @gen.coroutine
     def delete(self, path, checkpoint_id):
         """delete clears a checkpoint for a given file"""
         cm = self.contents_manager
         yield gen.maybe_future(cm.delete_checkpoint(checkpoint_id, path))
         self.set_status(204)
         self.finish()
 
 
 class NotebooksRedirectHandler(IPythonHandler):
     """Redirect /api/notebooks to /api/contents"""
     SUPPORTED_METHODS = ('GET', 'PUT', 'PATCH', 'POST', 'DELETE')
 
     def get(self, path):
         self.log.warn("/api/notebooks is deprecated, use /api/contents")
         self.redirect(url_path_join(
             self.base_url,
             'api/contents',
             path
         ))
 
     put = patch = post = delete = get
 
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 
 _checkpoint_id_regex = r"(?P<checkpoint_id>[\w-]+)"
 
 default_handlers = [
     (r"/api/contents%s/checkpoints" % path_regex, CheckpointsHandler),
     (r"/api/contents%s/checkpoints/%s" % (path_regex, _checkpoint_id_regex),
         ModifyCheckpointsHandler),
     (r"/api/contents%s" % path_regex, ContentsHandler),
     (r"/api/notebooks/?(.*)", NotebooksRedirectHandler),
 ]

jupyter_notebook/services/contents/tests/test_contents_api.py

@@ -1,694 +1,694
 # coding: utf-8
 """Test the contents webservice API."""
 
 import base64
 from contextlib import contextmanager
 import io
 import json
 import os
 import shutil
 from unicodedata import normalize
 
 pjoin = os.path.join
 
 import requests
 
 from ..filecheckpoints import GenericFileCheckpoints
 
 from IPython.config import Config
-from IPython.html.utils import url_path_join, url_escape, to_os_path
-from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
+from jupyter_notebook.utils import url_path_join, url_escape, to_os_path
+from jupyter_notebook.tests.launchnotebook import NotebookTestBase, assert_http_error
 from IPython.nbformat import read, write, from_dict
 from IPython.nbformat.v4 import (
     new_notebook, new_markdown_cell,
 )
 from IPython.nbformat import v2
 from IPython.utils import py3compat
 from IPython.utils.tempdir import TemporaryDirectory
 
 def uniq_stable(elems):
     """uniq_stable(elems) -> list
 
     Return from an iterable, a list of all the unique elements in the input,
     maintaining the order in which they first appear.
     """
     seen = set()
     return [x for x in elems if x not in seen and not seen.add(x)]
 
 def notebooks_only(dir_model):
     return [nb for nb in dir_model['content'] if nb['type']=='notebook']
 
 def dirs_only(dir_model):
     return [x for x in dir_model['content'] if x['type']=='directory']
 
 
 class API(object):
     """Wrapper for contents API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, path, body=None, params=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'api/contents', path),
                 data=body, params=params,
         )
         response.raise_for_status()
         return response
 
     def list(self, path='/'):
         return self._req('GET', path)
 
     def read(self, path, type=None, format=None, content=None):
         params = {}
         if type is not None:
             params['type'] = type
         if format is not None:
             params['format'] = format
         if content == False:
             params['content'] = '0'
         return self._req('GET', path, params=params)
 
     def create_untitled(self, path='/', ext='.ipynb'):
         body = None
         if ext:
             body = json.dumps({'ext': ext})
         return self._req('POST', path, body)
 
     def mkdir_untitled(self, path='/'):
         return self._req('POST', path, json.dumps({'type': 'directory'}))
 
     def copy(self, copy_from, path='/'):
         body = json.dumps({'copy_from':copy_from})
         return self._req('POST', path, body)
 
     def create(self, path='/'):
         return self._req('PUT', path)
 
     def upload(self, path, body):
         return self._req('PUT', path, body)
 
     def mkdir(self, path='/'):
         return self._req('PUT', path, json.dumps({'type': 'directory'}))
 
     def copy_put(self, copy_from, path='/'):
         body = json.dumps({'copy_from':copy_from})
         return self._req('PUT', path, body)
 
     def save(self, path, body):
         return self._req('PUT', path, body)
 
     def delete(self, path='/'):
         return self._req('DELETE', path)
 
     def rename(self, path, new_path):
         body = json.dumps({'path': new_path})
         return self._req('PATCH', path, body)
 
     def get_checkpoints(self,  path):
         return self._req('GET', url_path_join(path, 'checkpoints'))
 
     def new_checkpoint(self,  path):
         return self._req('POST', url_path_join(path, 'checkpoints'))
 
     def restore_checkpoint(self, path, checkpoint_id):
         return self._req('POST', url_path_join(path, 'checkpoints', checkpoint_id))
 
     def delete_checkpoint(self, path, checkpoint_id):
         return self._req('DELETE', url_path_join(path, 'checkpoints', checkpoint_id))
 
 class APITest(NotebookTestBase):
     """Test the kernels web service API"""
     dirs_nbs = [('', 'inroot'),
                 ('Directory with spaces in', 'inspace'),
                 (u'unicodé', 'innonascii'),
                 ('foo', 'a'),
                 ('foo', 'b'),
                 ('foo', 'name with spaces'),
                 ('foo', u'unicodé'),
                 ('foo/bar', 'baz'),
                 ('ordering', 'A'),
                 ('ordering', 'b'),
                 ('ordering', 'C'),
                 (u'å b', u'ç d'),
                ]
     hidden_dirs = ['.hidden', '__pycache__']
 
     # Don't include root dir.
     dirs = uniq_stable([py3compat.cast_unicode(d) for (d,n) in dirs_nbs[1:]])
     top_level_dirs = {normalize('NFC', d.split('/')[0]) for d in dirs}
 
     @staticmethod
     def _blob_for_name(name):
         return name.encode('utf-8') + b'\xFF'
 
     @staticmethod
     def _txt_for_name(name):
         return u'%s text file' % name
     
     def to_os_path(self, api_path):
         return to_os_path(api_path, root=self.notebook_dir.name)
     
     def make_dir(self, api_path):
         """Create a directory at api_path"""
         os_path = self.to_os_path(api_path)
         try:
             os.makedirs(os_path)
         except OSError:
             print("Directory already exists: %r" % os_path)
 
     def make_txt(self, api_path, txt):
         """Make a text file at a given api_path"""
         os_path = self.to_os_path(api_path)
         with io.open(os_path, 'w', encoding='utf-8') as f:
             f.write(txt)
     
     def make_blob(self, api_path, blob):
         """Make a binary file at a given api_path"""
         os_path = self.to_os_path(api_path)
         with io.open(os_path, 'wb') as f:
             f.write(blob)
     
     def make_nb(self, api_path, nb):
         """Make a notebook file at a given api_path"""
         os_path = self.to_os_path(api_path)
         
         with io.open(os_path, 'w', encoding='utf-8') as f:
             write(nb, f, version=4)
 
     def delete_dir(self, api_path):
         """Delete a directory at api_path, removing any contents."""
         os_path = self.to_os_path(api_path)
         shutil.rmtree(os_path, ignore_errors=True)
 
     def delete_file(self, api_path):
         """Delete a file at the given path if it exists."""
         if self.isfile(api_path):
             os.unlink(self.to_os_path(api_path))
     
     def isfile(self, api_path):
         return os.path.isfile(self.to_os_path(api_path))
     
     def isdir(self, api_path):
         return os.path.isdir(self.to_os_path(api_path))
     
     def setUp(self):
 
         for d in (self.dirs + self.hidden_dirs):
             self.make_dir(d)
 
         for d, name in self.dirs_nbs:
             # create a notebook
             nb = new_notebook()
             self.make_nb(u'{}/{}.ipynb'.format(d, name), nb)
             
             # create a text file
             txt = self._txt_for_name(name)
             self.make_txt(u'{}/{}.txt'.format(d, name), txt)
             
             # create a binary file
             blob = self._blob_for_name(name)
             self.make_blob(u'{}/{}.blob'.format(d, name), blob)
 
         self.api = API(self.base_url())
 
     def tearDown(self):
         for dname in (list(self.top_level_dirs) + self.hidden_dirs):
             self.delete_dir(dname)
         self.delete_file('inroot.ipynb')
 
     def test_list_notebooks(self):
         nbs = notebooks_only(self.api.list().json())
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'inroot.ipynb')
 
         nbs = notebooks_only(self.api.list('/Directory with spaces in/').json())
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'inspace.ipynb')
 
         nbs = notebooks_only(self.api.list(u'/unicodé/').json())
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'innonascii.ipynb')
         self.assertEqual(nbs[0]['path'], u'unicodé/innonascii.ipynb')
 
         nbs = notebooks_only(self.api.list('/foo/bar/').json())
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'baz.ipynb')
         self.assertEqual(nbs[0]['path'], 'foo/bar/baz.ipynb')
 
         nbs = notebooks_only(self.api.list('foo').json())
         self.assertEqual(len(nbs), 4)
         nbnames = { normalize('NFC', n['name']) for n in nbs }
         expected = [ u'a.ipynb', u'b.ipynb', u'name with spaces.ipynb', u'unicodé.ipynb']
         expected = { normalize('NFC', name) for name in expected }
         self.assertEqual(nbnames, expected)
 
         nbs = notebooks_only(self.api.list('ordering').json())
         nbnames = [n['name'] for n in nbs]
         expected = ['A.ipynb', 'b.ipynb', 'C.ipynb']
         self.assertEqual(nbnames, expected)
 
     def test_list_dirs(self):
         dirs = dirs_only(self.api.list().json())
         dir_names = {normalize('NFC', d['name']) for d in dirs}
         self.assertEqual(dir_names, self.top_level_dirs)  # Excluding hidden dirs
 
     def test_get_dir_no_content(self):
         for d in self.dirs:
             model = self.api.read(d, content=False).json()
             self.assertEqual(model['path'], d)
             self.assertEqual(model['type'], 'directory')
             self.assertIn('content', model)
             self.assertEqual(model['content'], None)
 
     def test_list_nonexistant_dir(self):
         with assert_http_error(404):
             self.api.list('nonexistant')
 
     def test_get_nb_contents(self):
         for d, name in self.dirs_nbs:
             path = url_path_join(d, name + '.ipynb')
             nb = self.api.read(path).json()
             self.assertEqual(nb['name'], u'%s.ipynb' % name)
             self.assertEqual(nb['path'], path)
             self.assertEqual(nb['type'], 'notebook')
             self.assertIn('content', nb)
             self.assertEqual(nb['format'], 'json')
             self.assertIn('metadata', nb['content'])
             self.assertIsInstance(nb['content']['metadata'], dict)
 
     def test_get_nb_no_content(self):
         for d, name in self.dirs_nbs:
             path = url_path_join(d, name + '.ipynb')
             nb = self.api.read(path, content=False).json()
             self.assertEqual(nb['name'], u'%s.ipynb' % name)
             self.assertEqual(nb['path'], path)
             self.assertEqual(nb['type'], 'notebook')
             self.assertIn('content', nb)
             self.assertEqual(nb['content'], None)
 
     def test_get_contents_no_such_file(self):
         # Name that doesn't exist - should be a 404
         with assert_http_error(404):
             self.api.read('foo/q.ipynb')
 
     def test_get_text_file_contents(self):
         for d, name in self.dirs_nbs:
             path = url_path_join(d, name + '.txt')
             model = self.api.read(path).json()
             self.assertEqual(model['name'], u'%s.txt' % name)
             self.assertEqual(model['path'], path)
             self.assertIn('content', model)
             self.assertEqual(model['format'], 'text')
             self.assertEqual(model['type'], 'file')
             self.assertEqual(model['content'], self._txt_for_name(name))
 
         # Name that doesn't exist - should be a 404
         with assert_http_error(404):
             self.api.read('foo/q.txt')
 
         # Specifying format=text should fail on a non-UTF-8 file
         with assert_http_error(400):
             self.api.read('foo/bar/baz.blob', type='file', format='text')
 
     def test_get_binary_file_contents(self):
         for d, name in self.dirs_nbs:
             path = url_path_join(d, name + '.blob')
             model = self.api.read(path).json()
             self.assertEqual(model['name'], u'%s.blob' % name)
             self.assertEqual(model['path'], path)
             self.assertIn('content', model)
             self.assertEqual(model['format'], 'base64')
             self.assertEqual(model['type'], 'file')
             self.assertEqual(
                 base64.decodestring(model['content'].encode('ascii')),
                 self._blob_for_name(name),
             )
 
         # Name that doesn't exist - should be a 404
         with assert_http_error(404):
             self.api.read('foo/q.txt')
 
     def test_get_bad_type(self):
         with assert_http_error(400):
             self.api.read(u'unicodé', type='file')  # this is a directory
 
         with assert_http_error(400):
             self.api.read(u'unicodé/innonascii.ipynb', type='directory')
 
     def _check_created(self, resp, path, type='notebook'):
         self.assertEqual(resp.status_code, 201)
         location_header = py3compat.str_to_unicode(resp.headers['Location'])
         self.assertEqual(location_header, url_escape(url_path_join(u'/api/contents', path)))
         rjson = resp.json()
         self.assertEqual(rjson['name'], path.rsplit('/', 1)[-1])
         self.assertEqual(rjson['path'], path)
         self.assertEqual(rjson['type'], type)
         isright = self.isdir if type == 'directory' else self.isfile
         assert isright(path)
 
     def test_create_untitled(self):
         resp = self.api.create_untitled(path=u'å b')
         self._check_created(resp, u'å b/Untitled.ipynb')
 
         # Second time
         resp = self.api.create_untitled(path=u'å b')
         self._check_created(resp, u'å b/Untitled1.ipynb')
 
         # And two directories down
         resp = self.api.create_untitled(path='foo/bar')
         self._check_created(resp, 'foo/bar/Untitled.ipynb')
 
     def test_create_untitled_txt(self):
         resp = self.api.create_untitled(path='foo/bar', ext='.txt')
         self._check_created(resp, 'foo/bar/untitled.txt', type='file')
 
         resp = self.api.read(path='foo/bar/untitled.txt')
         model = resp.json()
         self.assertEqual(model['type'], 'file')
         self.assertEqual(model['format'], 'text')
         self.assertEqual(model['content'], '')
 
     def test_upload(self):
         nb = new_notebook()
         nbmodel = {'content': nb, 'type': 'notebook'}
         path = u'å b/Upload tést.ipynb'
         resp = self.api.upload(path, body=json.dumps(nbmodel))
         self._check_created(resp, path)
 
     def test_mkdir_untitled(self):
         resp = self.api.mkdir_untitled(path=u'å b')
         self._check_created(resp, u'å b/Untitled Folder', type='directory')
 
         # Second time
         resp = self.api.mkdir_untitled(path=u'å b')
         self._check_created(resp, u'å b/Untitled Folder 1', type='directory')
 
         # And two directories down
         resp = self.api.mkdir_untitled(path='foo/bar')
         self._check_created(resp, 'foo/bar/Untitled Folder', type='directory')
 
     def test_mkdir(self):
         path = u'å b/New ∂ir'
         resp = self.api.mkdir(path)
         self._check_created(resp, path, type='directory')
 
     def test_mkdir_hidden_400(self):
         with assert_http_error(400):
             resp = self.api.mkdir(u'å b/.hidden')
 
     def test_upload_txt(self):
         body = u'ünicode téxt'
         model = {
             'content' : body,
             'format'  : 'text',
             'type'    : 'file',
         }
         path = u'å b/Upload tést.txt'
         resp = self.api.upload(path, body=json.dumps(model))
 
         # check roundtrip
         resp = self.api.read(path)
         model = resp.json()
         self.assertEqual(model['type'], 'file')
         self.assertEqual(model['format'], 'text')
         self.assertEqual(model['content'], body)
 
     def test_upload_b64(self):
         body = b'\xFFblob'
         b64body = base64.encodestring(body).decode('ascii')
         model = {
             'content' : b64body,
             'format'  : 'base64',
             'type'    : 'file',
         }
         path = u'å b/Upload tést.blob'
         resp = self.api.upload(path, body=json.dumps(model))
 
         # check roundtrip
         resp = self.api.read(path)
         model = resp.json()
         self.assertEqual(model['type'], 'file')
         self.assertEqual(model['path'], path)
         self.assertEqual(model['format'], 'base64')
         decoded = base64.decodestring(model['content'].encode('ascii'))
         self.assertEqual(decoded, body)
 
     def test_upload_v2(self):
         nb = v2.new_notebook()
         ws = v2.new_worksheet()
         nb.worksheets.append(ws)
         ws.cells.append(v2.new_code_cell(input='print("hi")'))
         nbmodel = {'content': nb, 'type': 'notebook'}
         path = u'å b/Upload tést.ipynb'
         resp = self.api.upload(path, body=json.dumps(nbmodel))
         self._check_created(resp, path)
         resp = self.api.read(path)
         data = resp.json()
         self.assertEqual(data['content']['nbformat'], 4)
 
     def test_copy(self):
         resp = self.api.copy(u'å b/ç d.ipynb', u'å b')
         self._check_created(resp, u'å b/ç d-Copy1.ipynb')
         
         resp = self.api.copy(u'å b/ç d.ipynb', u'å b')
         self._check_created(resp, u'å b/ç d-Copy2.ipynb')
     
     def test_copy_copy(self):
         resp = self.api.copy(u'å b/ç d.ipynb', u'å b')
         self._check_created(resp, u'å b/ç d-Copy1.ipynb')
         
         resp = self.api.copy(u'å b/ç d-Copy1.ipynb', u'å b')
         self._check_created(resp, u'å b/ç d-Copy2.ipynb')
     
     def test_copy_path(self):
         resp = self.api.copy(u'foo/a.ipynb', u'å b')
         self._check_created(resp, u'å b/a.ipynb')
         
         resp = self.api.copy(u'foo/a.ipynb', u'å b')
         self._check_created(resp, u'å b/a-Copy1.ipynb')
 
     def test_copy_put_400(self):
         with assert_http_error(400):
             resp = self.api.copy_put(u'å b/ç d.ipynb', u'å b/cøpy.ipynb')
 
     def test_copy_dir_400(self):
         # can't copy directories
         with assert_http_error(400):
             resp = self.api.copy(u'å b', u'foo')
 
     def test_delete(self):
         for d, name in self.dirs_nbs:
             print('%r, %r' % (d, name))
             resp = self.api.delete(url_path_join(d, name + '.ipynb'))
             self.assertEqual(resp.status_code, 204)
 
         for d in self.dirs + ['/']:
             nbs = notebooks_only(self.api.list(d).json())
             print('------')
             print(d)
             print(nbs)
             self.assertEqual(nbs, [])
 
     def test_delete_dirs(self):
         # depth-first delete everything, so we don't try to delete empty directories
         for name in sorted(self.dirs + ['/'], key=len, reverse=True):
             listing = self.api.list(name).json()['content']
             for model in listing:
                 self.api.delete(model['path'])
         listing = self.api.list('/').json()['content']
         self.assertEqual(listing, [])
 
     def test_delete_non_empty_dir(self):
         """delete non-empty dir raises 400"""
         with assert_http_error(400):
             self.api.delete(u'å b')
 
     def test_rename(self):
         resp = self.api.rename('foo/a.ipynb', 'foo/z.ipynb')
         self.assertEqual(resp.headers['Location'].split('/')[-1], 'z.ipynb')
         self.assertEqual(resp.json()['name'], 'z.ipynb')
         self.assertEqual(resp.json()['path'], 'foo/z.ipynb')
         assert self.isfile('foo/z.ipynb')
 
         nbs = notebooks_only(self.api.list('foo').json())
         nbnames = set(n['name'] for n in nbs)
         self.assertIn('z.ipynb', nbnames)
         self.assertNotIn('a.ipynb', nbnames)
 
     def test_checkpoints_follow_file(self):
 
         # Read initial file state
         orig = self.api.read('foo/a.ipynb')
 
         # Create a checkpoint of initial state
         r = self.api.new_checkpoint('foo/a.ipynb')
         cp1 = r.json()
 
         # Modify file and save
         nbcontent = json.loads(orig.text)['content']
         nb = from_dict(nbcontent)
         hcell = new_markdown_cell('Created by test')
         nb.cells.append(hcell)
         nbmodel = {'content': nb, 'type': 'notebook'}
         self.api.save('foo/a.ipynb', body=json.dumps(nbmodel))
 
         # Rename the file.
         self.api.rename('foo/a.ipynb', 'foo/z.ipynb')
 
         # Looking for checkpoints in the old location should yield no results.
         self.assertEqual(self.api.get_checkpoints('foo/a.ipynb').json(), [])
 
         # Looking for checkpoints in the new location should work.
         cps = self.api.get_checkpoints('foo/z.ipynb').json()
         self.assertEqual(cps, [cp1])
 
         # Delete the file.  The checkpoint should be deleted as well.
         self.api.delete('foo/z.ipynb')
         cps = self.api.get_checkpoints('foo/z.ipynb').json()
         self.assertEqual(cps, [])
 
     def test_rename_existing(self):
         with assert_http_error(409):
             self.api.rename('foo/a.ipynb', 'foo/b.ipynb')
 
     def test_save(self):
         resp = self.api.read('foo/a.ipynb')
         nbcontent = json.loads(resp.text)['content']
         nb = from_dict(nbcontent)
         nb.cells.append(new_markdown_cell(u'Created by test ³'))
 
         nbmodel = {'content': nb, 'type': 'notebook'}
         resp = self.api.save('foo/a.ipynb', body=json.dumps(nbmodel))
 
         nbcontent = self.api.read('foo/a.ipynb').json()['content']
         newnb = from_dict(nbcontent)
         self.assertEqual(newnb.cells[0].source,
                          u'Created by test ³')
 
     def test_checkpoints(self):
         resp = self.api.read('foo/a.ipynb')
         r = self.api.new_checkpoint('foo/a.ipynb')
         self.assertEqual(r.status_code, 201)
         cp1 = r.json()
         self.assertEqual(set(cp1), {'id', 'last_modified'})
         self.assertEqual(r.headers['Location'].split('/')[-1], cp1['id'])
 
         # Modify it
         nbcontent = json.loads(resp.text)['content']
         nb = from_dict(nbcontent)
         hcell = new_markdown_cell('Created by test')
         nb.cells.append(hcell)
         # Save
         nbmodel= {'content': nb, 'type': 'notebook'}
         resp = self.api.save('foo/a.ipynb', body=json.dumps(nbmodel))
 
         # List checkpoints
         cps = self.api.get_checkpoints('foo/a.ipynb').json()
         self.assertEqual(cps, [cp1])
 
         nbcontent = self.api.read('foo/a.ipynb').json()['content']
         nb = from_dict(nbcontent)
         self.assertEqual(nb.cells[0].source, 'Created by test')
 
         # Restore cp1
         r = self.api.restore_checkpoint('foo/a.ipynb', cp1['id'])
         self.assertEqual(r.status_code, 204)
         nbcontent = self.api.read('foo/a.ipynb').json()['content']
         nb = from_dict(nbcontent)
         self.assertEqual(nb.cells, [])
 
         # Delete cp1
         r = self.api.delete_checkpoint('foo/a.ipynb', cp1['id'])
         self.assertEqual(r.status_code, 204)
         cps = self.api.get_checkpoints('foo/a.ipynb').json()
         self.assertEqual(cps, [])
 
     def test_file_checkpoints(self):
         """
         Test checkpointing of non-notebook files.
         """
         filename = 'foo/a.txt'
         resp = self.api.read(filename)
         orig_content = json.loads(resp.text)['content']
 
         # Create a checkpoint.
         r = self.api.new_checkpoint(filename)
         self.assertEqual(r.status_code, 201)
         cp1 = r.json()
         self.assertEqual(set(cp1), {'id', 'last_modified'})
         self.assertEqual(r.headers['Location'].split('/')[-1], cp1['id'])
 
         # Modify the file and save.
         new_content = orig_content + '\nsecond line'
         model = {
             'content': new_content,
             'type': 'file',
             'format': 'text',
         }
         resp = self.api.save(filename, body=json.dumps(model))
 
         # List checkpoints
         cps = self.api.get_checkpoints(filename).json()
         self.assertEqual(cps, [cp1])
 
         content = self.api.read(filename).json()['content']
         self.assertEqual(content, new_content)
 
         # Restore cp1
         r = self.api.restore_checkpoint(filename, cp1['id'])
         self.assertEqual(r.status_code, 204)
         restored_content = self.api.read(filename).json()['content']
         self.assertEqual(restored_content, orig_content)
 
         # Delete cp1
         r = self.api.delete_checkpoint(filename, cp1['id'])
         self.assertEqual(r.status_code, 204)
         cps = self.api.get_checkpoints(filename).json()
         self.assertEqual(cps, [])
 
     @contextmanager
     def patch_cp_root(self, dirname):
         """
         Temporarily patch the root dir of our checkpoint manager.
         """
         cpm = self.notebook.contents_manager.checkpoints
         old_dirname = cpm.root_dir
         cpm.root_dir = dirname
         try:
             yield
         finally:
             cpm.root_dir = old_dirname
 
     def test_checkpoints_separate_root(self):
         """
         Test that FileCheckpoints functions correctly even when it's
         using a different root dir from FileContentsManager.  This also keeps
         the implementation honest for use with ContentsManagers that don't map
         models to the filesystem
 
         Override this method to a no-op when testing other managers.
         """
         with TemporaryDirectory() as td:
             with self.patch_cp_root(td):
                 self.test_checkpoints()
 
         with TemporaryDirectory() as td:
             with self.patch_cp_root(td):
                 self.test_file_checkpoints()
 
 
 class GenericFileCheckpointsAPITest(APITest):
     """
     Run the tests from APITest with GenericFileCheckpoints.
     """
     config = Config()
     config.FileContentsManager.checkpoints_class = GenericFileCheckpoints
 
     def test_config_did_something(self):
 
         self.assertIsInstance(
             self.notebook.contents_manager.checkpoints,
             GenericFileCheckpoints,
         )
 
 

jupyter_notebook/services/kernels/handlers.py

@@ -1,288 +1,288
 """Tornado handlers for kernels."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
 import logging
 from tornado import gen, web
 from tornado.concurrent import Future
 from tornado.ioloop import IOLoop
 
 from jupyter_client.jsonutil import date_default
 from IPython.utils.py3compat import cast_unicode
-from IPython.html.utils import url_path_join, url_escape
+from jupyter_notebook.utils import url_path_join, url_escape
 
 from ...base.handlers import IPythonHandler, json_errors
 from ...base.zmqhandlers import AuthenticatedZMQStreamHandler, deserialize_binary_message
 
 from IPython.core.release import kernel_protocol_version
 
 class MainKernelHandler(IPythonHandler):
 
     @web.authenticated
     @json_errors
     def get(self):
         km = self.kernel_manager
         self.finish(json.dumps(km.list_kernels()))
 
     @web.authenticated
     @json_errors
     def post(self):
         km = self.kernel_manager
         model = self.get_json_body()
         if model is None:
             model = {
                 'name': km.default_kernel_name
             }
         else:
             model.setdefault('name', km.default_kernel_name)
 
         kernel_id = km.start_kernel(kernel_name=model['name'])
         model = km.kernel_model(kernel_id)
         location = url_path_join(self.base_url, 'api', 'kernels', kernel_id)
         self.set_header('Location', url_escape(location))
         self.set_status(201)
         self.finish(json.dumps(model))
 
 
 class KernelHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('DELETE', 'GET')
 
     @web.authenticated
     @json_errors
     def get(self, kernel_id):
         km = self.kernel_manager
         km._check_kernel_id(kernel_id)
         model = km.kernel_model(kernel_id)
         self.finish(json.dumps(model))
 
     @web.authenticated
     @json_errors
     def delete(self, kernel_id):
         km = self.kernel_manager
         km.shutdown_kernel(kernel_id)
         self.set_status(204)
         self.finish()
 
 
 class KernelActionHandler(IPythonHandler):
 
     @web.authenticated
     @json_errors
     def post(self, kernel_id, action):
         km = self.kernel_manager
         if action == 'interrupt':
             km.interrupt_kernel(kernel_id)
             self.set_status(204)
         if action == 'restart':
             km.restart_kernel(kernel_id)
             model = km.kernel_model(kernel_id)
             self.set_header('Location', '{0}api/kernels/{1}'.format(self.base_url, kernel_id))
             self.write(json.dumps(model))
         self.finish()
 
 
 class ZMQChannelsHandler(AuthenticatedZMQStreamHandler):
     
     @property
     def kernel_info_timeout(self):
         return self.settings.get('kernel_info_timeout', 10)
     
     def __repr__(self):
         return "%s(%s)" % (self.__class__.__name__, getattr(self, 'kernel_id', 'uninitialized'))
     
     def create_stream(self):
         km = self.kernel_manager
         identity = self.session.bsession
         for channel in ('shell', 'iopub', 'stdin'):
             meth = getattr(km, 'connect_' + channel)
             self.channels[channel] = stream = meth(self.kernel_id, identity=identity)
             stream.channel = channel
         km.add_restart_callback(self.kernel_id, self.on_kernel_restarted)
         km.add_restart_callback(self.kernel_id, self.on_restart_failed, 'dead')
     
     def request_kernel_info(self):
         """send a request for kernel_info"""
         km = self.kernel_manager
         kernel = km.get_kernel(self.kernel_id)
         try:
             # check for previous request
             future = kernel._kernel_info_future
         except AttributeError:
             self.log.debug("Requesting kernel info from %s", self.kernel_id)
             # Create a kernel_info channel to query the kernel protocol version.
             # This channel will be closed after the kernel_info reply is received.
             if self.kernel_info_channel is None:
                 self.kernel_info_channel = km.connect_shell(self.kernel_id)
             self.kernel_info_channel.on_recv(self._handle_kernel_info_reply)
             self.session.send(self.kernel_info_channel, "kernel_info_request")
             # store the future on the kernel, so only one request is sent
             kernel._kernel_info_future = self._kernel_info_future
         else:
             if not future.done():
                 self.log.debug("Waiting for pending kernel_info request")
             future.add_done_callback(lambda f: self._finish_kernel_info(f.result()))
         return self._kernel_info_future
     
     def _handle_kernel_info_reply(self, msg):
         """process the kernel_info_reply
         
         enabling msg spec adaptation, if necessary
         """
         idents,msg = self.session.feed_identities(msg)
         try:
             msg = self.session.deserialize(msg)
         except:
             self.log.error("Bad kernel_info reply", exc_info=True)
             self._kernel_info_future.set_result({})
             return
         else:
             info = msg['content']
             self.log.debug("Received kernel info: %s", info)
             if msg['msg_type'] != 'kernel_info_reply' or 'protocol_version' not in info:
                 self.log.error("Kernel info request failed, assuming current %s", info)
                 info = {}
             self._finish_kernel_info(info)
         
         # close the kernel_info channel, we don't need it anymore
         if self.kernel_info_channel:
             self.kernel_info_channel.close()
         self.kernel_info_channel = None
     
     def _finish_kernel_info(self, info):
         """Finish handling kernel_info reply
         
         Set up protocol adaptation, if needed,
         and signal that connection can continue.
         """
         protocol_version = info.get('protocol_version', kernel_protocol_version)
         if protocol_version != kernel_protocol_version:
             self.session.adapt_version = int(protocol_version.split('.')[0])
             self.log.info("Adapting to protocol v%s for kernel %s", protocol_version, self.kernel_id)
         if not self._kernel_info_future.done():
             self._kernel_info_future.set_result(info)
     
     def initialize(self):
         super(ZMQChannelsHandler, self).initialize()
         self.zmq_stream = None
         self.channels = {}
         self.kernel_id = None
         self.kernel_info_channel = None
         self._kernel_info_future = Future()
     
     @gen.coroutine
     def pre_get(self):
         # authenticate first
         super(ZMQChannelsHandler, self).pre_get()
         # then request kernel info, waiting up to a certain time before giving up.
         # We don't want to wait forever, because browsers don't take it well when
         # servers never respond to websocket connection requests.
         kernel = self.kernel_manager.get_kernel(self.kernel_id)
         self.session.key = kernel.session.key
         future = self.request_kernel_info()
         
         def give_up():
             """Don't wait forever for the kernel to reply"""
             if future.done():
                 return
             self.log.warn("Timeout waiting for kernel_info reply from %s", self.kernel_id)
             future.set_result({})
         loop = IOLoop.current()
         loop.add_timeout(loop.time() + self.kernel_info_timeout, give_up)
         # actually wait for it
         yield future
     
     @gen.coroutine
     def get(self, kernel_id):
         self.kernel_id = cast_unicode(kernel_id, 'ascii')
         yield super(ZMQChannelsHandler, self).get(kernel_id=kernel_id)
     
     def open(self, kernel_id):
         super(ZMQChannelsHandler, self).open()
         try:
             self.create_stream()
         except web.HTTPError as e:
             self.log.error("Error opening stream: %s", e)
             # WebSockets don't response to traditional error codes so we
             # close the connection.
             for channel, stream in self.channels.items():
                 if not stream.closed():
                     stream.close()
             self.close()
         else:
             for channel, stream in self.channels.items():
                 stream.on_recv_stream(self._on_zmq_reply)
 
     def on_message(self, msg):
         if not self.channels:
             # already closed, ignore the message
             self.log.debug("Received message on closed websocket %r", msg)
             return
         if isinstance(msg, bytes):
             msg = deserialize_binary_message(msg)
         else:
             msg = json.loads(msg)
         channel = msg.pop('channel', None)
         if channel is None:
             self.log.warn("No channel specified, assuming shell: %s", msg)
             channel = 'shell'
         if channel not in self.channels:
             self.log.warn("No such channel: %r", channel)
             return
         stream = self.channels[channel]
         self.session.send(stream, msg)
 
     def on_close(self):
         km = self.kernel_manager
         if self.kernel_id in km:
             km.remove_restart_callback(
                 self.kernel_id, self.on_kernel_restarted,
             )
             km.remove_restart_callback(
                 self.kernel_id, self.on_restart_failed, 'dead',
             )
         # 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.
         for channel, stream in self.channels.items():
             if stream is not None and not stream.closed():
                 stream.on_recv(None)
                 # close the socket directly, don't wait for the stream
                 socket = stream.socket
                 stream.close()
                 socket.close()
         
         self.channels = {}
 
     def _send_status_message(self, status):
         msg = self.session.msg("status",
             {'execution_state': status}
         )
         msg['channel'] = 'iopub'
         self.write_message(json.dumps(msg, default=date_default))
 
     def on_kernel_restarted(self):
         logging.warn("kernel %s restarted", self.kernel_id)
         self._send_status_message('restarting')
 
     def on_restart_failed(self):
         logging.error("kernel %s restarted failed!", self.kernel_id)
         self._send_status_message('dead')
 
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 
 _kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
 _kernel_action_regex = r"(?P<action>restart|interrupt)"
 
 default_handlers = [
     (r"/api/kernels", MainKernelHandler),
     (r"/api/kernels/%s" % _kernel_id_regex, KernelHandler),
     (r"/api/kernels/%s/%s" % (_kernel_id_regex, _kernel_action_regex), KernelActionHandler),
     (r"/api/kernels/%s/channels" % _kernel_id_regex, ZMQChannelsHandler),
 ]

jupyter_notebook/services/kernels/kernelmanager.py

@@ -1,123 +1,123
 """A MultiKernelManager for use in the notebook webserver
 
 - raises HTTPErrors
 - creates REST API models
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 
 from tornado import web
 
 from IPython.kernel.multikernelmanager import MultiKernelManager
 from IPython.utils.traitlets import List, Unicode, TraitError
 
-from IPython.html.utils import to_os_path
+from jupyter_notebook.utils import to_os_path
 from IPython.utils.py3compat import getcwd
 
 
 class MappingKernelManager(MultiKernelManager):
     """A KernelManager that handles notebook mapping and HTTP error handling"""
 
     def _kernel_manager_class_default(self):
         return "IPython.kernel.ioloop.IOLoopKernelManager"
 
     kernel_argv = List(Unicode)
 
     root_dir = Unicode(config=True)
 
     def _root_dir_default(self):
         try:
             return self.parent.notebook_dir
         except AttributeError:
             return getcwd()
 
     def _root_dir_changed(self, name, old, new):
         """Do a bit of validation of the root dir."""
         if not os.path.isabs(new):
             # If we receive a non-absolute path, make it absolute.
             self.root_dir = os.path.abspath(new)
             return
         if not os.path.exists(new) or not os.path.isdir(new):
             raise TraitError("kernel root dir %r is not a directory" % new)
 
     #-------------------------------------------------------------------------
     # Methods for managing kernels and sessions
     #-------------------------------------------------------------------------
 
     def _handle_kernel_died(self, kernel_id):
         """notice that a kernel died"""
         self.log.warn("Kernel %s died, removing from map.", kernel_id)
         self.remove_kernel(kernel_id)
 
     def cwd_for_path(self, path):
         """Turn API path into absolute OS path."""
         os_path = to_os_path(path, self.root_dir)
         # in the case of notebooks and kernels not being on the same filesystem,
         # walk up to root_dir if the paths don't exist
         while not os.path.isdir(os_path) and os_path != self.root_dir:
             os_path = os.path.dirname(os_path)
         return os_path
 
     def start_kernel(self, kernel_id=None, path=None, **kwargs):
         """Start a kernel for a session and return its kernel_id.
 
         Parameters
         ----------
         kernel_id : uuid
             The uuid to associate the new kernel with. If this
             is not None, this kernel will be persistent whenever it is
             requested.
         path : API path
             The API path (unicode, '/' delimited) for the cwd.
             Will be transformed to an OS path relative to root_dir.
         kernel_name : str
             The name identifying which kernel spec to launch. This is ignored if
             an existing kernel is returned, but it may be checked in the future.
         """
         if kernel_id is None:
             if path is not None:
                 kwargs['cwd'] = self.cwd_for_path(path)
             kernel_id = super(MappingKernelManager, self).start_kernel(
                                             **kwargs)
             self.log.info("Kernel started: %s" % kernel_id)
             self.log.debug("Kernel args: %r" % kwargs)
             # register callback for failed auto-restart
             self.add_restart_callback(kernel_id,
                 lambda : self._handle_kernel_died(kernel_id),
                 'dead',
             )
         else:
             self._check_kernel_id(kernel_id)
             self.log.info("Using existing kernel: %s" % kernel_id)
         return kernel_id
 
     def shutdown_kernel(self, kernel_id, now=False):
         """Shutdown a kernel by kernel_id"""
         self._check_kernel_id(kernel_id)
         super(MappingKernelManager, self).shutdown_kernel(kernel_id, now=now)
 
     def kernel_model(self, kernel_id):
         """Return a dictionary of kernel information described in the
         JSON standard model."""
         self._check_kernel_id(kernel_id)
         model = {"id":kernel_id,
                  "name": self._kernels[kernel_id].kernel_name}
         return model
 
     def list_kernels(self):
         """Returns a list of kernel_id's of kernels running."""
         kernels = []
         kernel_ids = super(MappingKernelManager, self).list_kernel_ids()
         for kernel_id in kernel_ids:
             model = self.kernel_model(kernel_id)
             kernels.append(model)
         return kernels
 
     # override _check_kernel_id to raise 404 instead of KeyError
     def _check_kernel_id(self, kernel_id):
         """Check a that a kernel_id exists and raise 404 if not."""
         if kernel_id not in self:
             raise web.HTTPError(404, u'Kernel does not exist: %s' % kernel_id)

jupyter_notebook/services/kernels/tests/test_kernels_api.py

@@ -1,141 +1,141
 """Test the kernels service API."""
 
 import json
 import requests
 
 from jupyter_client.kernelspec import NATIVE_KERNEL_NAME
 
-from IPython.html.utils import url_path_join
-from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
+from jupyter_notebook.utils import url_path_join
+from jupyter_notebook.tests.launchnotebook import NotebookTestBase, assert_http_error
 
 class KernelAPI(object):
     """Wrapper for kernel REST API requests"""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, path, body=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'api/kernels', path), data=body)
 
         if 400 <= response.status_code < 600:
             try:
                 response.reason = response.json()['message']
             except:
                 pass
         response.raise_for_status()
 
         return response
 
     def list(self):
         return self._req('GET', '')
 
     def get(self, id):
         return self._req('GET', id)
 
     def start(self, name=NATIVE_KERNEL_NAME):
         body = json.dumps({'name': name})
         return self._req('POST', '', body)
 
     def shutdown(self, id):
         return self._req('DELETE', id)
 
     def interrupt(self, id):
         return self._req('POST', url_path_join(id, 'interrupt'))
 
     def restart(self, id):
         return self._req('POST', url_path_join(id, 'restart'))
 
 class KernelAPITest(NotebookTestBase):
     """Test the kernels web service API"""
     def setUp(self):
         self.kern_api = KernelAPI(self.base_url())
 
     def tearDown(self):
         for k in self.kern_api.list().json():
             self.kern_api.shutdown(k['id'])
 
     def test_no_kernels(self):
         """Make sure there are no kernels running at the start"""
         kernels = self.kern_api.list().json()
         self.assertEqual(kernels, [])
 
     def test_default_kernel(self):
         # POST request
         r = self.kern_api._req('POST', '')
         kern1 = r.json()
         self.assertEqual(r.headers['location'], '/api/kernels/' + kern1['id'])
         self.assertEqual(r.status_code, 201)
         self.assertIsInstance(kern1, dict)
 
         self.assertEqual(r.headers['Content-Security-Policy'], (
                             "frame-ancestors 'self'; "
                             "report-uri /api/security/csp-report;"
         ))
 
     def test_main_kernel_handler(self):
         # POST request
         r = self.kern_api.start()
         kern1 = r.json()
         self.assertEqual(r.headers['location'], '/api/kernels/' + kern1['id'])
         self.assertEqual(r.status_code, 201)
         self.assertIsInstance(kern1, dict)
 
         self.assertEqual(r.headers['Content-Security-Policy'], (
                             "frame-ancestors 'self'; "
                             "report-uri /api/security/csp-report;"
         ))
 
         # GET request
         r = self.kern_api.list()
         self.assertEqual(r.status_code, 200)
         assert isinstance(r.json(), list)
         self.assertEqual(r.json()[0]['id'], kern1['id'])
         self.assertEqual(r.json()[0]['name'], kern1['name'])
 
         # create another kernel and check that they both are added to the
         # list of kernels from a GET request
         kern2 = self.kern_api.start().json()
         assert isinstance(kern2, dict)
         r = self.kern_api.list()
         kernels = r.json()
         self.assertEqual(r.status_code, 200)
         assert isinstance(kernels, list)
         self.assertEqual(len(kernels), 2)
 
         # Interrupt a kernel
         r = self.kern_api.interrupt(kern2['id'])
         self.assertEqual(r.status_code, 204)
 
         # Restart a kernel
         r = self.kern_api.restart(kern2['id'])
         self.assertEqual(r.headers['Location'], '/api/kernels/'+kern2['id'])
         rekern = r.json()
         self.assertEqual(rekern['id'], kern2['id'])
         self.assertEqual(rekern['name'], kern2['name'])
 
     def test_kernel_handler(self):
         # GET kernel with given id
         kid = self.kern_api.start().json()['id']
         r = self.kern_api.get(kid)
         kern1 = r.json()
         self.assertEqual(r.status_code, 200)
         assert isinstance(kern1, dict)
         self.assertIn('id', kern1)
         self.assertEqual(kern1['id'], kid)
 
         # Request a bad kernel id and check that a JSON
         # message is returned!
         bad_id = '111-111-111-111-111'
         with assert_http_error(404, 'Kernel does not exist: ' + bad_id):
             self.kern_api.get(bad_id)
 
         # DELETE kernel with id
         r = self.kern_api.shutdown(kid)
         self.assertEqual(r.status_code, 204)
         kernels = self.kern_api.list().json()
         self.assertEqual(kernels, [])
 
         # Request to delete a non-existent kernel id
         bad_id = '111-111-111-111-111'
         with assert_http_error(404, 'Kernel does not exist: ' + bad_id):
             self.kern_api.shutdown(bad_id)

jupyter_notebook/services/kernelspecs/tests/test_kernelspecs_api.py

@@ -1,130 +1,130
 # coding: utf-8
 """Test the kernel specs webservice API."""
 
 import errno
 import io
 import json
 import os
 import shutil
 
 pjoin = os.path.join
 
 import requests
 
 from IPython.kernel.kernelspec import NATIVE_KERNEL_NAME
-from IPython.html.utils import url_path_join
-from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
+from jupyter_notebook.utils import url_path_join
+from jupyter_notebook.tests.launchnotebook import NotebookTestBase, assert_http_error
 
 # Copied from IPython.kernel.tests.test_kernelspec so updating that doesn't
 # break these tests
 sample_kernel_json = {'argv':['cat', '{connection_file}'],
                       'display_name':'Test kernel',
                      }
 
 some_resource = u"The very model of a modern major general"
 
 
 class KernelSpecAPI(object):
     """Wrapper for notebook API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, path, body=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, path),
                 data=body,
         )
         response.raise_for_status()
         return response
 
     def list(self):
         return self._req('GET', 'api/kernelspecs')
 
     def kernel_spec_info(self, name):
         return self._req('GET', url_path_join('api/kernelspecs', name))
     
     def kernel_resource(self, name, path):
         return self._req('GET', url_path_join('kernelspecs', name, path))
 
 class APITest(NotebookTestBase):
     """Test the kernelspec web service API"""
     def setUp(self):
         ipydir = self.ipython_dir.name
         sample_kernel_dir = pjoin(ipydir, 'kernels', 'sample')
         try:
             os.makedirs(sample_kernel_dir)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
         
         with open(pjoin(sample_kernel_dir, 'kernel.json'), 'w') as f:
             json.dump(sample_kernel_json, f)
         
         with io.open(pjoin(sample_kernel_dir, 'resource.txt'), 'w',
                      encoding='utf-8') as f:
             f.write(some_resource)
 
         self.ks_api = KernelSpecAPI(self.base_url())
 
     def test_list_kernelspecs_bad(self):
         """Can list kernelspecs when one is invalid"""
         bad_kernel_dir = pjoin(self.ipython_dir.name, 'kernels', 'bad')
         try:
             os.makedirs(bad_kernel_dir)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
         
         with open(pjoin(bad_kernel_dir, 'kernel.json'), 'w') as f:
             f.write("garbage")
         
         model = self.ks_api.list().json()
         assert isinstance(model, dict)
         self.assertEqual(model['default'], NATIVE_KERNEL_NAME)
         specs = model['kernelspecs']
         assert isinstance(specs, dict)
         # 2: the sample kernelspec created in setUp, and the native Python kernel
         self.assertGreaterEqual(len(specs), 2)
         
         shutil.rmtree(bad_kernel_dir)
     
     def test_list_kernelspecs(self):
         model = self.ks_api.list().json()
         assert isinstance(model, dict)
         self.assertEqual(model['default'], NATIVE_KERNEL_NAME)
         specs = model['kernelspecs']
         assert isinstance(specs, dict)
 
         # 2: the sample kernelspec created in setUp, and the native Python kernel
         self.assertGreaterEqual(len(specs), 2)
 
         def is_sample_kernelspec(s):
             return s['name'] == 'sample' and s['spec']['display_name'] == 'Test kernel'
 
         def is_default_kernelspec(s):
             return s['name'] == NATIVE_KERNEL_NAME and s['spec']['display_name'].startswith("Python")
 
         assert any(is_sample_kernelspec(s) for s in specs.values()), specs
         assert any(is_default_kernelspec(s) for s in specs.values()), specs
 
     def test_get_kernelspec(self):
         model = self.ks_api.kernel_spec_info('Sample').json()  # Case insensitive
         self.assertEqual(model['name'].lower(), 'sample')
         self.assertIsInstance(model['spec'], dict)
         self.assertEqual(model['spec']['display_name'], 'Test kernel')
         self.assertIsInstance(model['resources'], dict)
 
     def test_get_nonexistant_kernelspec(self):
         with assert_http_error(404):
             self.ks_api.kernel_spec_info('nonexistant')
     
     def test_get_kernel_resource_file(self):
         res = self.ks_api.kernel_resource('sAmple', 'resource.txt')
         self.assertEqual(res.text, some_resource)
     
     def test_get_nonexistant_resource(self):
         with assert_http_error(404):
             self.ks_api.kernel_resource('nonexistant', 'resource.txt')
         
         with assert_http_error(404):
             self.ks_api.kernel_resource('sample', 'nonexistant.txt')

jupyter_notebook/services/nbconvert/tests/test_nbconvert_api.py

@@ -1,31 +1,31
 import requests
 
-from IPython.html.utils import url_path_join
-from IPython.html.tests.launchnotebook import NotebookTestBase
+from jupyter_notebook.utils import url_path_join
+from jupyter_notebook.tests.launchnotebook import NotebookTestBase
 
 class NbconvertAPI(object):
     """Wrapper for nbconvert API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, path, body=None, params=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'api/nbconvert', path),
                 data=body, params=params,
         )
         response.raise_for_status()
         return response
 
     def list_formats(self):
         return self._req('GET', '')
 
 class APITest(NotebookTestBase):
     def setUp(self):
         self.nbconvert_api = NbconvertAPI(self.base_url())
 
     def test_list_formats(self):
         formats = self.nbconvert_api.list_formats().json()
         self.assertIsInstance(formats, dict)
         self.assertIn('python', formats)
         self.assertIn('html', formats)
         self.assertEqual(formats['python']['output_mimetype'], 'text/x-python')
  No newline at end of file

jupyter_notebook/services/sessions/handlers.py

@@ -1,122 +1,122
 """Tornado handlers for the sessions web service."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
 
 from tornado import web
 
 from ...base.handlers import IPythonHandler, json_errors
 from jupyter_client.jsonutil import date_default
-from IPython.html.utils import url_path_join, url_escape
+from jupyter_notebook.utils import url_path_join, url_escape
 from IPython.kernel.kernelspec import NoSuchKernel
 
 
 class SessionRootHandler(IPythonHandler):
 
     @web.authenticated
     @json_errors
     def get(self):
         # Return a list of running sessions
         sm = self.session_manager
         sessions = sm.list_sessions()
         self.finish(json.dumps(sessions, default=date_default))
 
     @web.authenticated
     @json_errors
     def post(self):
         # Creates a new session
         #(unless a session already exists for the named nb)
         sm = self.session_manager
         cm = self.contents_manager
         km = self.kernel_manager
 
         model = self.get_json_body()
         if model is None:
             raise web.HTTPError(400, "No JSON data provided")
         try:
             path = model['notebook']['path']
         except KeyError:
             raise web.HTTPError(400, "Missing field in JSON data: notebook.path")
         try:
             kernel_name = model['kernel']['name']
         except KeyError:
             self.log.debug("No kernel name specified, using default kernel")
             kernel_name = None
 
         # Check to see if session exists
         if sm.session_exists(path=path):
             model = sm.get_session(path=path)
         else:
             try:
                 model = sm.create_session(path=path, kernel_name=kernel_name)
             except NoSuchKernel:
                 msg = ("The '%s' kernel is not available. Please pick another "
                        "suitable kernel instead, or install that kernel." % kernel_name)
                 status_msg = '%s not found' % kernel_name
                 self.log.warn('Kernel not found: %s' % kernel_name)
                 self.set_status(501)
                 self.finish(json.dumps(dict(message=msg, short_message=status_msg)))
                 return
 
         location = url_path_join(self.base_url, 'api', 'sessions', model['id'])
         self.set_header('Location', url_escape(location))
         self.set_status(201)
         self.finish(json.dumps(model, default=date_default))
 
 class SessionHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('GET', 'PATCH', 'DELETE')
 
     @web.authenticated
     @json_errors
     def get(self, session_id):
         # Returns the JSON model for a single session
         sm = self.session_manager
         model = sm.get_session(session_id=session_id)
         self.finish(json.dumps(model, default=date_default))
 
     @web.authenticated
     @json_errors
     def patch(self, session_id):
         # Currently, this handler is strictly for renaming notebooks
         sm = self.session_manager
         model = self.get_json_body()
         if model is None:
             raise web.HTTPError(400, "No JSON data provided")
         changes = {}
         if 'notebook' in model:
             notebook = model['notebook']
             if 'path' in notebook:
                 changes['path'] = notebook['path']
 
         sm.update_session(session_id, **changes)
         model = sm.get_session(session_id=session_id)
         self.finish(json.dumps(model, default=date_default))
 
     @web.authenticated
     @json_errors
     def delete(self, session_id):
         # Deletes the session with given session_id
         sm = self.session_manager
         try:
             sm.delete_session(session_id)
         except KeyError:
             # the kernel was deleted but the session wasn't!
             raise web.HTTPError(410, "Kernel deleted before session")
         self.set_status(204)
         self.finish()
 
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 _session_id_regex = r"(?P<session_id>\w+-\w+-\w+-\w+-\w+)"
 
 default_handlers = [
     (r"/api/sessions/%s" % _session_id_regex, SessionHandler),
     (r"/api/sessions",  SessionRootHandler)
 ]
 

jupyter_notebook/services/sessions/sessionmanager.py

@@ -1,208 +1,208
 """A base class session manager."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import uuid
 import sqlite3
 
 from tornado import web
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.utils.py3compat import unicode_type
 from IPython.utils.traitlets import Instance
 
 
 class SessionManager(LoggingConfigurable):
 
-    kernel_manager = Instance('IPython.html.services.kernels.kernelmanager.MappingKernelManager')
-    contents_manager = Instance('IPython.html.services.contents.manager.ContentsManager')
+    kernel_manager = Instance('jupyter_notebook.services.kernels.kernelmanager.MappingKernelManager')
+    contents_manager = Instance('jupyter_notebook.services.contents.manager.ContentsManager')
     
     # Session database initialized below
     _cursor = None
     _connection = None
     _columns = {'session_id', 'path', 'kernel_id'}
     
     @property
     def cursor(self):
         """Start a cursor and create a database called 'session'"""
         if self._cursor is None:
             self._cursor = self.connection.cursor()
             self._cursor.execute("""CREATE TABLE session 
                 (session_id, path, kernel_id)""")
         return self._cursor
 
     @property
     def connection(self):
         """Start a database connection"""
         if self._connection is None:
             self._connection = sqlite3.connect(':memory:')
             self._connection.row_factory = sqlite3.Row
         return self._connection
         
     def __del__(self):
         """Close connection once SessionManager closes"""
         self.cursor.close()
 
     def session_exists(self, path):
         """Check to see if the session for a given notebook exists"""
         self.cursor.execute("SELECT * FROM session WHERE path=?", (path,))
         reply = self.cursor.fetchone()
         if reply is None:
             return False
         else:
             return True
 
     def new_session_id(self):
         "Create a uuid for a new session"
         return unicode_type(uuid.uuid4())
 
     def create_session(self, path=None, kernel_name=None):
         """Creates a session and returns its model"""
         session_id = self.new_session_id()
         # allow nbm to specify kernels cwd
         kernel_path = self.contents_manager.get_kernel_path(path=path)
         kernel_id = self.kernel_manager.start_kernel(path=kernel_path,
                                                      kernel_name=kernel_name)
         return self.save_session(session_id, path=path,
                                  kernel_id=kernel_id)
 
     def save_session(self, session_id, path=None, kernel_id=None):
         """Saves the items for the session with the given session_id
         
         Given a session_id (and any other of the arguments), this method
         creates a row in the sqlite session database that holds the information
         for a session.
         
         Parameters
         ----------
         session_id : str
             uuid for the session; this method must be given a session_id
         path : str
             the path for the given notebook
         kernel_id : str
             a uuid for the kernel associated with this session
         
         Returns
         -------
         model : dict
             a dictionary of the session model
         """
         self.cursor.execute("INSERT INTO session VALUES (?,?,?)",
             (session_id, path, kernel_id)
         )
         return self.get_session(session_id=session_id)
 
     def get_session(self, **kwargs):
         """Returns the model for a particular session.
         
         Takes a keyword argument and searches for the value in the session
         database, then returns the rest of the session's info.
 
         Parameters
         ----------
         **kwargs : keyword argument
             must be given one of the keywords and values from the session database
             (i.e. session_id, path, kernel_id)
 
         Returns
         -------
         model : dict
             returns a dictionary that includes all the information from the 
             session described by the kwarg.
         """
         if not kwargs:
             raise TypeError("must specify a column to query")
 
         conditions = []
         for column in kwargs.keys():
             if column not in self._columns:
                 raise TypeError("No such column: %r", column)
             conditions.append("%s=?" % column)
 
         query = "SELECT * FROM session WHERE %s" % (' AND '.join(conditions))
 
         self.cursor.execute(query, list(kwargs.values()))
         try:
             row = self.cursor.fetchone()
         except KeyError:
             # The kernel is missing, so the session just got deleted.
             row = None
 
         if row is None:
             q = []
             for key, value in kwargs.items():
                 q.append("%s=%r" % (key, value))
 
             raise web.HTTPError(404, u'Session not found: %s' % (', '.join(q)))
 
         return self.row_to_model(row)
 
     def update_session(self, session_id, **kwargs):
         """Updates the values in the session database.
         
         Changes the values of the session with the given session_id
         with the values from the keyword arguments. 
         
         Parameters
         ----------
         session_id : str
             a uuid that identifies a session in the sqlite3 database
         **kwargs : str
             the key must correspond to a column title in session database,
             and the value replaces the current value in the session 
             with session_id.
         """
         self.get_session(session_id=session_id)
 
         if not kwargs:
             # no changes
             return
 
         sets = []
         for column in kwargs.keys():
             if column not in self._columns:
                 raise TypeError("No such column: %r" % column)
             sets.append("%s=?" % column)
         query = "UPDATE session SET %s WHERE session_id=?" % (', '.join(sets))
         self.cursor.execute(query, list(kwargs.values()) + [session_id])
 
     def row_to_model(self, row):
         """Takes sqlite database session row and turns it into a dictionary"""
         if row['kernel_id'] not in self.kernel_manager:
             # The kernel was killed or died without deleting the session.
             # We can't use delete_session here because that tries to find
             # and shut down the kernel.
             self.cursor.execute("DELETE FROM session WHERE session_id=?", 
                                 (row['session_id'],))
             raise KeyError
 
         model = {
             'id': row['session_id'],
             'notebook': {
                 'path': row['path']
             },
             'kernel': self.kernel_manager.kernel_model(row['kernel_id'])
         }
         return model
 
     def list_sessions(self):
         """Returns a list of dictionaries containing all the information from
         the session database"""
         c = self.cursor.execute("SELECT * FROM session")
         result = []
         # We need to use fetchall() here, because row_to_model can delete rows,
         # which messes up the cursor if we're iterating over rows.
         for row in c.fetchall():
             try:
                 result.append(self.row_to_model(row))
             except KeyError:
                 pass
         return result
 
     def delete_session(self, session_id):
         """Deletes the row in the session database with given session_id"""
         # Check that session exists before deleting
         session = self.get_session(session_id=session_id)
         self.kernel_manager.shutdown_kernel(session['kernel']['id'])
         self.cursor.execute("DELETE FROM session WHERE session_id=?", (session_id,))

jupyter_notebook/services/sessions/tests/test_sessionmanager.py

@@ -1,162 +1,162
 """Tests for the session manager."""
 
 from unittest import TestCase
 
 from tornado import web
 
 from ..sessionmanager import SessionManager
-from IPython.html.services.kernels.kernelmanager import MappingKernelManager
-from IPython.html.services.contents.manager import ContentsManager
+from jupyter_notebook.services.kernels.kernelmanager import MappingKernelManager
+from jupyter_notebook.services.contents.manager import ContentsManager
 
 class DummyKernel(object):
     def __init__(self, kernel_name='python'):
         self.kernel_name = kernel_name
 
 class DummyMKM(MappingKernelManager):
     """MappingKernelManager interface that doesn't start kernels, for testing"""
     def __init__(self, *args, **kwargs):
         super(DummyMKM, self).__init__(*args, **kwargs)
         self.id_letters = iter(u'ABCDEFGHIJK')
 
     def _new_id(self):
         return next(self.id_letters)
     
     def start_kernel(self, kernel_id=None, path=None, kernel_name='python', **kwargs):
         kernel_id = kernel_id or self._new_id()
         self._kernels[kernel_id] = DummyKernel(kernel_name=kernel_name)
         return kernel_id
 
     def shutdown_kernel(self, kernel_id, now=False):
         del self._kernels[kernel_id]
 
 
 class TestSessionManager(TestCase):
     
     def setUp(self):
         self.sm = SessionManager(
             kernel_manager=DummyMKM(),
             contents_manager=ContentsManager(),
         )
 
     def test_get_session(self):
         sm = self.sm
         session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='bar')['id']
         model = sm.get_session(session_id=session_id)
         expected = {'id':session_id,
                     'notebook':{'path': u'/path/to/test.ipynb'},
                     'kernel': {'id':u'A', 'name': 'bar'}}
         self.assertEqual(model, expected)
 
     def test_bad_get_session(self):
         # Should raise error if a bad key is passed to the database.
         sm = self.sm
         session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='foo')['id']
         self.assertRaises(TypeError, sm.get_session, bad_id=session_id) # Bad keyword
 
     def test_get_session_dead_kernel(self):
         sm = self.sm
         session = sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python')
         # kill the kernel
         sm.kernel_manager.shutdown_kernel(session['kernel']['id'])
         with self.assertRaises(KeyError):
             sm.get_session(session_id=session['id'])
         # no sessions left
         listed = sm.list_sessions()
         self.assertEqual(listed, [])
 
     def test_list_sessions(self):
         sm = self.sm
         sessions = [
             sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python'),
             sm.create_session(path='/path/to/2/test2.ipynb', kernel_name='python'),
             sm.create_session(path='/path/to/3/test3.ipynb', kernel_name='python'),
         ]
         sessions = sm.list_sessions()
         expected = [
             {
                 'id':sessions[0]['id'],
                 'notebook':{'path': u'/path/to/1/test1.ipynb'},
                 'kernel':{'id':u'A', 'name':'python'}
             }, {
                 'id':sessions[1]['id'],
                 'notebook': {'path': u'/path/to/2/test2.ipynb'},
                 'kernel':{'id':u'B', 'name':'python'}
             }, {
                 'id':sessions[2]['id'],
                 'notebook':{'path': u'/path/to/3/test3.ipynb'},
                 'kernel':{'id':u'C', 'name':'python'}
             }
         ]
         self.assertEqual(sessions, expected)
 
     def test_list_sessions_dead_kernel(self):
         sm = self.sm
         sessions = [
             sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python'),
             sm.create_session(path='/path/to/2/test2.ipynb', kernel_name='python'),
         ]
         # kill one of the kernels
         sm.kernel_manager.shutdown_kernel(sessions[0]['kernel']['id'])
         listed = sm.list_sessions()
         expected = [
             {
                 'id': sessions[1]['id'],
                 'notebook': {
                     'path': u'/path/to/2/test2.ipynb',
                 },
                 'kernel': {
                     'id': u'B',
                     'name':'python',
                 }
             }
         ]
         self.assertEqual(listed, expected)
 
     def test_update_session(self):
         sm = self.sm
         session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='julia')['id']
         sm.update_session(session_id, path='/path/to/new_name.ipynb')
         model = sm.get_session(session_id=session_id)
         expected = {'id':session_id,
                     'notebook':{'path': u'/path/to/new_name.ipynb'},
                     'kernel':{'id':u'A', 'name':'julia'}}
         self.assertEqual(model, expected)
     
     def test_bad_update_session(self):
         # try to update a session with a bad keyword ~ raise error
         sm = self.sm
         session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='ir')['id']
         self.assertRaises(TypeError, sm.update_session, session_id=session_id, bad_kw='test.ipynb') # Bad keyword
 
     def test_delete_session(self):
         sm = self.sm
         sessions = [
             sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python'),
             sm.create_session(path='/path/to/2/test2.ipynb', kernel_name='python'),
             sm.create_session(path='/path/to/3/test3.ipynb', kernel_name='python'),
         ]
         sm.delete_session(sessions[1]['id'])
         new_sessions = sm.list_sessions()
         expected = [{
                 'id': sessions[0]['id'],
                 'notebook': {'path': u'/path/to/1/test1.ipynb'},
                 'kernel': {'id':u'A', 'name':'python'}
             }, {
                 'id': sessions[2]['id'],
                 'notebook': {'path': u'/path/to/3/test3.ipynb'},
                 'kernel': {'id':u'C', 'name':'python'}
             }
         ]
         self.assertEqual(new_sessions, expected)
 
     def test_bad_delete_session(self):
         # try to delete a session that doesn't exist ~ raise error
         sm = self.sm
         sm.create_session(path='/path/to/test.ipynb', kernel_name='python')
         self.assertRaises(TypeError, sm.delete_session, bad_kwarg='23424') # Bad keyword
         self.assertRaises(web.HTTPError, sm.delete_session, session_id='23424') # nonexistant
 

jupyter_notebook/services/sessions/tests/test_sessions_api.py

@@ -1,124 +1,124
 """Test the sessions web service API."""
 
 import errno
 import io
 import os
 import json
 import requests
 import shutil
 import time
 
 pjoin = os.path.join
 
-from IPython.html.utils import url_path_join
-from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
+from jupyter_notebook.utils import url_path_join
+from jupyter_notebook.tests.launchnotebook import NotebookTestBase, assert_http_error
 from IPython.nbformat.v4 import new_notebook
 from IPython.nbformat import write
 
 class SessionAPI(object):
     """Wrapper for notebook API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, path, body=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'api/sessions', path), data=body)
 
         if 400 <= response.status_code < 600:
             try:
                 response.reason = response.json()['message']
             except:
                 pass
         response.raise_for_status()
 
         return response
 
     def list(self):
         return self._req('GET', '')
 
     def get(self, id):
         return self._req('GET', id)
 
     def create(self, path, kernel_name='python'):
         body = json.dumps({'notebook': {'path':path},
                            'kernel': {'name': kernel_name}})
         return self._req('POST', '', body)
 
     def modify(self, id, path):
         body = json.dumps({'notebook': {'path':path}})
         return self._req('PATCH', id, body)
 
     def delete(self, id):
         return self._req('DELETE', id)
 
 class SessionAPITest(NotebookTestBase):
     """Test the sessions web service API"""
     def setUp(self):
         nbdir = self.notebook_dir.name
         try:
             os.mkdir(pjoin(nbdir, 'foo'))
         except OSError as e:
             # Deleting the folder in an earlier test may have failed
             if e.errno != errno.EEXIST:
                 raise
 
         with io.open(pjoin(nbdir, 'foo', 'nb1.ipynb'), 'w',
                      encoding='utf-8') as f:
             nb = new_notebook()
             write(nb, f, version=4)
 
         self.sess_api = SessionAPI(self.base_url())
 
     def tearDown(self):
         for session in self.sess_api.list().json():
             self.sess_api.delete(session['id'])
         # This is necessary in some situations on Windows: without it, it
         # fails to delete the directory because something is still using it. I
         # think there is a brief period after the kernel terminates where
         # Windows still treats its working directory as in use. On my Windows
         # VM, 0.01s is not long enough, but 0.1s appears to work reliably.
         # -- TK, 15 December 2014
         time.sleep(0.1)
 
         shutil.rmtree(pjoin(self.notebook_dir.name, 'foo'),
                       ignore_errors=True)
 
     def test_create(self):
         sessions = self.sess_api.list().json()
         self.assertEqual(len(sessions), 0)
 
         resp = self.sess_api.create('foo/nb1.ipynb')
         self.assertEqual(resp.status_code, 201)
         newsession = resp.json()
         self.assertIn('id', newsession)
         self.assertEqual(newsession['notebook']['path'], 'foo/nb1.ipynb')
         self.assertEqual(resp.headers['Location'], '/api/sessions/{0}'.format(newsession['id']))
 
         sessions = self.sess_api.list().json()
         self.assertEqual(sessions, [newsession])
 
         # Retrieve it
         sid = newsession['id']
         got = self.sess_api.get(sid).json()
         self.assertEqual(got, newsession)
 
     def test_delete(self):
         newsession = self.sess_api.create('foo/nb1.ipynb').json()
         sid = newsession['id']
 
         resp = self.sess_api.delete(sid)
         self.assertEqual(resp.status_code, 204)
 
         sessions = self.sess_api.list().json()
         self.assertEqual(sessions, [])
 
         with assert_http_error(404):
             self.sess_api.get(sid)
 
     def test_modify(self):
         newsession = self.sess_api.create('foo/nb1.ipynb').json()
         sid = newsession['id']
 
         changed = self.sess_api.modify(sid, 'nb2.ipynb').json()
         self.assertEqual(changed['id'], sid)
         self.assertEqual(changed['notebook']['path'], 'nb2.ipynb')

jupyter_notebook/static/widgets/js/manager.js

@@ -1,489 +1,489
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     "underscore",
     "backbone",
     "jquery",
     "base/js/utils",
     "base/js/namespace",
     "services/kernels/comm"
 ], function (_, Backbone, $, utils, IPython, comm) {
     "use strict";
     //--------------------------------------------------------------------
     // WidgetManager class
     //--------------------------------------------------------------------
     var WidgetManager = function (comm_manager, notebook) {
         /**
          * Public constructor
          */
         WidgetManager._managers.push(this);
 
         // Attach a comm manager to the 
         this.keyboard_manager = notebook.keyboard_manager;
         this.notebook = notebook;
         this.comm_manager = comm_manager;
         this.comm_target_name = 'ipython.widget';
         this._models = {}; /* Dictionary of model ids and model instance promises */
 
         // Register with the comm manager.
         this.comm_manager.register_target(this.comm_target_name, $.proxy(this._handle_comm_open, this));
 
         // Load the initial state of the widget manager if a load callback was
         // registered.
         var that = this;
         if (WidgetManager._load_callback) {
             Promise.resolve().then(function () {
                 return WidgetManager._load_callback.call(that);
             }).then(function(state) {
                 that.set_state(state);
             }).catch(utils.reject('Error loading widget manager state', true));
         }
 
         // Setup state saving code.
         this.notebook.events.on('before_save.Notebook', function() {
             var save_callback = WidgetManager._save_callback;
             var options = WidgetManager._get_state_options;
             if (save_callback) {
                 that.get_state(options).then(function(state) {
                     save_callback.call(that, state);
                 }).catch(utils.reject('Could not call widget save state callback.', true));
             }
         });
     };
 
     //--------------------------------------------------------------------
     // Class level
     //--------------------------------------------------------------------
     WidgetManager._model_types = {}; /* Dictionary of model type names (target_name) and model types. */
     WidgetManager._view_types = {}; /* Dictionary of view names and view types. */
     WidgetManager._managers = []; /* List of widget managers */
     WidgetManager._load_callback = null;
     WidgetManager._save_callback = null;
 
     WidgetManager.register_widget_model = function (model_name, model_type) {
         /** 
          * Registers a widget model by name.
          */
         WidgetManager._model_types[model_name] = model_type;
     };
 
     WidgetManager.register_widget_view = function (view_name, view_type) {
         /** 
          * Registers a widget view by name.
          */
         WidgetManager._view_types[view_name] = view_type;
     };
 
     WidgetManager.set_state_callbacks = function (load_callback, save_callback, options) {
         /**
          * Registers callbacks for widget state persistence.
          * 
          * Parameters
          * ----------
          * load_callback: function()
          *      function that is called when the widget manager state should be
          *      loaded.  This function should return a promise for the widget
          *      manager state.  An empty state is an empty dictionary `{}`.
          * save_callback: function(state as dictionary)
          *      function that is called when the notebook is saved or autosaved.
          *      The current state of the widget manager is passed in as the first
          *      argument.
          */
         WidgetManager._load_callback = load_callback;
         WidgetManager._save_callback = save_callback;
         WidgetManager._get_state_options = options;
 
         // Use the load callback to immediately load widget states.
         WidgetManager._managers.forEach(function(manager) {
             if (load_callback) {
                 Promise.resolve().then(function () {
                     return load_callback.call(manager);
                 }).then(function(state) {
                     manager.set_state(state);
                 }).catch(utils.reject('Error loading widget manager state', true));
             }
         });
     };
 
     // Use local storage to persist widgets across page refresh by default.
     // LocalStorage is per domain, so we need to explicitly set the URL
     // that the widgets are associated with so they don't show on other 
     // pages hosted by the noteboook server.
     var url = [window.location.protocol, '//', window.location.host, window.location.pathname].join('');
     var key = 'widgets:' + url;
     WidgetManager.set_state_callbacks(function() {
         if (localStorage[key]) {
             return JSON.parse(localStorage[key]);
         }
         return {};
     }, function(state) {
         localStorage[key] = JSON.stringify(state);
     });
 
     //--------------------------------------------------------------------
     // Instance level
     //--------------------------------------------------------------------
     WidgetManager.prototype.display_view = function(msg, model) {
         /**
          * Displays a view for a particular model.
          */
         var cell = this.get_msg_cell(msg.parent_header.msg_id);
         if (cell === null) {
             return Promise.reject(new Error("Could not determine where the display" + 
                 " message was from.  Widget will not be displayed"));
         } else {
             return this.display_view_in_cell(cell, model)
                 .catch(utils.reject('Could not display view', true)); 
         }
     };
 
     WidgetManager.prototype.display_view_in_cell = function(cell, model) {
         // Displays a view in a cell.
         if (cell.display_widget_view) {
             var that = this;
             return cell.display_widget_view(this.create_view(model, {
                 cell: cell,
                 // Only set cell_index when view is displayed as directly.
                 cell_index: that.notebook.find_cell_index(cell),
             })).then(function(view) {
                 that._handle_display_view(view);
                 view.trigger('displayed');
                 return view;
             }).catch(utils.reject('Could not create or display view', true)); 
         } else {
             return Promise.reject(new Error('Cell does not have a `display_widget_view` method'));
         }
     };
 
     WidgetManager.prototype._handle_display_view = function (view) {
         /**
          * Have the IPython keyboard manager disable its event
          * handling so the widget can capture keyboard input.
          * Note, this is only done on the outer most widgets.
          */
         if (this.keyboard_manager) {
             this.keyboard_manager.register_events(view.$el);
         
             if (view.additional_elements) {
                 for (var i = 0; i < view.additional_elements.length; i++) {
                     this.keyboard_manager.register_events(view.additional_elements[i]);
                 }
             } 
         }
     };
     
     WidgetManager.prototype.create_view = function(model, options) {
         /**
          * Creates a promise for a view of a given model
          *
          * Make sure the view creation is not out of order with 
          * any state updates.
          */
         model.state_change = model.state_change.then(function() {
             
             return utils.load_class(model.get('_view_name'), model.get('_view_module'),
             WidgetManager._view_types).then(function(ViewType) {
 
                 // If a view is passed into the method, use that view's cell as
                 // the cell for the view that is created.
                 options = options || {};
                 if (options.parent !== undefined) {
                     options.cell = options.parent.options.cell;
                 }
                 // Create and render the view...
                 var parameters = {model: model, options: options};
                 var view = new ViewType(parameters);
                 view.listenTo(model, 'destroy', view.remove);
                 return Promise.resolve(view.render()).then(function() {return view;});
             }).catch(utils.reject("Couldn't create a view for model id '" + String(model.id) + "'", true));
         });
         var id = utils.uuid();
         model.views[id] = model.state_change;
         model.state_change.then(function(view) { 
             view.once('remove', function() {
                 delete view.model.views[id];
             }, this);
         });
         return model.state_change;
     };
 
     WidgetManager.prototype.get_msg_cell = function (msg_id) {
         var cell = null;
         // First, check to see if the msg was triggered by cell execution.
         if (this.notebook) {
             cell = this.notebook.get_msg_cell(msg_id);
         }
         if (cell !== null) {
             return cell;
         }
         // Second, check to see if a get_cell callback was defined
         // for the message.  get_cell callbacks are registered for
         // widget messages, so this block is actually checking to see if the
         // message was triggered by a widget.
         var kernel = this.comm_manager.kernel;
         if (kernel) {
             var callbacks = kernel.get_callbacks_for_msg(msg_id);
             if (callbacks && callbacks.iopub &&
                 callbacks.iopub.get_cell !== undefined) {
                 return callbacks.iopub.get_cell();
             }
         }
         
         // Not triggered by a cell or widget (no get_cell callback 
         // exists).
         return null;
     };
 
     WidgetManager.prototype.callbacks = function (view) {
         /**
          * callback handlers specific a view
          */
         var callbacks = {};
         if (view && view.options.cell) {
 
             // Try to get output handlers
             var cell = view.options.cell;
             var handle_output = null;
             var handle_clear_output = null;
             if (cell.output_area) {
                 handle_output = $.proxy(cell.output_area.handle_output, cell.output_area);
                 handle_clear_output = $.proxy(cell.output_area.handle_clear_output, cell.output_area);
             }
 
             // Create callback dictionary using what is known
             var that = this;
             callbacks = {
                 iopub : {
                     output : handle_output,
                     clear_output : handle_clear_output,
 
                     // Special function only registered by widget messages.
                     // Allows us to get the cell for a message so we know
                     // where to add widgets if the code requires it.
                     get_cell : function () {
                         return cell;
                     },
                 },
             };
         }
         return callbacks;
     };
 
     WidgetManager.prototype.get_model = function (model_id) {
         /**
          * Get a promise for a model by model id.
          */
         return this._models[model_id];
     };
 
     WidgetManager.prototype._handle_comm_open = function (comm, msg) {
         /**
          * Handle when a comm is opened.
          */
         return this.create_model({
             model_name: msg.content.data.model_name, 
             model_module: msg.content.data.model_module, 
             comm: comm}).catch(utils.reject("Couldn't create a model.", true));
     };
 
     WidgetManager.prototype.create_model = function (options) {
         /**
          * Create and return a promise for a new widget model
          *
          * Minimally, one must provide the model_name and widget_class
          * parameters to create a model from Javascript.
          *
          * Example
          * --------
          * JS:
          * IPython.notebook.kernel.widget_manager.create_model({
          *      model_name: 'WidgetModel', 
-         *      widget_class: 'IPython.html.widgets.widget_int.IntSlider'})
+         *      widget_class: 'jupyter_notebook.widgets.widget_int.IntSlider'})
          *      .then(function(model) { console.log('Create success!', model); },
          *      $.proxy(console.error, console));
          *
          * Parameters
          * ----------
          * options: dictionary
          *  Dictionary of options with the following contents:
          *      model_name: string
          *          Target name of the widget model to create.
          *      model_module: (optional) string
          *          Module name of the widget model to create.
          *      widget_class: (optional) string
          *          Target name of the widget in the back-end.
          *      comm: (optional) Comm
          *
          * Create a comm if it wasn't provided.
          */
         var comm = options.comm;
         if (!comm) {
             comm = this.comm_manager.new_comm('ipython.widget', {'widget_class': options.widget_class});
         }
 
         var that = this;
         var model_id = comm.comm_id;
         var model_promise =  utils.load_class(options.model_name, options.model_module, WidgetManager._model_types)
             .then(function(ModelType) {
                 var widget_model = new ModelType(that, model_id, comm);
                 widget_model.once('comm:close', function () {
                     delete that._models[model_id];
                 });
                 widget_model.name = options.model_name;
                 widget_model.module = options.model_module;
                 return widget_model;
 
             }, function(error) {
                 delete that._models[model_id];
                 var wrapped_error = new utils.WrappedError("Couldn't create model", error);
                 return Promise.reject(wrapped_error);
             });
         this._models[model_id] = model_promise;
         return model_promise;
     };
 
     WidgetManager.prototype.get_state = function(options) {
         /**
          * Asynchronously get the state of the widget manager.
          *
          * This includes all of the widget models and the cells that they are
          * displayed in.
          *
          * Parameters
          * ----------
          * options: dictionary
          *  Dictionary of options with the following contents:
          *      only_displayed: (optional) boolean=false
          *          Only return models with one or more displayed views.
          *      not_live: (optional) boolean=false
          *          Include models that have comms with severed connections.
          *
          * Returns
          * -------
          * Promise for a state dictionary
          */
         var that = this;
         return utils.resolve_promises_dict(this._models).then(function(models) {
             var state = {};
 
             var model_promises = [];
             for (var model_id in models) {
                 if (models.hasOwnProperty(model_id)) {
                     var model = models[model_id];
 
                     // If the model has one or more views defined for it,
                     // consider it displayed.
                     var displayed_flag = !(options && options.only_displayed) || Object.keys(model.views).length > 0;
                     var live_flag = (options && options.not_live) || model.comm_live;
                     if (displayed_flag && live_flag) {
                         state[model_id] = {
                             model_name: model.name,
                             model_module: model.module,
                             state: model.get_state(),
                             views: [],
                         };
 
                         // Get the views that are displayed *now*.
                         (function(local_state) {
                             model_promises.push(utils.resolve_promises_dict(model.views).then(function(model_views) {
                                 for (var id in model_views) {
                                     if (model_views.hasOwnProperty(id)) {
                                         var view = model_views[id];
                                         if (view.options.cell_index) {
                                             local_state.views.push(view.options.cell_index);
                                         }
                                     }
                                 }
                             }));
                         })(state[model_id]);
                     }
                 }
             }
             return Promise.all(model_promises).then(function() { return state; });
         }).catch(utils.reject('Could not get state of widget manager', true));
     };
     
     WidgetManager.prototype.set_state = function(state) {
         /**
          * Set the notebook's state.
          *
          * Reconstructs all of the widget models and attempts to redisplay the
          * widgets in the appropriate cells by cell index.
          */
         
         // Get the kernel when it's available.
         var that = this;
         return this._get_connected_kernel().then(function(kernel) {
             
             // Recreate all the widget models for the given state and 
             // display the views.
             that.all_views = [];
             var model_ids = Object.keys(state);
             for (var i = 0; i < model_ids.length; i++) {
                 var model_id = model_ids[i];
                 
                 // Recreate a comm using the widget's model id (model_id == comm_id).
                 var new_comm = new comm.Comm(kernel.widget_manager.comm_target_name, model_id);
                 kernel.comm_manager.register_comm(new_comm);
 
                 // Create the model using the recreated comm.  When the model is
                 // created we don't know yet if the comm is valid so set_comm_live
                 // false.  Once we receive the first state push from the back-end
                 // we know the comm is alive.
                 var views = kernel.widget_manager.create_model({
                     comm: new_comm, 
                     model_name: state[model_id].model_name, 
                     model_module: state[model_id].model_module})
                 .then(function(model) {
 
                     model.set_comm_live(false);
                     var view_promise = Promise.resolve().then(function() {
                         return model.set_state(state[model.id].state);
                     }).then(function() {
                         model.request_state().then(function() {
                             model.set_comm_live(true);
                         });
 
                         // Display the views of the model.
                         var views = [];
                         var model_views = state[model.id].views;
                         for (var j=0; j<model_views.length; j++) {
                             var cell_index = model_views[j];
                             var cell = that.notebook.get_cell(cell_index);
                             views.push(that.display_view_in_cell(cell, model));
                         }
                         return Promise.all(views);
                     });
                     return view_promise;
                 });
                 that.all_views.push(views);
             }
             return Promise.all(that.all_views);
         }).catch(utils.reject('Could not set widget manager state.', true));  
     };
 
     WidgetManager.prototype._get_connected_kernel = function() {
         /**
          * Gets a promise for a connected kernel
          */
         var that = this;
         return new Promise(function(resolve, reject) {
             if (that.comm_manager && 
                 that.comm_manager.kernel && 
                 that.comm_manager.kernel.is_connected()) {
 
                 resolve(that.comm_manager.kernel);
             } else {
                 that.notebook.events.on('kernel_connected.Kernel', function(event, data) {
                     resolve(data.kernel);
                 });
             }    
         });
     };
 
     // Backwards compatibility.
     IPython.WidgetManager = WidgetManager;
 
     return {'WidgetManager': WidgetManager};
 });

jupyter_notebook/terminal/__init__.py

@@ -1,27 +1,27
 import os
 
 import terminado
 from ..utils import check_version
 
 if not check_version(terminado.__version__, '0.3.3'):
     raise ImportError("terminado >= 0.3.3 required, found %s" % terminado.__version__)
 
 from terminado import NamedTermManager
 from tornado.log import app_log
-from IPython.html.utils import url_path_join as ujoin
+from jupyter_notebook.utils import url_path_join as ujoin
 from .handlers import TerminalHandler, TermSocket
 from . import api_handlers
 
 def initialize(webapp):
     shell = os.environ.get('SHELL', 'sh')
     terminal_manager = webapp.settings['terminal_manager'] = NamedTermManager(shell_command=[shell])
     terminal_manager.log = app_log
     base_url = webapp.settings['base_url']
     handlers = [
         (ujoin(base_url, r"/terminals/(\w+)"), TerminalHandler),
         (ujoin(base_url, r"/terminals/websocket/(\w+)"), TermSocket,
              {'term_manager': terminal_manager}),
         (ujoin(base_url, r"/api/terminals"), api_handlers.TerminalRootHandler),
         (ujoin(base_url, r"/api/terminals/(\w+)"), api_handlers.TerminalHandler),
     ]
     webapp.add_handlers(".*$", handlers)
  No newline at end of file

jupyter_notebook/tests/test_files.py

@@ -1,152 +1,152
 # coding: utf-8
 """Test the /files/ handler."""
 
 import io
 import os
 from unicodedata import normalize
 
 pjoin = os.path.join
 
 import requests
 import json
 
 from IPython.nbformat import write
 from IPython.nbformat.v4 import (new_notebook,
                               new_markdown_cell, new_code_cell,
                               new_output)
 
-from IPython.html.utils import url_path_join
+from jupyter_notebook.utils import url_path_join
 from .launchnotebook import NotebookTestBase
 from IPython.utils import py3compat
 
 
 class FilesTest(NotebookTestBase):
     def test_hidden_files(self):
         not_hidden = [
             u'å b',
             u'å b/ç. d',
         ]
         hidden = [
             u'.å b',
             u'å b/.ç d',
         ]
         dirs = not_hidden + hidden
         
         nbdir = self.notebook_dir.name
         for d in dirs:
             path = pjoin(nbdir, d.replace('/', os.sep))
             if not os.path.exists(path):
                 os.mkdir(path)
             with open(pjoin(path, 'foo'), 'w') as f:
                 f.write('foo')
             with open(pjoin(path, '.foo'), 'w') as f:
                 f.write('.foo')
         url = self.base_url()
         
         for d in not_hidden:
             path = pjoin(nbdir, d.replace('/', os.sep))
             r = requests.get(url_path_join(url, 'files', d, 'foo'))
             r.raise_for_status()
             self.assertEqual(r.text, 'foo')
             r = requests.get(url_path_join(url, 'files', d, '.foo'))
             self.assertEqual(r.status_code, 404)
             
         for d in hidden:
             path = pjoin(nbdir, d.replace('/', os.sep))
             for foo in ('foo', '.foo'):
                 r = requests.get(url_path_join(url, 'files', d, foo))
                 self.assertEqual(r.status_code, 404)
     
     def test_contents_manager(self):
         "make sure ContentsManager returns right files (ipynb, bin, txt)."
 
         nbdir = self.notebook_dir.name
         base = self.base_url()
 
         nb = new_notebook(
             cells=[
                 new_markdown_cell(u'Created by test ³'),
                 new_code_cell("print(2*6)", outputs=[
                     new_output("stream", text="12"),
                 ])
             ]
         )
 
         with io.open(pjoin(nbdir, 'testnb.ipynb'), 'w', 
             encoding='utf-8') as f:
             write(nb, f, version=4)
 
         with io.open(pjoin(nbdir, 'test.bin'), 'wb') as f:
             f.write(b'\xff' + os.urandom(5))
             f.close()
 
         with io.open(pjoin(nbdir, 'test.txt'), 'w') as f:
             f.write(u'foobar')
             f.close()
 
         r = requests.get(url_path_join(base, 'files', 'testnb.ipynb'))
         self.assertEqual(r.status_code, 200)
         self.assertIn('print(2*6)', r.text)
         json.loads(r.text)
 
         r = requests.get(url_path_join(base, 'files', 'test.bin'))
         self.assertEqual(r.status_code, 200)
         self.assertEqual(r.headers['content-type'], 'application/octet-stream')
         self.assertEqual(r.content[:1], b'\xff')
         self.assertEqual(len(r.content), 6)
 
         r = requests.get(url_path_join(base, 'files', 'test.txt'))
         self.assertEqual(r.status_code, 200)
         self.assertEqual(r.headers['content-type'], 'text/plain')
         self.assertEqual(r.text, 'foobar')
     
     def test_download(self):
         nbdir = self.notebook_dir.name
         base = self.base_url()
         
         text = 'hello'
         with open(pjoin(nbdir, 'test.txt'), 'w') as f:
             f.write(text)
         
         r = requests.get(url_path_join(base, 'files', 'test.txt'))
         disposition = r.headers.get('Content-Disposition', '')
         self.assertNotIn('attachment', disposition)
 
         r = requests.get(url_path_join(base, 'files', 'test.txt') + '?download=1')
         disposition = r.headers.get('Content-Disposition', '')
         self.assertIn('attachment', disposition)
         self.assertIn('filename="test.txt"', disposition)
 
     def test_old_files_redirect(self):
         """pre-2.0 'files/' prefixed links are properly redirected"""
         nbdir = self.notebook_dir.name
         base = self.base_url()
         
         os.mkdir(pjoin(nbdir, 'files'))
         os.makedirs(pjoin(nbdir, 'sub', 'files'))
         
         for prefix in ('', 'sub'):
             with open(pjoin(nbdir, prefix, 'files', 'f1.txt'), 'w') as f:
                 f.write(prefix + '/files/f1')
             with open(pjoin(nbdir, prefix, 'files', 'f2.txt'), 'w') as f:
                 f.write(prefix + '/files/f2')
             with open(pjoin(nbdir, prefix, 'f2.txt'), 'w') as f:
                 f.write(prefix + '/f2')
             with open(pjoin(nbdir, prefix, 'f3.txt'), 'w') as f:
                 f.write(prefix + '/f3')
             
             url = url_path_join(base, 'notebooks', prefix, 'files', 'f1.txt')
             r = requests.get(url)
             self.assertEqual(r.status_code, 200)
             self.assertEqual(r.text, prefix + '/files/f1')
 
             url = url_path_join(base, 'notebooks', prefix, 'files', 'f2.txt')
             r = requests.get(url)
             self.assertEqual(r.status_code, 200)
             self.assertEqual(r.text, prefix + '/files/f2')
 
             url = url_path_join(base, 'notebooks', prefix, 'files', 'f3.txt')
             r = requests.get(url)
             self.assertEqual(r.status_code, 200)
             self.assertEqual(r.text, prefix + '/f3')
 

jupyter_notebook/tests/test_nbextensions.py

@@ -1,342 +1,342
 # coding: utf-8
 """Test installation of notebook extensions"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import glob
 import os
 import re
 import sys
 import tarfile
 import zipfile
 from io import BytesIO, StringIO
 from os.path import basename, join as pjoin
 from unittest import TestCase
 
 try:
     from unittest import mock
 except ImportError:
     import mock # py2
 
 import IPython.testing.decorators as dec
 from IPython.utils import py3compat
 from IPython.utils.tempdir import TemporaryDirectory
-from IPython.html import nbextensions
-from IPython.html.nbextensions import install_nbextension, check_nbextension
+from jupyter_notebook import nbextensions
+from jupyter_notebook.nbextensions import install_nbextension, check_nbextension
 
 
 def touch(file, mtime=None):
     """ensure a file exists, and set its modification time
     
     returns the modification time of the file
     """
     open(file, 'a').close()
     # set explicit mtime
     if mtime:
         atime = os.stat(file).st_atime
         os.utime(file, (atime, mtime))
     return os.stat(file).st_mtime
 
 class TestInstallNBExtension(TestCase):
     
     def tempdir(self):
         td = TemporaryDirectory()
         self.tempdirs.append(td)
         return py3compat.cast_unicode(td.name)
 
     def setUp(self):
         self.tempdirs = []
         src = self.src = self.tempdir()
         self.files = files = [
             pjoin(u'ƒile'),
             pjoin(u'∂ir', u'ƒile1'),
             pjoin(u'∂ir', u'∂ir2', u'ƒile2'),
         ]
         for file in files:
             fullpath = os.path.join(self.src, file)
             parent = os.path.dirname(fullpath)
             if not os.path.exists(parent):
                 os.makedirs(parent)
             touch(fullpath)
         
         self.ipdir = self.tempdir()
         self.save_get_ipython_dir = nbextensions.get_ipython_dir
         nbextensions.get_ipython_dir = lambda : self.ipdir
         self.save_system_dir = nbextensions.SYSTEM_NBEXTENSIONS_INSTALL_DIR
         nbextensions.SYSTEM_NBEXTENSIONS_INSTALL_DIR = self.system_nbext = self.tempdir()
     
     def tearDown(self):
         nbextensions.get_ipython_dir = self.save_get_ipython_dir
         nbextensions.SYSTEM_NBEXTENSIONS_INSTALL_DIR = self.save_system_dir
         for td in self.tempdirs:
             td.cleanup()
 
     def assert_dir_exists(self, path):
         if not os.path.exists(path):
             do_exist = os.listdir(os.path.dirname(path))
             self.fail(u"%s should exist (found %s)" % (path, do_exist))
     
     def assert_not_dir_exists(self, path):
         if os.path.exists(path):
             self.fail(u"%s should not exist" % path)
     
     def assert_installed(self, relative_path, user=False):
         if user:
             nbext = pjoin(self.ipdir, u'nbextensions')
         else:
             nbext = self.system_nbext
         self.assert_dir_exists(
             pjoin(nbext, relative_path)
         )
     
     def assert_not_installed(self, relative_path, user=False):
         if user:
             nbext = pjoin(self.ipdir, u'nbextensions')
         else:
             nbext = self.system_nbext
         self.assert_not_dir_exists(
             pjoin(nbext, relative_path)
         )
     
     def test_create_ipython_dir(self):
         """install_nbextension when ipython_dir doesn't exist"""
         with TemporaryDirectory() as td:
             self.ipdir = ipdir = pjoin(td, u'ipython')
             install_nbextension(self.src, user=True)
             self.assert_dir_exists(ipdir)
             for file in self.files:
                 self.assert_installed(
                     pjoin(basename(self.src), file),
                     user=bool(ipdir)
                 )
     
     def test_create_nbextensions_user(self):
         with TemporaryDirectory() as td:
             self.ipdir = ipdir = pjoin(td, u'ipython')
             install_nbextension(self.src, user=True)
             self.assert_installed(
                 pjoin(basename(self.src), u'ƒile'),
                 user=True
             )
     
     def test_create_nbextensions_system(self):
         with TemporaryDirectory() as td:
             nbextensions.SYSTEM_NBEXTENSIONS_INSTALL_DIR = self.system_nbext = pjoin(td, u'nbextensions')
             install_nbextension(self.src, user=False)
             self.assert_installed(
                 pjoin(basename(self.src), u'ƒile'),
                 user=False
             )
     
     def test_single_file(self):
         file = self.files[0]
         install_nbextension(pjoin(self.src, file))
         self.assert_installed(file)
     
     def test_single_dir(self):
         d = u'∂ir'
         install_nbextension(pjoin(self.src, d))
         self.assert_installed(self.files[-1])
     
 
     def test_destination_file(self):
         file = self.files[0]
         install_nbextension(pjoin(self.src, file), destination = u'ƒiledest')
         self.assert_installed(u'ƒiledest')
 
     def test_destination_dir(self):
         d = u'∂ir'
         install_nbextension(pjoin(self.src, d), destination = u'ƒiledest2')
         self.assert_installed(pjoin(u'ƒiledest2', u'∂ir2', u'ƒile2'))
     
     def test_install_nbextension(self):
         with self.assertRaises(TypeError):
             install_nbextension(glob.glob(pjoin(self.src, '*')))
     
     def test_overwrite_file(self):
         with TemporaryDirectory() as d:
             fname = u'ƒ.js'
             src = pjoin(d, fname)
             with open(src, 'w') as f:
                 f.write('first')
             mtime = touch(src)
             dest = pjoin(self.system_nbext, fname)
             install_nbextension(src)
             with open(src, 'w') as f:
                 f.write('overwrite')
             mtime = touch(src, mtime - 100)
             install_nbextension(src, overwrite=True)
             with open(dest) as f:
                 self.assertEqual(f.read(), 'overwrite')
     
     def test_overwrite_dir(self):
         with TemporaryDirectory() as src:
             base = basename(src)
             fname = u'ƒ.js'
             touch(pjoin(src, fname))
             install_nbextension(src)
             self.assert_installed(pjoin(base, fname))
             os.remove(pjoin(src, fname))
             fname2 = u'∂.js'
             touch(pjoin(src, fname2))
             install_nbextension(src, overwrite=True)
             self.assert_installed(pjoin(base, fname2))
             self.assert_not_installed(pjoin(base, fname))
     
     def test_update_file(self):
         with TemporaryDirectory() as d:
             fname = u'ƒ.js'
             src = pjoin(d, fname)
             with open(src, 'w') as f:
                 f.write('first')
             mtime = touch(src)
             install_nbextension(src)
             self.assert_installed(fname)
             dest = pjoin(self.system_nbext, fname)
             old_mtime = os.stat(dest).st_mtime
             with open(src, 'w') as f:
                 f.write('overwrite')
             touch(src, mtime + 10)
             install_nbextension(src)
             with open(dest) as f:
                 self.assertEqual(f.read(), 'overwrite')
     
     def test_skip_old_file(self):
         with TemporaryDirectory() as d:
             fname = u'ƒ.js'
             src = pjoin(d, fname)
             mtime = touch(src)
             install_nbextension(src)
             self.assert_installed(fname)
             dest = pjoin(self.system_nbext, fname)
             old_mtime = os.stat(dest).st_mtime
             
             mtime = touch(src, mtime - 100)
             install_nbextension(src)
             new_mtime = os.stat(dest).st_mtime
             self.assertEqual(new_mtime, old_mtime)
 
     def test_quiet(self):
         stdout = StringIO()
         stderr = StringIO()
         with mock.patch.object(sys, 'stdout', stdout), \
              mock.patch.object(sys, 'stderr', stderr):
             install_nbextension(self.src, verbose=0)
         self.assertEqual(stdout.getvalue(), '')
         self.assertEqual(stderr.getvalue(), '')
     
     def test_install_zip(self):
         path = pjoin(self.src, "myjsext.zip")
         with zipfile.ZipFile(path, 'w') as f:
             f.writestr("a.js", b"b();")
             f.writestr("foo/a.js", b"foo();")
         install_nbextension(path)
         self.assert_installed("a.js")
         self.assert_installed(pjoin("foo", "a.js"))
     
     def test_install_tar(self):
         def _add_file(f, fname, buf):
             info = tarfile.TarInfo(fname)
             info.size = len(buf)
             f.addfile(info, BytesIO(buf))
         
         for i,ext in enumerate((".tar.gz", ".tgz", ".tar.bz2")):
             path = pjoin(self.src, "myjsext" + ext)
             with tarfile.open(path, 'w') as f:
                 _add_file(f, "b%i.js" % i, b"b();")
                 _add_file(f, "foo/b%i.js" % i, b"foo();")
             install_nbextension(path)
             self.assert_installed("b%i.js" % i)
             self.assert_installed(pjoin("foo", "b%i.js" % i))
     
     def test_install_url(self):
         def fake_urlretrieve(url, dest):
             touch(dest)
         save_urlretrieve = nbextensions.urlretrieve
         nbextensions.urlretrieve = fake_urlretrieve
         try:
             install_nbextension("http://example.com/path/to/foo.js")
             self.assert_installed("foo.js")
             install_nbextension("https://example.com/path/to/another/bar.js")
             self.assert_installed("bar.js")
             install_nbextension("https://example.com/path/to/another/bar.js", 
                                 destination = 'foobar.js')
             self.assert_installed("foobar.js")
         finally:
             nbextensions.urlretrieve = save_urlretrieve
     
     def test_check_nbextension(self):
         with TemporaryDirectory() as d:
             f = u'ƒ.js'
             src = pjoin(d, f)
             touch(src)
             install_nbextension(src, user=True)
         
         assert check_nbextension(f, user=True)
         assert check_nbextension([f], user=True)
         assert not check_nbextension([f, pjoin('dne', f)], user=True)
     
     @dec.skip_win32
     def test_install_symlink(self):
         with TemporaryDirectory() as d:
             f = u'ƒ.js'
             src = pjoin(d, f)
             touch(src)
             install_nbextension(src, symlink=True)
         dest = pjoin(self.system_nbext, f)
         assert os.path.islink(dest)
         link = os.readlink(dest)
         self.assertEqual(link, src)
     
     @dec.skip_win32
     def test_overwrite_broken_symlink(self):
         with TemporaryDirectory() as d:
             f = u'ƒ.js'
             f2 = u'ƒ2.js'
             src = pjoin(d, f)
             src2 = pjoin(d, f2)
             touch(src)
             install_nbextension(src, symlink=True)
             os.rename(src, src2)
             install_nbextension(src2, symlink=True, overwrite=True, destination=f)
         dest = pjoin(self.system_nbext, f)
         assert os.path.islink(dest)
         link = os.readlink(dest)
         self.assertEqual(link, src2)
 
     @dec.skip_win32
     def test_install_symlink_destination(self):
         with TemporaryDirectory() as d:
             f = u'ƒ.js'
             flink = u'ƒlink.js'
             src = pjoin(d, f)
             touch(src)
             install_nbextension(src, symlink=True, destination=flink)
         dest = pjoin(self.system_nbext, flink)
         assert os.path.islink(dest)
         link = os.readlink(dest)
         self.assertEqual(link, src)
 
     def test_install_symlink_bad(self):
         with self.assertRaises(ValueError):
             install_nbextension("http://example.com/foo.js", symlink=True)
         
         with TemporaryDirectory() as d:
             zf = u'ƒ.zip'
             zsrc = pjoin(d, zf)
             with zipfile.ZipFile(zsrc, 'w') as z:
                 z.writestr("a.js", b"b();")
         
             with self.assertRaises(ValueError):
                 install_nbextension(zsrc, symlink=True)
 
     def test_install_destination_bad(self):
         with TemporaryDirectory() as d:
             zf = u'ƒ.zip'
             zsrc = pjoin(d, zf)
             with zipfile.ZipFile(zsrc, 'w') as z:
                 z.writestr("a.js", b"b();")
         
             with self.assertRaises(ValueError):
                 install_nbextension(zsrc, destination='foo')

jupyter_notebook/tests/test_notebookapp.py

@@ -1,62 +1,62
 """Test NotebookApp"""
 
 
 import logging
 import os
 from tempfile import NamedTemporaryFile
 
 import nose.tools as nt
 
 from traitlets.tests.utils import check_help_all_output
 
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.traitlets import TraitError
-from IPython.html import notebookapp
+from jupyter_notebook import notebookapp
 NotebookApp = notebookapp.NotebookApp
 
 
 def test_help_output():
     """ipython notebook --help-all works"""
-    check_help_all_output('IPython.html')
+    check_help_all_output('jupyter_notebook')
 
 def test_server_info_file():
     nbapp = NotebookApp(profile='nbserver_file_test', log=logging.getLogger())
     def get_servers():
         return list(notebookapp.list_running_servers(profile='nbserver_file_test'))
     nbapp.initialize(argv=[])
     nbapp.write_server_info_file()
     servers = get_servers()
     nt.assert_equal(len(servers), 1)
     nt.assert_equal(servers[0]['port'], nbapp.port)
     nt.assert_equal(servers[0]['url'], nbapp.connection_url)
     nbapp.remove_server_info_file()
     nt.assert_equal(get_servers(), [])
 
     # The ENOENT error should be silenced.
     nbapp.remove_server_info_file()
 
 def test_nb_dir():
     with TemporaryDirectory() as td:
         app = NotebookApp(notebook_dir=td)
         nt.assert_equal(app.notebook_dir, td)
 
 def test_no_create_nb_dir():
     with TemporaryDirectory() as td:
         nbdir = os.path.join(td, 'notebooks')
         app = NotebookApp()
         with nt.assert_raises(TraitError):
             app.notebook_dir = nbdir
 
 def test_missing_nb_dir():
     with TemporaryDirectory() as td:
         nbdir = os.path.join(td, 'notebook', 'dir', 'is', 'missing')
         app = NotebookApp()
         with nt.assert_raises(TraitError):
             app.notebook_dir = nbdir
 
 def test_invalid_nb_dir():
     with NamedTemporaryFile() as tf:
         app = NotebookApp()
         with nt.assert_raises(TraitError):
             app.notebook_dir = tf
 

jupyter_notebook/tests/test_paths.py

@@ -1,40 +1,40
 
 import re
 import nose.tools as nt
 
-from IPython.html.base.handlers import path_regex
+from jupyter_notebook.base.handlers import path_regex
 
 try: # py3
     assert_regex = nt.assert_regex
     assert_not_regex = nt.assert_not_regex
 except AttributeError: # py2
     assert_regex = nt.assert_regexp_matches
     assert_not_regex = nt.assert_not_regexp_matches
 
 
 # build regexps that tornado uses:
 path_pat = re.compile('^' + '/x%s' % path_regex + '$')
 
 def test_path_regex():
     for path in (
         '/x',
         '/x/',
         '/x/foo',
         '/x/foo.ipynb',
         '/x/foo/bar',
         '/x/foo/bar.txt',
     ):
         assert_regex(path, path_pat)
 
 def test_path_regex_bad():
     for path in (
         '/xfoo',
         '/xfoo/',
         '/xfoo/bar',
         '/xfoo/bar/',
         '/x/foo/bar/',
         '/x//foo',
         '/y',
         '/y/x/foo',
     ):
         assert_not_regex(path, path_pat)

jupyter_notebook/tests/test_utils.py

@@ -1,66 +1,66
 """Test HTML utils"""
 
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 
 import nose.tools as nt
 
 from traitlets.tests.utils import check_help_all_output
-from IPython.html.utils import url_escape, url_unescape, is_hidden
+from jupyter_notebook.utils import url_escape, url_unescape, is_hidden
 from IPython.utils.tempdir import TemporaryDirectory
 
 
 def test_help_output():
     """jupyter notebook --help-all works"""
     # FIXME: will be jupyter_notebook
-    check_help_all_output('IPython.html')
+    check_help_all_output('jupyter_notebook')
 
 
 def test_url_escape():
 
     # changes path or notebook name with special characters to url encoding
     # these tests specifically encode paths with spaces
     path = url_escape('/this is a test/for spaces/')
     nt.assert_equal(path, '/this%20is%20a%20test/for%20spaces/')
 
     path = url_escape('notebook with space.ipynb')
     nt.assert_equal(path, 'notebook%20with%20space.ipynb')
 
     path = url_escape('/path with a/notebook and space.ipynb')
     nt.assert_equal(path, '/path%20with%20a/notebook%20and%20space.ipynb')
     
     path = url_escape('/ !@$#%^&* / test %^ notebook @#$ name.ipynb')
     nt.assert_equal(path,
         '/%20%21%40%24%23%25%5E%26%2A%20/%20test%20%25%5E%20notebook%20%40%23%24%20name.ipynb')
 
 def test_url_unescape():
 
     # decodes a url string to a plain string
     # these tests decode paths with spaces
     path = url_unescape('/this%20is%20a%20test/for%20spaces/')
     nt.assert_equal(path, '/this is a test/for spaces/')
 
     path = url_unescape('notebook%20with%20space.ipynb')
     nt.assert_equal(path, 'notebook with space.ipynb')
 
     path = url_unescape('/path%20with%20a/notebook%20and%20space.ipynb')
     nt.assert_equal(path, '/path with a/notebook and space.ipynb')
 
     path = url_unescape(
         '/%20%21%40%24%23%25%5E%26%2A%20/%20test%20%25%5E%20notebook%20%40%23%24%20name.ipynb')
     nt.assert_equal(path, '/ !@$#%^&* / test %^ notebook @#$ name.ipynb')
 
 def test_is_hidden():
     with TemporaryDirectory() as root:
         subdir1 = os.path.join(root, 'subdir')
         os.makedirs(subdir1)
         nt.assert_equal(is_hidden(subdir1, root), False)
         subdir2 = os.path.join(root, '.subdir2')
         os.makedirs(subdir2)
         nt.assert_equal(is_hidden(subdir2, root), True)
         subdir34 = os.path.join(root, 'subdir3', '.subdir4')
         os.makedirs(subdir34)
         nt.assert_equal(is_hidden(subdir34, root), True)
         nt.assert_equal(is_hidden(subdir34), True)

jupyter_notebook/tests/widgets/manager.js

@@ -1,94 +1,94
 // Test the widget manager.
 casper.notebook_test(function () {
     var index;
     
     this.then(function () {
     
         // Check if the WidgetManager class is defined.
         this.test.assert(this.evaluate(function() {
             return IPython.WidgetManager !== undefined; 
         }), 'WidgetManager class is defined');
 
         // Check if the widget manager has been instantiated.
         this.test.assert(this.evaluate(function() {
             return IPython.notebook.kernel.widget_manager !== undefined; 
         }), 'Notebook widget manager instantiated');
 
         // Try creating a widget from Javascript.
         this.evaluate(function() {
             IPython.notebook.kernel.widget_manager.create_model({
                 model_name: 'WidgetModel', 
-                widget_class: 'IPython.html.widgets.widget_int.IntSlider'})
+                widget_class: 'jupyter_notebook.widgets.widget_int.IntSlider'})
                 .then(function(model) { 
                     console.log('Create success!', model); 
                     window.slider_id = model.id; 
                 }, function(error) { console.log(error); });
         });
     });
 
     // Wait for the state to be recieved.
     this.waitFor(function check() {
         return this.evaluate(function() {
             return window.slider_id !== undefined;
         });
     });
 
     index = this.append_cell(
-        'from IPython.html.widgets import Widget\n' + 
+        'from jupyter_notebook.widgets import Widget\n' + 
         'widget = list(Widget.widgets.values())[0]\n' +
         'print(widget.model_id)');
     this.execute_cell_then(index, function(index) {
         var output = this.get_output_cell(index).text.trim();
         var slider_id = this.evaluate(function() { return window.slider_id; });
         this.test.assertEquals(output, slider_id, "Widget created from the front-end.");
     });
 
     // Widget persistence tests.
     index = this.append_cell(
-        'from IPython.html.widgets import HTML\n' + 
+        'from jupyter_notebook.widgets import HTML\n' + 
         'from IPython.display import display\n' + 
         'display(HTML(value="<div id=\'hello\'></div>"))');
     this.execute_cell_then(index, function() {});
 
     index = this.append_cell(
         'display(HTML(value="<div id=\'world\'></div>"))');
     this.execute_cell_then(index, function() {});
 
     var that = this;
     this.then(function() {
         // Wait for the widgets to be shown.
         that.waitForSelector('#hello', function() {
             that.waitForSelector('#world', function() {
                 that.test.assertExists('#hello', 'Hello HTML widget constructed.');
                 that.test.assertExists('#world', 'World HTML widget constructed.');
 
                 // Save the notebook.
                 that.evaluate(function() {
                     IPython.notebook.save_notebook(false).then(function() {
                         window.was_saved = true;
                     });
                 });
                 that.waitFor(function check() {
                     return that.evaluate(function() {
                         return window.was_saved;
                     });
                 }, function then() {
 
                     // Reload the page
                     that.reload(function() {
 
                         // Wait for the elements to show up again.
                         that.waitForSelector('#hello', function() {
                             that.waitForSelector('#world', function() {
                                 that.test.assertExists('#hello', 'Hello HTML widget persisted.');
                                 that.test.assertExists('#world', 'World HTML widget persisted.');
                             });
                         });
                     });
                 });
             });
         });
     });
 
     
 });

jupyter_notebook/tests/widgets/widget.js

@@ -1,309 +1,309
 var xor = function (a, b) {return !a ^ !b;}; 
 var isArray = function (a) {
     try {
         return Object.toString.call(a) === "[object Array]" || Object.toString.call(a) === "[object RuntimeArray]";
     } catch (e) {
         return Array.isArray(a);
     }
 };
 var recursive_compare = function(a, b) {
     // Recursively compare two objects.
     var same = true;
     same = same && !xor(a instanceof Object || typeof a == 'object', b instanceof Object || typeof b == 'object');
     same = same && !xor(isArray(a), isArray(b));
 
     if (same) {
         if (a instanceof Object) {
             var key;
             for (key in a) {
                 if (a.hasOwnProperty(key) && !recursive_compare(a[key], b[key])) {
                     same = false;
                     break;
                 }
             }
             for (key in b) {
                 if (b.hasOwnProperty(key) && !recursive_compare(a[key], b[key])) {
                     same = false;
                     break;
                 }
             }
         } else {
             return a === b;
         }    
     }
     
     return same;
 };
 
 // Test the widget framework.
 casper.notebook_test(function () {
     var index;
 
     index = this.append_cell(
-        ['from IPython.html import widgets',
+        ['from jupyter_notebook import widgets',
          'from IPython.display import display, clear_output',
          'print("Success")'].join('\n'));
     this.execute_cell_then(index);
 
     this.then(function () {
         // Test multi-set, single touch code.  First create a custom widget.
         this.thenEvaluate(function() {
             var MultiSetView = IPython.DOMWidgetView.extend({
                 render: function(){
                     this.model.set('a', 1);
                     this.model.set('b', 2);
                     this.model.set('c', 3);
                     this.touch();
                 },
             });
             IPython.WidgetManager.register_widget_view('MultiSetView', MultiSetView);
         }, {});
     });
 
     // Try creating the multiset widget, verify that sets the values correctly.
     var multiset = {};
     multiset.index = this.append_cell([
         'from IPython.utils.traitlets import Unicode, CInt',
         'class MultiSetWidget(widgets.Widget):',
         '    _view_name = Unicode("MultiSetView", sync=True)',
         '    a = CInt(0, sync=True)',
         '    b = CInt(0, sync=True)',
         '    c = CInt(0, sync=True)',
         '    d = CInt(-1, sync=True)', // See if it sends a full state.
         '    def set_state(self, sync_data):',
         '        widgets.Widget.set_state(self, sync_data)',
         '        self.d = len(sync_data)',
         'multiset = MultiSetWidget()',
         'display(multiset)',
         'print(multiset.model_id)'].join('\n'));
     this.execute_cell_then(multiset.index, function(index) {
         multiset.model_id = this.get_output_cell(index).text.trim();
     });
 
     this.wait_for_widget(multiset);
 
     index = this.append_cell(
         'print("%d%d%d" % (multiset.a, multiset.b, multiset.c))');
     this.execute_cell_then(index, function(index) {
         this.test.assertEquals(this.get_output_cell(index).text.trim(), '123',
             'Multiple model.set calls and one view.touch update state in back-end.');
     });
 
     index = this.append_cell(
         'print("%d" % (multiset.d))');
     this.execute_cell_then(index, function(index) {
         this.test.assertEquals(this.get_output_cell(index).text.trim(), '3',
             'Multiple model.set calls sent a partial state.');
     });
 
     var textbox = {};
     throttle_index = this.append_cell([
         'import time',
         'textbox = widgets.Text()',
         'display(textbox)',
         'textbox._dom_classes = ["my-throttle-textbox"]',
         'def handle_change(name, old, new):',
         '    display(len(new))',
         '    time.sleep(0.5)',
         'textbox.on_trait_change(handle_change, "value")',
         'print(textbox.model_id)'].join('\n'));
     this.execute_cell_then(throttle_index, function(index){
         textbox.model_id = this.get_output_cell(index).text.trim();
 
         this.test.assert(this.cell_element_exists(index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(index, 
             '.my-throttle-textbox'), 'Textbox exists.');
 
         // Send 20 characters
         this.sendKeys('.my-throttle-textbox input', '12345678901234567890');
     });
 
     this.wait_for_widget(textbox);
 
     this.then(function () { 
         var outputs = this.evaluate(function(i) {
             return IPython.notebook.get_cell(i).output_area.outputs;
         }, {i : throttle_index});
 
         // Only 4 outputs should have printed, but because of timing, sometimes
         // 5 outputs will print.  All we need to do is verify num outputs <= 5
         // because that is much less than 20.
         this.test.assert(outputs.length <= 5, 'Messages throttled.');
 
         // We also need to verify that the last state sent was correct.
         var last_state = outputs[outputs.length-1].data['text/plain'];
         this.test.assertEquals(last_state, "20", "Last state sent when throttling.");
     });
 
 
     this.thenEvaluate(function() {
         define('TestWidget', ['widgets/js/widget', 'base/js/utils', 'underscore'], function(widget, utils, _) {
             var floatArray = {
                 deserialize: function (value, model) {
                     if (value===null) {return null;}
                     // DataView -> float64 typed array
                     return new Float64Array(value.buffer);
                 },
                 // serialization automatically handled since the 
                 // attribute is an ArrayBuffer view
             };
             
             var floatList = {
                 deserialize: function (value, model) {
                     // list of floats -> list of strings
                     return value.map(function(x) {return x.toString()});
                 },
                 serialize: function(value, model) {
                     // list of strings -> list of floats
                     return value.map(function(x) {return parseFloat(x);})
                 }
             };
 
             var TestWidgetModel = widget.WidgetModel.extend({}, {
                 serializers: _.extend({
                     array_list: floatList,
                     array_binary: floatArray
                 }, widget.WidgetModel.serializers)
             });
             
             var TestWidgetView = widget.DOMWidgetView.extend({
                 render: function () {
                     this.listenTo(this.model, 'msg:custom', this.handle_msg);
                 },
                 handle_msg: function(content, buffers) {
                     this.msg = [content, buffers];
                 }
             });
 
             return {TestWidgetModel: TestWidgetModel, TestWidgetView: TestWidgetView};
         });
     });
 
     var testwidget = {};
     this.append_cell_execute_then([
-        'from IPython.html import widgets',
+        'from jupyter_notebook import widgets',
         'from IPython.utils.traitlets import Unicode, Instance, List',
         'from IPython.display import display',
         'from array import array',
         'def _array_to_memoryview(x):',
         '    if x is None: return None',
         '    try:',
         '        y = memoryview(x)',
         '    except TypeError:',
         '        # in python 2, arrays do not support the new buffer protocol',
         '        y = memoryview(buffer(x))',
         '    return y',
         'def _memoryview_to_array(x):',
         '    if x is None: return None',
         '    return array("d", x.tobytes())',
         'arrays_binary = {',
         '    "from_json": _memoryview_to_array,',
         '    "to_json": _array_to_memoryview',
         '}',
         '',
         'def _array_to_list(x):',
         '    return list(x)',
         'def _list_to_array(x):',
         '    return array("d",x)',
         'arrays_list = {',
         '    "from_json": _list_to_array,',
         '    "to_json": _array_to_list',
         '}',
         '',
         'class TestWidget(widgets.DOMWidget):',
         '    _model_module = Unicode("TestWidget", sync=True)',
         '    _model_name = Unicode("TestWidgetModel", sync=True)',
         '    _view_module = Unicode("TestWidget", sync=True)',
         '    _view_name = Unicode("TestWidgetView", sync=True)',
         '    array_binary = Instance(array, allow_none=True, sync=True, **arrays_binary)',
         '    array_list = Instance(array, args=("d", [3.0]), allow_none=False, sync=True, **arrays_list)',
         '    msg = {}',
         '    def __init__(self, **kwargs):',
         '        super(widgets.DOMWidget, self).__init__(**kwargs)',
         '        self.on_msg(self._msg)',
         '    def _msg(self, _, content, buffers):',
         '        self.msg = [content, buffers]',
         'x=TestWidget()',
         'display(x)',
         'print(x.model_id)'].join('\n'), function(index){
             testwidget.index = index;
             testwidget.model_id = this.get_output_cell(index).text.trim();
         });
     this.wait_for_widget(testwidget);
 
 
     this.append_cell_execute_then('x.array_list = array("d", [1.5, 2.0, 3.1])');
     this.wait_for_widget(testwidget);
     this.then(function() {
         var result = this.evaluate(function(index) {
             var v = IPython.notebook.get_cell(index).widget_views[0];
             var result = v.model.get('array_list');
             var z = result.slice();
             z[0]+="1234";
             z[1]+="5678";
             v.model.set('array_list', z);
             v.touch();
             return result;
         }, testwidget.index);
         this.test.assertEquals(result, ["1.5", "2", "3.1"], "JSON custom serializer kernel -> js");
     });
     
     this.assert_output_equals('print(x.array_list.tolist() == [1.51234, 25678.0, 3.1])',
                               'True', 'JSON custom serializer js -> kernel');
 
     if (this.slimerjs) {
         this.append_cell_execute_then("x.array_binary=array('d', [1.5,2.5,5])", function() {
             this.evaluate(function(index) {
                 var v = IPython.notebook.get_cell(index).widget_views[0];
                 var z = v.model.get('array_binary');
                 z[0]*=3;
                 z[1]*=3;
                 z[2]*=3;
                 // we set to null so that we recognize the change
                 // when we set data back to z
                 v.model.set('array_binary', null);
                 v.model.set('array_binary', z);
                 v.touch();
             }, textwidget.index);
         });
         this.wait_for_widget(testwidget);
         this.assert_output_equals('x.array_binary.tolist() == [4.5, 7.5, 15.0]',
                                   'True\n', 'Binary custom serializer js -> kernel')
 
         this.append_cell_execute_then('x.send("some content", [memoryview(b"binarycontent"), memoryview("morecontent")])');
         this.wait_for_widget(testwidget);
 
         this.then(function() {
             var result = this.evaluate(function(index) {
                 var v = IPython.notebook.get_cell(index).widget_views[0];
                 var d = new TextDecoder('utf-8');
                 return {text: v.msg[0], 
                         binary0: d.decode(v.msg[1][0]),
                         binary1: d.decode(v.msg[1][1])};
             }, testwidget.index);
             this.test.assertEquals(result, {text: 'some content', 
                                        binary0: 'binarycontent', 
                                        binary1: 'morecontent'}, 
                               "Binary widget messages kernel -> js");
         });
 
         this.then(function() {
             this.evaluate(function(index) {
                 var v = IPython.notebook.get_cell(index).widget_views[0];
                 v.send('content back', [new Uint8Array([1,2,3,4]), new Float64Array([2.1828, 3.14159])])
             }, testwidget.index);
         });
         this.wait_for_widget(testwidget);
         this.assert_output_equals([
             'all([x.msg[0] == "content back",',
             '     x.msg[1][0].tolist() == [1,2,3,4],',
             '     array("d", x.msg[1][1].tobytes()).tolist() == [2.1828, 3.14159]])'].join('\n'),
                                   'True', 'Binary buffers message js -> kernel');
     } else {
         console.log("skipping binary websocket tests on phantomjs");
     }
 
 });

jupyter_notebook/tests/widgets/widget_bool.js

@@ -1,92 +1,92
 // Test widget bool class
 casper.notebook_test(function () {
     "use strict";
 
     // Create a checkbox and togglebutton.
     var bool_index = this.append_cell(
-        'from IPython.html import widgets\n' + 
+        'from jupyter_notebook import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'bool_widgets = [widgets.Checkbox(description="Title", value=True),\n' +
         '    widgets.ToggleButton(description="Title", value=True)]\n' +
         'display(bool_widgets[0])\n' +
         'display(bool_widgets[1])\n' +
         'print("Success")');
     this.execute_cell_then(bool_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create bool widget cell executed with correct output.');
     });
 
     // Wait for the widgets to actually display.
     var widget_checkbox_selector = '.widget-area .widget-subarea .widget-hbox input';
     var widget_togglebutton_selector = '.widget-area .widget-subarea button';
     this.wait_for_element(bool_index, widget_checkbox_selector);
     this.wait_for_element(bool_index, widget_togglebutton_selector);
 
     // Continue the tests.
     this.then(function() {
         this.test.assert(this.cell_element_exists(bool_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(bool_index, 
             widget_checkbox_selector),
             'Checkbox exists.');
 
         this.test.assert(this.cell_element_function(bool_index, 
             widget_checkbox_selector, 'prop', ['checked']),
             'Checkbox is checked.');
 
         this.test.assert(this.cell_element_exists(bool_index, 
             '.widget-area .widget-subarea .widget-hbox .widget-label'),
             'Checkbox label exists.');
 
         this.test.assert(this.cell_element_function(bool_index, 
             '.widget-area .widget-subarea .widget-hbox .widget-label', 'html')=="Title",
             'Checkbox labeled correctly.');
 
         this.test.assert(this.cell_element_exists(bool_index, 
             widget_togglebutton_selector),
             'Toggle button exists.');
 
         this.test.assert(this.cell_element_function(bool_index, 
             widget_togglebutton_selector, 'html')=='<i class="fa"></i>Title',
             'Toggle button labeled correctly.');
 
         this.test.assert(this.cell_element_function(bool_index, 
             widget_togglebutton_selector, 'hasClass', ['active']),
             'Toggle button is toggled.');
     });
 
     // Try changing the state of the widgets programatically.
     var index = this.append_cell(
         'bool_widgets[0].value = False\n' +
         'bool_widgets[1].value = False\n' +
         'print("Success")');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Change bool widget value cell executed with correct output.');
 
         this.test.assert(! this.cell_element_function(bool_index, 
             widget_checkbox_selector, 'prop', ['checked']),
             'Checkbox is not checked. (1)');
 
         this.test.assert(! this.cell_element_function(bool_index, 
             widget_togglebutton_selector, 'hasClass', ['active']),
             'Toggle button is not toggled. (1)');
  
         // Try toggling the bool by clicking on the checkbox.
         this.cell_element_function(bool_index, widget_checkbox_selector, 'click');
 
         this.test.assert(this.cell_element_function(bool_index, 
             widget_checkbox_selector, 'prop', ['checked']),
             'Checkbox is checked. (2)');
 
         // Try toggling the bool by clicking on the toggle button.
         this.cell_element_function(bool_index, widget_togglebutton_selector, 'click');
 
         this.test.assert(this.cell_element_function(bool_index, 
             widget_togglebutton_selector, 'hasClass', ['active']),
             'Toggle button is toggled. (3)');
 
     });
 });

jupyter_notebook/tests/widgets/widget_box.js

@@ -1,92 +1,92
 // Test container class
 casper.notebook_test(function () {
 
     // Create a box widget.
     var container_index = this.append_cell(
-        'from IPython.html import widgets\n' + 
+        'from jupyter_notebook import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'container = widgets.Box()\n' +
         'button = widgets.Button()\n'+
         'container.children = [button]\n'+
         'display(container)\n'+
         'container._dom_classes = ["my-test-class"]\n'+
         'print("Success")\n');
     this.execute_cell_then(container_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create container cell executed with correct output.');
     });
 
     // Wait for the widgets to actually display.
     var widget_box_selector = '.widget-area .widget-subarea .widget-box';
     var widget_box_button_selector = '.widget-area .widget-subarea .widget-box button';
     this.wait_for_element(container_index, widget_box_selector);
     this.wait_for_element(container_index, widget_box_button_selector);
 
     // Continue with the tests.
     this.then(function() {
         this.test.assert(this.cell_element_exists(container_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(container_index, 
             widget_box_selector),
             'Widget container exists.');
 
         this.test.assert(this.cell_element_exists(container_index, 
             '.widget-area .widget-subarea .my-test-class'),
             '_dom_classes works.');
 
         this.test.assert(this.cell_element_exists(container_index, 
             widget_box_button_selector),
             'Container parent/child relationship works.');
     });
 
     index = this.append_cell(
         'container.box_style = "success"\n'+
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
 
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Set box_style cell executed with correct output.');
 
         this.test.assert(this.cell_element_exists(container_index, 
             '.widget-box.alert-success'),
             'Set box_style works.');
     });
 
     index = this.append_cell(
         'container._dom_classes = []\n'+
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
 
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Remove container class cell executed with correct output.');
 
         this.test.assert(! this.cell_element_exists(container_index, 
             '.widget-area .widget-subarea .my-test-class'),
             '_dom_classes can be used to remove a class.');
     });
 
     var boxalone_index = this.append_cell(
         'display(button)\n'+
         'print("Success")\n');
     this.execute_cell_then(boxalone_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Display container child executed with correct output.');
     });
 
     // Wait for the widget to actually display.
     var widget_button_selector = '.widget-area .widget-subarea button';
     this.wait_for_element(boxalone_index, widget_button_selector);
 
     // Continue with the tests.
     this.then(function() {
         this.test.assert(! this.cell_element_exists(boxalone_index, 
             widget_box_selector),
             'Parent container not displayed.');
 
         this.test.assert(this.cell_element_exists(boxalone_index, 
             widget_button_selector),
             'Child displayed.');
     });
 });
  No newline at end of file

jupyter_notebook/tests/widgets/widget_button.js

@@ -1,48 +1,48
 // Test widget button class
 casper.notebook_test(function () {
     var button_index = this.append_cell(
-        'from IPython.html import widgets\n' + 
+        'from jupyter_notebook import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'button = widgets.Button(description="Title")\n' +
         'display(button)\n' +
         'print("Success")\n' +
         'def handle_click(sender):\n' +
         '    display("Clicked")\n' +
         'button.on_click(handle_click)');
     this.execute_cell_then(button_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n',
             'Create button cell executed with correct output.');
     });
 
     // Wait for the widgets to actually display.
     var widget_button_selector = '.widget-area .widget-subarea button';
     this.wait_for_element(button_index, widget_button_selector);
 
     // Continue with the tests.
     this.then(function() {
         this.test.assert(this.cell_element_exists(button_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(button_index, 
             widget_button_selector),
             'Widget button exists.');
 
         this.test.assert(this.cell_element_function(button_index, 
             widget_button_selector, 'html')=='<i class="fa"></i>Title',
             'Set button description.');
 
         this.cell_element_function(button_index, 
             widget_button_selector, 'click');
     });
 
     this.wait_for_output(button_index, 1);
 
     this.then(function () {
         var warning_text = this.get_output_cell(button_index, 1).text;
         this.test.assertNotEquals(warning_text.indexOf('Warning'), -1,
             'Importing widgets show a warning');
         this.test.assertEquals(this.get_output_cell(button_index, 2).data['text/plain'], "'Clicked'",
             'Button click event fires.');
     });
 });

jupyter_notebook/tests/widgets/widget_float.js

@@ -1,107 +1,107
 // Test widget float class
 casper.notebook_test(function () {
     var float_text = {};
     float_text.query = '.widget-area .widget-subarea .my-second-float-text input';
     float_text.index = this.append_cell(
-        'from IPython.html import widgets\n' + 
+        'from jupyter_notebook import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'float_widget = widgets.FloatText()\n' +
         'display(float_widget)\n' + 
         'float_widget._dom_classes = ["my-second-float-text"]\n' + 
         'print(float_widget.model_id)\n');
     this.execute_cell_then(float_text.index, function(index){
         float_text.model_id = this.get_output_cell(index).text.trim();
     });
 
     // Wait for the widget to actually display.
     this.wait_for_element(float_text.index, float_text.query);
 
     // Continue with the tests
     this.then(function(){        
         this.test.assert(this.cell_element_exists(float_text.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(float_text.index, float_text.query),
             'Widget float textbox exists.');
 
         this.cell_element_function(float_text.index, float_text.query, 'val', ['']);
         this.sendKeys(float_text.query, '1.05');
     });
 
     this.wait_for_widget(float_text);
 
     index = this.append_cell('print(float_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1.05\n', 
             'Float textbox value set.');
         this.cell_element_function(float_text.index, float_text.query, 'val', ['']);
         this.sendKeys(float_text.query, '123456789.0');
     });
 
     this.wait_for_widget(float_text);
     
     index = this.append_cell('print(float_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '123456789.0\n', 
             'Long float textbox value set (probably triggers throttling).');
         this.cell_element_function(float_text.index, float_text.query, 'val', ['']);
         this.sendKeys(float_text.query, '12hello');
     });
 
     this.wait_for_widget(float_text);
 
     index = this.append_cell('print(float_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '12.0\n', 
             'Invald float textbox value caught and filtered.');
     });
 
     var float_text_query = '.widget-area .widget-subarea .widget-numeric-text';
     var slider = {};
     slider.query = '.widget-area .widget-subarea .slider';
     slider.index = this.append_cell(
         'floatrange = [widgets.BoundedFloatText(), \n' +
         '    widgets.FloatSlider()]\n' +
         '[display(floatrange[i]) for i in range(2)]\n' + 
         'print("Success")\n');
     this.execute_cell_then(slider.index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create float range cell executed with correct output.');
     });
 
     // Wait for the widgets to actually display.
     this.wait_for_element(slider.index, slider.query);
     this.wait_for_element(slider.index, float_text_query);
 
     this.then(function(){
         this.test.assert(this.cell_element_exists(slider.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(slider.index, slider.query),
             'Widget slider exists.');
 
         this.test.assert(this.cell_element_exists(slider.index, float_text_query),
             'Widget float textbox exists.');
     });
 
     index = this.append_cell(
         'for widget in floatrange:\n' +
         '    widget.max = 50.0\n' +
         '    widget.min = -50.0\n' +
         '    widget.value = 25.0\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
 
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Float range properties cell executed with correct output.');
 
         this.test.assert(this.cell_element_exists(slider.index, slider.query), 
             'Widget slider exists.');
 
         this.test.assert(this.cell_element_function(slider.index, slider.query, 
             'slider', ['value']) == 25.0,
             'Slider set to Python value.');
     });
 });
  No newline at end of file

jupyter_notebook/tests/widgets/widget_image.js

@@ -1,49 +1,49
 // Test image class
 casper.notebook_test(function () {
     "use strict";
     var index = this.append_cell(
-        'from IPython.html import widgets\n' + 
+        'from jupyter_notebook import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'print("Success")');
     this.execute_cell_then(index);
 
     // Get the temporary directory that the test server is running in.
     var cwd = '';
     index = this.append_cell('!echo $(pwd)');
     this.execute_cell_then(index, function(index){
         cwd = this.get_output_cell(index).text.trim();
     });
 
     var test_jpg = '/9j/4AAQSkZJRgABAQEASABIAAD//gATQ3JlYXRlZCB3aXRoIEdJTVD/2wBDACAWGBwYFCAcGhwkIiAmMFA0MCwsMGJGSjpQdGZ6eHJmcG6AkLicgIiuim5woNqirr7EztDOfJri8uDI8LjKzsb/2wBDASIkJDAqMF40NF7GhHCExsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsb/wgARCAABAAEDAREAAhEBAxEB/8QAFAABAAAAAAAAAAAAAAAAAAAAA//EABUBAQEAAAAAAAAAAAAAAAAAAAME/9oADAMBAAIQAxAAAAECv//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAQUCf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQMBAT8Bf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8Bf//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEABj8Cf//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAT8hf//aAAwDAQACAAMAAAAQn//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQMBAT8Qf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8Qf//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAT8Qf//Z';
 
     var image_index = this.append_cell(
         'import base64\n' + 
         'data = base64.b64decode("' + test_jpg + '")\n' +
         'image = widgets.Image()\n' +
         'image.format = "jpeg"\n' +
         'image.value = data\n' +
         'image.width = "50px"\n' +
         'image.height = "50px"\n' +
         'display(image)\n' + 
         'print("Success")\n');
     this.execute_cell_then(image_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create image executed with correct output.');
     });
 
     // Wait for the widget to actually display.
     var img_selector = '.widget-area .widget-subarea img';
     this.wait_for_element(image_index, img_selector);
 
     this.then(function(){
         this.test.assert(this.cell_element_exists(image_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(image_index, img_selector), 'Image exists.');
 
         // Verify that the image's base64 data has made it into the DOM.
         var img_src = this.cell_element_function(image_index, img_selector, 'attr', ['src']);
         this.test.assert(img_src.indexOf(test_jpg) > -1, 'Image src data exists.');
     });    
 });

jupyter_notebook/tests/widgets/widget_int.js

@@ -1,177 +1,177
 // Test widget int class
 casper.notebook_test(function () {
     var int_text = {};
     int_text.query = '.widget-area .widget-subarea .my-second-int-text input';
     int_text.index = this.append_cell(
-        'from IPython.html import widgets\n' + 
+        'from jupyter_notebook import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'int_widget = widgets.IntText()\n' +
         'display(int_widget)\n' + 
         'int_widget._dom_classes = ["my-second-int-text"]\n' + 
         'print(int_widget.model_id)\n');
     this.execute_cell_then(int_text.index, function(index){
         int_text.model_id = this.get_output_cell(index).text.trim();
     });
 
     // Wait for the widget to actually display.
     this.wait_for_element(int_text.index, int_text.query);
 
     // Continue with the tests.
     this.then(function() {
         this.test.assert(this.cell_element_exists(int_text.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(int_text.index, int_text.query),
             'Widget int textbox exists.');
 
         this.cell_element_function(int_text.index, int_text.query, 'val', ['']);
         this.sendKeys(int_text.query, '1.05');
     });
 
     this.wait_for_widget(int_text);
 
     index = this.append_cell('print(int_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1\n', 
             'Int textbox value set.');
         this.cell_element_function(int_text.index, int_text.query, 'val', ['']);
         this.sendKeys(int_text.query, '123456789');
     });
 
     this.wait_for_widget(int_text);
 
     index = this.append_cell('print(int_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '123456789\n', 
             'Long int textbox value set (probably triggers throttling).');
         this.cell_element_function(int_text.index, int_text.query, 'val', ['']);
         this.sendKeys(int_text.query, '12hello');
     });
 
     this.wait_for_widget(int_text);
 
     index = this.append_cell('print(int_widget.value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '12\n', 
             'Invald int textbox value caught and filtered.');
     });
 
     var slider_query = '.widget-area .widget-subarea .slider';
     var int_text2 = {};
     int_text2.query = '.widget-area .widget-subarea .my-second-num-test-text input';
     int_text2.index = this.append_cell(
         'intrange = [widgets.BoundedIntTextWidget(),\n' +
         '    widgets.IntSliderWidget()]\n' +
         '[display(intrange[i]) for i in range(2)]\n' +
         'intrange[0]._dom_classes = ["my-second-num-test-text"]\n' +  
         'print(intrange[0].model_id)\n');
     this.execute_cell_then(int_text2.index, function(index){
         int_text2.model_id = this.get_output_cell(index).text.trim();
     });
 
     // Wait for the widgets to actually display.
     this.wait_for_element(int_text2.index, int_text2.query);
     this.wait_for_element(int_text2.index, slider_query);
 
     // Continue with the tests.
     this.then(function(){
         this.test.assert(this.cell_element_exists(int_text2.index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(int_text2.index, slider_query),
             'Widget slider exists.');
 
         this.test.assert(this.cell_element_exists(int_text2.index, int_text2.query),
             'Widget int textbox exists.');
     });
 
     index = this.append_cell(
         'for widget in intrange:\n' +
         '    widget.max = 50\n' +
         '    widget.min = -50\n' +
         '    widget.value = 25\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
 
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Int range properties cell executed with correct output.');
 
         this.test.assert(this.cell_element_exists(int_text2.index, slider_query), 
             'Widget slider exists.');
 
         this.test.assert(this.cell_element_function(int_text2.index, slider_query, 
             'slider', ['value']) == 25,
             'Slider set to Python value.');
 
         this.test.assert(this.cell_element_function(int_text2.index, int_text2.query,
             'val') == 25, 'Int textbox set to Python value.');
 
         // Clear the int textbox value and then set it to 1 by emulating
         // keyboard presses.
         this.evaluate(function(q){
             var textbox = IPython.notebook.element.find(q);
             textbox.val('1');
             textbox.trigger('keyup');
         }, {q: int_text2.query});
     });
 
     this.wait_for_widget(int_text2);
 
     index = this.append_cell('print(intrange[0].value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1\n', 
             'Int textbox set int range value');
 
         // Clear the int textbox value and then set it to 120 by emulating
         // keyboard presses.
         this.evaluate(function(q){
             var textbox = IPython.notebook.element.find(q);
             textbox.val('120');
             textbox.trigger('keyup');
         }, {q: int_text2.query});
     });
 
     this.wait_for_widget(int_text2);
 
     index = this.append_cell('print(intrange[0].value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '50\n', 
             'Int textbox value bound');
 
         // Clear the int textbox value and then set it to 'hello world' by 
         // emulating keyboard presses.  'hello world' should get filtered...
         this.evaluate(function(q){
             var textbox = IPython.notebook.element.find(q);
             textbox.val('hello world');
             textbox.trigger('keyup');
         }, {q: int_text2.query});
     });
 
     this.wait_for_widget(int_text2);
 
     index = this.append_cell('print(intrange[0].value)\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '50\n', 
             'Invalid int textbox characters ignored');
     });    
 
     index = this.append_cell(
         'a = widgets.IntSlider()\n' +
         'display(a)\n' +
         'a.max = -1\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(0, 0, 'Invalid int range max bound does not cause crash.');
     }, true); 
 
     index = this.append_cell(
         'a = widgets.IntSlider()\n' +
         'display(a)\n' +
         'a.min = 101\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(0, 0, 'Invalid int range min bound does not cause crash.');
     }, true);
 });
  No newline at end of file

jupyter_notebook/tests/widgets/widget_selection.js

@@ -1,148 +1,148
 // Test selection class
 casper.notebook_test(function () {
     index = this.append_cell(
-        'from IPython.html import widgets\n' + 
+        'from jupyter_notebook import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'print("Success")');
     this.execute_cell_then(index);
 
     var combo_selector = '.widget-area .widget-subarea .widget-hbox .btn-group .widget-combo-btn';
     var multibtn_selector = '.widget-area .widget-subarea .widget-hbox.widget-toggle-buttons .btn-group';
     var radio_selector = '.widget-area .widget-subarea .widget-hbox .widget-radio-box';
     var list_selector = '.widget-area .widget-subarea .widget-hbox .widget-listbox';
 
     var selection_index;
     var selection_values = 'abcd';
     var check_state = function(context, index, state){
         if (0 <= index && index < selection_values.length) {
             var multibtn_state = context.cell_element_function(selection_index, multibtn_selector + ' .btn:nth-child(' + (index + 1) + ')', 'hasClass', ['active']);
             var radio_state = context.cell_element_function(selection_index, radio_selector + ' .radio:nth-child(' + (index + 1) + ') input', 'prop', ['checked']);
             var list_val = context.cell_element_function(selection_index, list_selector, 'val');
             var combo_val = context.cell_element_function(selection_index, combo_selector, 'html');
             
             var val = selection_values.charAt(index);
             var list_state = (val == list_val);
             var combo_state = (val == combo_val);
 
             return multibtn_state == state &&
                 radio_state == state &&
                 list_state == state &&
                 combo_state == state;
         }
         return true;
     };
 
     var verify_selection = function(context, index){
         for (var i = 0; i < selection_values.length; i++) {
             if (!check_state(context, i, i==index)) {
                 return false;
             }
         }
         return true;
     };
 
 //values=["' + selection_values + '"[i] for i in range(4)]
     selection_index = this.append_cell(
         'options=["' + selection_values + '"[i] for i in range(4)]\n' +
         'selection = [widgets.Dropdown(options=options),\n' +
         '    widgets.ToggleButtons(options=options),\n' +
         '    widgets.RadioButtons(options=options),\n' +
         '    widgets.Select(options=options)]\n' +
         '[display(selection[i]) for i in range(4)]\n' +
         'for widget in selection:\n' +
         '    def handle_change(name,old,new):\n' +
         '        for other_widget in selection:\n' +
         '            other_widget.value = new\n' +
         '    widget.on_trait_change(handle_change, "value")\n' +
         'print("Success")\n');
     this.execute_cell_then(selection_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create selection cell executed with correct output.');
     });
 
     // Wait for the widgets to actually display.
     this.wait_for_element(selection_index, combo_selector);
     this.wait_for_element(selection_index, multibtn_selector);
     this.wait_for_element(selection_index, radio_selector);
     this.wait_for_element(selection_index, list_selector);
 
     // Continue with the tests.
     this.then(function() {
         this.test.assert(this.cell_element_exists(selection_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(selection_index, combo_selector),
              'Widget combobox exists.');
 
         this.test.assert(this.cell_element_exists(selection_index, multibtn_selector),
             'Widget multibutton exists.');
 
         this.test.assert(this.cell_element_exists(selection_index, radio_selector),
             'Widget radio buttons exists.');
 
         this.test.assert(this.cell_element_exists(selection_index, list_selector),
             'Widget list exists.');
 
         // Verify that no items are selected.
         this.test.assert(verify_selection(this, 0), 'Default first item selected.');
     });
 
     index = this.append_cell(
         'for widget in selection:\n' +
         '    widget.value = "a"\n' +
         'print("Success")\n');
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Python select item executed with correct output.');
 
         // Verify that the first item is selected.
         this.test.assert(verify_selection(this, 0), 'Python selected');
 
         // Verify that selecting a radio button updates all of the others.
         this.cell_element_function(selection_index, radio_selector + ' .radio:nth-child(2) input', 'click');
     });
     this.wait_for_idle();
     this.then(function () {
         this.test.assert(verify_selection(this, 1), 'Radio button selection updated view states correctly.');
 
         // Verify that selecting a list option updates all of the others.
         this.cell_element_function(selection_index, list_selector + ' option:nth-child(3)', 'click');
     });
     this.wait_for_idle();
     this.then(function () {
         this.test.assert(verify_selection(this, 2), 'List selection updated view states correctly.');
 
         // Verify that selecting a multibutton option updates all of the others.
         // Bootstrap3 has changed the toggle button group behavior.  Two clicks
         // are required to actually select an item.
         this.cell_element_function(selection_index, multibtn_selector + ' .btn:nth-child(4)', 'click');
         this.cell_element_function(selection_index, multibtn_selector + ' .btn:nth-child(4)', 'click');
     });
     this.wait_for_idle();
     this.then(function () {
         this.test.assert(verify_selection(this, 3), 'Multibutton selection updated view states correctly.');
 
         // Verify that selecting a combobox option updates all of the others.
         this.cell_element_function(selection_index, '.widget-area .widget-subarea .widget-hbox .btn-group ul.dropdown-menu li:nth-child(3) a', 'click');
     });
     this.wait_for_idle();
     this.then(function () {
         this.test.assert(verify_selection(this, 2), 'Combobox selection updated view states correctly.');
     });
 
     this.wait_for_idle();
 
     index = this.append_cell(
         'from copy import copy\n' +
         'for widget in selection:\n' +
         '    d = copy(widget.options)\n' +
         '    d.append("z")\n' +
         '    widget.options = d\n' +
         'selection[0].value = "z"');
     this.execute_cell_then(index, function(index){
 
         // Verify that selecting a combobox option updates all of the others.
         this.test.assert(verify_selection(this, 4), 'Item added to selection widget.');
     });
 });
  No newline at end of file

jupyter_notebook/tests/widgets/widget_selectioncontainer.js

@@ -1,120 +1,120
 // Test multicontainer class
 casper.notebook_test(function () {
     index = this.append_cell(
-        'from IPython.html import widgets\n' + 
+        'from jupyter_notebook import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'print("Success")');
     this.execute_cell_then(index);
 
     // Test tab view
     var multicontainer1_query = '.widget-area .widget-subarea div div.nav-tabs';
     var multicontainer1_index = this.append_cell(
         'multicontainer = widgets.Tab()\n' +
         'page1 = widgets.Text()\n' +
         'page2 = widgets.Text()\n' +
         'page3 = widgets.Text()\n' +
         'multicontainer.children = [page1, page2, page3]\n' +
         'display(multicontainer)\n' +
         'multicontainer.selected_index = 0\n' +
         'print("Success")\n');
     this.execute_cell_then(multicontainer1_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create multicontainer cell executed with correct output. (1)');
     });
 
     // Wait for the widget to actually display.
     this.wait_for_element(multicontainer1_index, multicontainer1_query);
 
     // Continue with the tests.
     this.then(function() {
         this.test.assert(this.cell_element_exists(multicontainer1_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(multicontainer1_index, multicontainer1_query),
             'Widget tab list exists.');
 
         // JQuery selector is 1 based
         this.click(multicontainer1_query + ' li:nth-child(2) a');
     });
 
     this.wait_for_idle();
 
     index = this.append_cell(
         'print(multicontainer.selected_index)\n' +
         'multicontainer.selected_index = 2'); // 0 based
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1\n', // 0 based
             'selected_index property updated with tab change.');
 
         // JQuery selector is 1 based
         this.test.assert(!this.cell_element_function(multicontainer1_index, multicontainer1_query + ' li:nth-child(1)', 'hasClass', ['active']),
                 "Tab 1 is not selected.");
         this.test.assert(!this.cell_element_function(multicontainer1_index, multicontainer1_query + ' li:nth-child(2)', 'hasClass', ['active']),
                 "Tab 2 is not selected.");
         this.test.assert(this.cell_element_function(multicontainer1_index, multicontainer1_query + ' li:nth-child(3)', 'hasClass', ['active']),
                 "Tab 3 is selected.");
     });
 
     index = this.append_cell('multicontainer.set_title(1, "hello")\nprint("Success")'); // 0 based
     this.execute_cell_then(index, function(index){
         this.test.assert(this.cell_element_function(multicontainer1_index, multicontainer1_query +
             ' li:nth-child(2) a', 'html') == 'hello',
             'Tab page title set (after display).');
     });
 
     // Test accordion view
     var multicontainer2_query = '.widget-area .widget-subarea .panel-group';
     var multicontainer2_index = this.append_cell(
         'multicontainer = widgets.Accordion()\n' +
         'page1 = widgets.Text()\n' +
         'page2 = widgets.Text()\n' +
         'page3 = widgets.Text()\n' +
         'multicontainer.children = [page1, page2, page3]\n' +
         'multicontainer.set_title(2, "good")\n' +
         'display(multicontainer)\n' +
         'multicontainer.selected_index = 0\n' +
         'print("Success")\n');
     this.execute_cell_then(multicontainer2_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create multicontainer cell executed with correct output. (2)');
     });
 
     // Wait for the widget to actually display.
     this.wait_for_element(multicontainer2_index, multicontainer2_query);
 
     // Continue with the tests.
     this.then(function() {
         this.test.assert(this.cell_element_exists(multicontainer2_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(multicontainer2_index, multicontainer2_query),
             'Widget accordion exists.');
 
         this.test.assert(this.cell_element_exists(multicontainer2_index, multicontainer2_query + 
             ' .panel:nth-child(1) .panel-collapse'),
             'First accordion page exists.');
 
         // JQuery selector is 1 based
         this.test.assert(this.cell_element_function(multicontainer2_index, multicontainer2_query + 
             ' .panel.panel-default:nth-child(3) .panel-heading .accordion-toggle', 
             'html')=='good', 'Accordion page title set (before display).');
 
         // JQuery selector is 1 based
         this.click(multicontainer2_query + ' .panel:nth-child(2) .panel-heading .accordion-toggle');
     });
 
     this.wait_for_idle();
 
     index = this.append_cell('print(multicontainer.selected_index)'); // 0 based
     this.execute_cell_then(index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, '1\n', // 0 based
             'selected_index property updated with tab change.');
 
         var is_collapsed = this.evaluate(function(s){
              return $(s + ' div.panel:nth-child(2) a').hasClass('collapsed'); // 1 based
         }, {s: multicontainer2_query});
         this.test.assertEquals(is_collapsed, false, 'Was tab actually opened?');
     });
 });
  No newline at end of file

jupyter_notebook/tests/widgets/widget_string.js

@@ -1,59 +1,59
 // Test widget string class
 casper.notebook_test(function () {
     var string_index = this.append_cell(
-        'from IPython.html import widgets\n' + 
+        'from jupyter_notebook import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'string_widget = [widgets.Text(value = "xyz", placeholder = "abc"),\n' +
         '    widgets.Textarea(value = "xyz", placeholder = "def"),\n' +
         '    widgets.HTML(value = "xyz"),\n' +
         '    widgets.Latex(value = "$\\\\LaTeX{}$")]\n' +
         '[display(widget) for widget in string_widget]\n'+
         'print("Success")');
     this.execute_cell_then(string_index, function(index){
         this.test.assertEquals(this.get_output_cell(index).text, 'Success\n', 
             'Create string widget cell executed with correct output.');
     });
 
     // Wait for the widget to actually display.
     var textbox_selector = '.widget-area .widget-subarea .widget-hbox input[type=text]';
     var textarea_selector = '.widget-area .widget-subarea .widget-hbox textarea';
     var latex_selector = '.widget-area .widget-subarea div span.MathJax_Preview';
     this.wait_for_element(string_index, textbox_selector);
     this.wait_for_element(string_index, textarea_selector);
     this.wait_for_element(string_index, latex_selector);
 
     // Continue with the tests.
     this.then(function(){
         this.test.assert(this.cell_element_exists(string_index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(string_index, 
             textbox_selector),
             'Textbox exists.');
 
         this.test.assert(this.cell_element_exists(string_index, 
             textarea_selector),
             'Textarea exists.');
 
         this.test.assert(this.cell_element_function(string_index, 
             textarea_selector, 'val')=='xyz',
             'Python set textarea value.');
 
         this.test.assert(this.cell_element_function(string_index, 
             textbox_selector, 'val')=='xyz',
             'Python set textbox value.');
 
         this.test.assert(this.cell_element_exists(string_index, 
             latex_selector),
             'MathJax parsed the LaTeX successfully.');
 
         this.test.assert(this.cell_element_function(string_index, 
             textarea_selector, 'attr', ['placeholder'])=='def',
             'Python set textarea placeholder.');
 
         this.test.assert(this.cell_element_function(string_index, 
             textbox_selector, 'attr', ['placeholder'])=='abc',
             'Python set textbox placehoder.');
     });
 });

jupyter_notebook/tree/tests/test_tree_handler.py

@@ -1,32 +1,32
 """Test the /tree handlers"""
 import os
 import io
-from IPython.html.utils import url_path_join
+from jupyter_notebook.utils import url_path_join
 from IPython.nbformat import write
 from IPython.nbformat.v4 import new_notebook
 
 import requests
 
-from IPython.html.tests.launchnotebook import NotebookTestBase
+from jupyter_notebook.tests.launchnotebook import NotebookTestBase
 
 class TreeTest(NotebookTestBase):
     def setUp(self):
         nbdir = self.notebook_dir.name
         d = os.path.join(nbdir, 'foo')
         os.mkdir(d)
 
         with io.open(os.path.join(d, 'bar.ipynb'), 'w', encoding='utf-8') as f:
             nb = new_notebook()
             write(nb, f, version=4)
 
         with io.open(os.path.join(d, 'baz.txt'), 'w', encoding='utf-8') as f:
             f.write(u'flamingo')
 
         self.base_url()
 
     def test_redirect(self):
         r = requests.get(url_path_join(self.base_url(), 'tree/foo/bar.ipynb'))
         self.assertEqual(r.url, self.base_url() + 'notebooks/foo/bar.ipynb')
 
         r = requests.get(url_path_join(self.base_url(), 'tree/foo/baz.txt'))
         self.assertEqual(r.url, url_path_join(self.base_url(), 'files/foo/baz.txt'))

jupyter_notebook/widgets/__init__.py

@@ -1,40 +1,40
 from .widget import Widget, DOMWidget, CallbackDispatcher, register, widget_serialization
 
 from .trait_types import Color, EventfulDict, EventfulList
 
 from .widget_bool import Checkbox, ToggleButton, Valid
 from .widget_button import Button
 from .widget_box import Box, FlexBox, HBox, VBox
 from .widget_float import FloatText, BoundedFloatText, FloatSlider, FloatProgress, FloatRangeSlider
 from .widget_image import Image
 from .widget_int import IntText, BoundedIntText, IntSlider, IntProgress, IntRangeSlider
 from .widget_output import Output
 from .widget_selection import RadioButtons, ToggleButtons, Dropdown, Select, SelectMultiple
 from .widget_selectioncontainer import Tab, Accordion
 from .widget_string import HTML, Latex, Text, Textarea
 from .interaction import interact, interactive, fixed, interact_manual
 from .widget_link import jslink, jsdlink
 
 # Deprecated classes
 from .widget_bool import CheckboxWidget, ToggleButtonWidget
 from .widget_button import ButtonWidget
 from .widget_box import ContainerWidget
 from .widget_float import FloatTextWidget, BoundedFloatTextWidget, FloatSliderWidget, FloatProgressWidget
 from .widget_image import ImageWidget
 from .widget_int import IntTextWidget, BoundedIntTextWidget, IntSliderWidget, IntProgressWidget
 from .widget_selection import RadioButtonsWidget, ToggleButtonsWidget, DropdownWidget, SelectWidget
 from .widget_selectioncontainer import TabWidget, AccordionWidget
 from .widget_string import HTMLWidget, LatexWidget, TextWidget, TextareaWidget
 
 # We use warn_explicit so we have very brief messages without file or line numbers.
 # The concern is that file or line numbers will confuse the interactive user.
 # To ignore this warning, do:
 #
 #     from warnings import filterwarnings
-#     filterwarnings('ignore', module='IPython.html.widgets')
+#     filterwarnings('ignore', module='jupyter_notebook.widgets')
 
 from warnings import warn_explicit
 __warningregistry__ = {}
 warn_explicit("IPython widgets are experimental and may change in the future.",
-              FutureWarning, '', 0, module = 'IPython.html.widgets',
+              FutureWarning, '', 0, module = 'jupyter_notebook.widgets',
               registry = __warningregistry__, module_globals = globals)

jupyter_notebook/widgets/interaction.py

@@ -1,344 +1,344
 """Interact with functions using widgets."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
 try:  # Python >= 3.3
     from inspect import signature, Parameter
 except ImportError:
     from IPython.utils.signatures import signature, Parameter
 from inspect import getcallargs
 
 from IPython.core.getipython import get_ipython
-from IPython.html.widgets import (Widget, Text,
+from jupyter_notebook.widgets import (Widget, Text,
     FloatSlider, IntSlider, Checkbox, Dropdown,
     Box, Button, DOMWidget)
 from IPython.display import display, clear_output
 from IPython.utils.py3compat import string_types, unicode_type
 from IPython.utils.traitlets import HasTraits, Any, Unicode
 
 empty = Parameter.empty
 
 
 def _matches(o, pattern):
     """Match a pattern of types in a sequence."""
     if not len(o) == len(pattern):
         return False
     comps = zip(o,pattern)
     return all(isinstance(obj,kind) for obj,kind in comps)
 
 
 def _get_min_max_value(min, max, value=None, step=None):
     """Return min, max, value given input values with possible None."""
     if value is None:
         if not max > min:
             raise ValueError('max must be greater than min: (min={0}, max={1})'.format(min, max))
         value = min + abs(min-max)/2
         value = type(min)(value)
     elif min is None and max is None:
         if value == 0.0:
             min, max, value = 0.0, 1.0, 0.5
         elif value == 0:
             min, max, value = 0, 1, 0
         elif isinstance(value, (int, float)):
             min, max = (-value, 3*value) if value > 0 else (3*value, -value)
         else:
             raise TypeError('expected a number, got: %r' % value)
     else:
         raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))
     if step is not None:
         # ensure value is on a step
         r = (value - min) % step
         value = value - r
     return min, max, value
 
 def _widget_abbrev_single_value(o):
     """Make widgets from single values, which can be used as parameter defaults."""
     if isinstance(o, string_types):
         return Text(value=unicode_type(o))
     elif isinstance(o, dict):
         return Dropdown(options=o)
     elif isinstance(o, bool):
         return Checkbox(value=o)
     elif isinstance(o, float):
         min, max, value = _get_min_max_value(None, None, o)
         return FloatSlider(value=o, min=min, max=max)
     elif isinstance(o, int):
         min, max, value = _get_min_max_value(None, None, o)
         return IntSlider(value=o, min=min, max=max)
     else:
         return None
 
 def _widget_abbrev(o):
     """Make widgets from abbreviations: single values, lists or tuples."""
     float_or_int = (float, int)
     if isinstance(o, (list, tuple)):
         if o and all(isinstance(x, string_types) for x in o):
             return Dropdown(options=[unicode_type(k) for k in o])
         elif _matches(o, (float_or_int, float_or_int)):
             min, max, value = _get_min_max_value(o[0], o[1])
             if all(isinstance(_, int) for _ in o):
                 cls = IntSlider
             else:
                 cls = FloatSlider
             return cls(value=value, min=min, max=max)
         elif _matches(o, (float_or_int, float_or_int, float_or_int)):
             step = o[2]
             if step <= 0:
                 raise ValueError("step must be >= 0, not %r" % step)
             min, max, value = _get_min_max_value(o[0], o[1], step=step)
             if all(isinstance(_, int) for _ in o):
                 cls = IntSlider
             else:
                 cls = FloatSlider
             return cls(value=value, min=min, max=max, step=step)
     else:
         return _widget_abbrev_single_value(o)
 
 def _widget_from_abbrev(abbrev, default=empty):
     """Build a Widget instance given an abbreviation or Widget."""
     if isinstance(abbrev, Widget) or isinstance(abbrev, fixed):
         return abbrev
 
     widget = _widget_abbrev(abbrev)
     if default is not empty and isinstance(abbrev, (list, tuple, dict)):
         # if it's not a single-value abbreviation,
         # set the initial value from the default
         try:
             widget.value = default
         except Exception:
             # ignore failure to set default
             pass
     if widget is None:
         raise ValueError("%r cannot be transformed to a Widget" % (abbrev,))
     return widget
 
 def _yield_abbreviations_for_parameter(param, kwargs):
     """Get an abbreviation for a function parameter."""
     name = param.name
     kind = param.kind
     ann = param.annotation
     default = param.default
     not_found = (name, empty, empty)
     if kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY):
         if name in kwargs:
             value = kwargs.pop(name)
         elif ann is not empty:
             value = ann
         elif default is not empty:
             value = default
         else:
             yield not_found
         yield (name, value, default)
     elif kind == Parameter.VAR_KEYWORD:
         # In this case name=kwargs and we yield the items in kwargs with their keys.
         for k, v in kwargs.copy().items():
             kwargs.pop(k)
             yield k, v, empty
 
 def _find_abbreviations(f, kwargs):
     """Find the abbreviations for a function and kwargs passed to interact."""
     new_kwargs = []
     for param in signature(f).parameters.values():
         for name, value, default in _yield_abbreviations_for_parameter(param, kwargs):
             if value is empty:
                 raise ValueError('cannot find widget or abbreviation for argument: {!r}'.format(name))
             new_kwargs.append((name, value, default))
     return new_kwargs
 
 def _widgets_from_abbreviations(seq):
     """Given a sequence of (name, abbrev) tuples, return a sequence of Widgets."""
     result = []
     for name, abbrev, default in seq:
         widget = _widget_from_abbrev(abbrev, default)
         if not widget.description:
             widget.description = name
         widget._kwarg = name
         result.append(widget)
     return result
 
 def interactive(__interact_f, **kwargs):
     """
     Builds a group of interactive widgets tied to a function and places the
     group into a Box container.
 
     Returns
     -------
     container : a Box instance containing multiple widgets
 
     Parameters
     ----------
     __interact_f : function
         The function to which the interactive widgets are tied. The `**kwargs`
         should match the function signature.
     **kwargs : various, optional
         An interactive widget is created for each keyword argument that is a
         valid widget abbreviation.
     """
     f = __interact_f
     co = kwargs.pop('clear_output', True)
     manual = kwargs.pop('__manual', False)
     kwargs_widgets = []
     container = Box(_dom_classes=['widget-interact'])
     container.result = None
     container.args = []
     container.kwargs = dict()
     kwargs = kwargs.copy()
 
     new_kwargs = _find_abbreviations(f, kwargs)
     # Before we proceed, let's make sure that the user has passed a set of args+kwargs
     # that will lead to a valid call of the function. This protects against unspecified
     # and doubly-specified arguments.
     getcallargs(f, **{n:v for n,v,_ in new_kwargs})
     # Now build the widgets from the abbreviations.
     kwargs_widgets.extend(_widgets_from_abbreviations(new_kwargs))
 
     # This has to be done as an assignment, not using container.children.append,
     # so that traitlets notices the update. We skip any objects (such as fixed) that
     # are not DOMWidgets.
     c = [w for w in kwargs_widgets if isinstance(w, DOMWidget)]
 
     # If we are only to run the function on demand, add a button to request this
     if manual:
         manual_button = Button(description="Run %s" % f.__name__)
         c.append(manual_button)
     container.children = c
 
     # Build the callback
     def call_f(name=None, old=None, new=None):
         container.kwargs = {}
         for widget in kwargs_widgets:
             value = widget.value
             container.kwargs[widget._kwarg] = value
         if co:
             clear_output(wait=True)
         if manual:
             manual_button.disabled = True
         try:
             container.result = f(**container.kwargs)
         except Exception as e:
             ip = get_ipython()
             if ip is None:
                 container.log.warn("Exception in interact callback: %s", e, exc_info=True)
             else:
                 ip.showtraceback()
         finally:
             if manual:
                 manual_button.disabled = False
 
     # Wire up the widgets
     # If we are doing manual running, the callback is only triggered by the button
     # Otherwise, it is triggered for every trait change received
     # On-demand running also suppresses running the function with the initial parameters
     if manual:
         manual_button.on_click(call_f)
     else:
         for widget in kwargs_widgets:
             widget.on_trait_change(call_f, 'value')
 
         container.on_displayed(lambda _: call_f(None, None, None))
 
     return container
 
 def interact(__interact_f=None, **kwargs):
     """
     Displays interactive widgets which are tied to a function.
     Expects the first argument to be a function. Parameters to this function are
     widget abbreviations passed in as keyword arguments (`**kwargs`). Can be used
     as a decorator (see examples).
 
     Returns
     -------
     f : __interact_f with interactive widget attached to it.
 
     Parameters
     ----------
     __interact_f : function
         The function to which the interactive widgets are tied. The `**kwargs`
         should match the function signature. Passed to :func:`interactive()`
     **kwargs : various, optional
         An interactive widget is created for each keyword argument that is a
         valid widget abbreviation. Passed to :func:`interactive()`
 
     Examples
     --------
     Render an interactive text field that shows the greeting with the passed in
     text::
 
        # 1. Using interact as a function
        def greeting(text="World"):
            print "Hello {}".format(text)
        interact(greeting, text="IPython Widgets")
         
        # 2. Using interact as a decorator
        @interact
        def greeting(text="World"):
            print "Hello {}".format(text)
         
        # 3. Using interact as a decorator with named parameters
        @interact(text="IPython Widgets")
        def greeting(text="World"):
            print "Hello {}".format(text)
         
     Render an interactive slider widget and prints square of number::
 
        # 1. Using interact as a function
        def square(num=1):
            print "{} squared is {}".format(num, num*num)
        interact(square, num=5)
 
        # 2. Using interact as a decorator
        @interact
        def square(num=2):
            print "{} squared is {}".format(num, num*num)
         
        # 3. Using interact as a decorator with named parameters
        @interact(num=5)
        def square(num=2):
            print "{} squared is {}".format(num, num*num)
     """
     # positional arg support in: https://gist.github.com/8851331
     if __interact_f is not None:
         # This branch handles the cases 1 and 2
         # 1. interact(f, **kwargs)
         # 2. @interact
         #    def f(*args, **kwargs):
         #        ...
         f = __interact_f
         w = interactive(f, **kwargs)
         try:
             f.widget = w
         except AttributeError:
             # some things (instancemethods) can't have attributes attached,
             # so wrap in a lambda
             f = lambda *args, **kwargs: __interact_f(*args, **kwargs)
             f.widget = w
         display(w)
         return f
     else:
         # This branch handles the case 3
         # @interact(a=30, b=40)
         # def f(*args, **kwargs):
         #     ...
         def dec(f):
             return interact(f, **kwargs)
         return dec
 
 def interact_manual(__interact_f=None, **kwargs):
     """interact_manual(f, **kwargs)
     
     As `interact()`, generates widgets for each argument, but rather than running
     the function after each widget change, adds a "Run" button and waits for it
     to be clicked. Useful if the function is long-running and has several
     parameters to change.
     """
     return interact(__interact_f, __manual=True, **kwargs)
 
 class fixed(HasTraits):
     """A pseudo-widget whose value is fixed and never synced to the client."""
     value = Any(help="Any Python object")
     description = Unicode('', help="Any Python object")
     def __init__(self, value, **kwargs):
         super(fixed, self).__init__(value=value, **kwargs)

jupyter_notebook/widgets/tests/test_interaction.py

@@ -1,693 +1,693
 """Test interact and interactive."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
 try:
     from unittest.mock import patch
 except ImportError:
     from mock import patch
 
 import nose.tools as nt
 
 from IPython.kernel.comm import Comm
-from IPython.html import widgets
-from IPython.html.widgets import interact, interactive, Widget, interaction
+from jupyter_notebook import widgets
+from jupyter_notebook.widgets import interact, interactive, Widget, interaction
 from IPython.utils.py3compat import annotate
 
 #-----------------------------------------------------------------------------
 # Utility stuff
 #-----------------------------------------------------------------------------
 
 class DummyComm(Comm):
     comm_id = 'a-b-c-d'
     
     def open(self, *args, **kwargs):
         pass
     
     def send(self, *args, **kwargs):
         pass
     
     def close(self, *args, **kwargs):
         pass
 
 _widget_attrs = {}
 displayed = []
 undefined = object()
 
 def setup():
     _widget_attrs['_comm_default'] = getattr(Widget, '_comm_default', undefined)
     Widget._comm_default = lambda self: DummyComm()
     _widget_attrs['_ipython_display_'] = Widget._ipython_display_
     def raise_not_implemented(*args, **kwargs):
         raise NotImplementedError()
     Widget._ipython_display_ = raise_not_implemented
 
 def teardown():
     for attr, value in _widget_attrs.items():
         if value is undefined:
             delattr(Widget, attr)
         else:
             setattr(Widget, attr, value)
 
 def f(**kwargs):
     pass
 
 def clear_display():
     global displayed
     displayed = []
 
 def record_display(*args):
     displayed.extend(args)
 
 #-----------------------------------------------------------------------------
 # Actual tests
 #-----------------------------------------------------------------------------
 
 def check_widget(w, **d):
     """Check a single widget against a dict"""
     for attr, expected in d.items():
         if attr == 'cls':
             nt.assert_is(w.__class__, expected)
         else:
             value = getattr(w, attr)
             nt.assert_equal(value, expected,
                 "%s.%s = %r != %r" % (w.__class__.__name__, attr, value, expected)
             )
 
 def check_widgets(container, **to_check):
     """Check that widgets are created as expected"""
     # build a widget dictionary, so it matches
     widgets = {}
     for w in container.children:
         widgets[w.description] = w
     
     for key, d in to_check.items():
         nt.assert_in(key, widgets)
         check_widget(widgets[key], **d)
     
 
 def test_single_value_string():
     a = u'hello'
     c = interactive(f, a=a)
     w = c.children[0]
     check_widget(w,
         cls=widgets.Text,
         description='a',
         value=a,
     )
 
 def test_single_value_bool():
     for a in (True, False):
         c = interactive(f, a=a)
         w = c.children[0]
         check_widget(w,
             cls=widgets.Checkbox,
             description='a',
             value=a,
         )
 
 def test_single_value_dict():
     for d in [
         dict(a=5),
         dict(a=5, b='b', c=dict),
     ]:
         c = interactive(f, d=d)
         w = c.children[0]
         check_widget(w,
             cls=widgets.Dropdown,
             description='d',
             options=d,
             value=next(iter(d.values())),
         )
 
 def test_single_value_float():
     for a in (2.25, 1.0, -3.5):
         c = interactive(f, a=a)
         w = c.children[0]
         check_widget(w,
             cls=widgets.FloatSlider,
             description='a',
             value=a,
             min= -a if a > 0 else 3*a,
             max= 3*a if a > 0 else -a,
             step=0.1,
             readout=True,
         )
 
 def test_single_value_int():
     for a in (1, 5, -3):
         c = interactive(f, a=a)
         nt.assert_equal(len(c.children), 1)
         w = c.children[0]
         check_widget(w,
             cls=widgets.IntSlider,
             description='a',
             value=a,
             min= -a if a > 0 else 3*a,
             max= 3*a if a > 0 else -a,
             step=1,
             readout=True,
         )
 
 def test_list_tuple_2_int():
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,1))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,-1))
     for min, max in [ (0,1), (1,10), (1,2), (-5,5), (-20,-19) ]:
         c = interactive(f, tup=(min, max), lis=[min, max])
         nt.assert_equal(len(c.children), 2)
         d = dict(
             cls=widgets.IntSlider,
             min=min,
             max=max,
             step=1,
             readout=True,
         )
         check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_3_int():
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,2,0))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,2,-1))
     for min, max, step in [ (0,2,1), (1,10,2), (1,100,2), (-5,5,4), (-100,-20,4) ]:
         c = interactive(f, tup=(min, max, step), lis=[min, max, step])
         nt.assert_equal(len(c.children), 2)
         d = dict(
             cls=widgets.IntSlider,
             min=min,
             max=max,
             step=step,
             readout=True,
         )
         check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_2_float():
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1.0,1.0))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(0.5,-0.5))
     for min, max in [ (0.5, 1.5), (1.1,10.2), (1,2.2), (-5.,5), (-20,-19.) ]:
         c = interactive(f, tup=(min, max), lis=[min, max])
         nt.assert_equal(len(c.children), 2)
         d = dict(
             cls=widgets.FloatSlider,
             min=min,
             max=max,
             step=.1,
             readout=True,
         )
         check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_3_float():
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,2,0.0))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(-1,-2,1.))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,2.,-1.))
     for min, max, step in [ (0.,2,1), (1,10.,2), (1,100,2.), (-5.,5.,4), (-100,-20.,4.) ]:
         c = interactive(f, tup=(min, max, step), lis=[min, max, step])
         nt.assert_equal(len(c.children), 2)
         d = dict(
             cls=widgets.FloatSlider,
             min=min,
             max=max,
             step=step,
             readout=True,
         )
         check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_str():
     values = ['hello', 'there', 'guy']
     first = values[0]
     c = interactive(f, tup=tuple(values), lis=list(values))
     nt.assert_equal(len(c.children), 2)
     d = dict(
         cls=widgets.Dropdown,
         value=first,
         options=values
     )
     check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_invalid():
     for bad in [
         (),
         (5, 'hi'),
         ('hi', 5),
         ({},),
         (None,),
     ]:
         with nt.assert_raises(ValueError):
             print(bad) # because there is no custom message in assert_raises
             c = interactive(f, tup=bad)
 
 def test_defaults():
     @annotate(n=10)
     def f(n, f=4.5, g=1):
         pass
     
     c = interactive(f)
     check_widgets(c,
         n=dict(
             cls=widgets.IntSlider,
             value=10,
         ),
         f=dict(
             cls=widgets.FloatSlider,
             value=4.5,
         ),
         g=dict(
             cls=widgets.IntSlider,
             value=1,
         ),
     )
 
 def test_default_values():
     @annotate(n=10, f=(0, 10.), g=5, h={'a': 1, 'b': 2}, j=['hi', 'there'])
     def f(n, f=4.5, g=1, h=2, j='there'):
         pass
     
     c = interactive(f)
     check_widgets(c,
         n=dict(
             cls=widgets.IntSlider,
             value=10,
         ),
         f=dict(
             cls=widgets.FloatSlider,
             value=4.5,
         ),
         g=dict(
             cls=widgets.IntSlider,
             value=5,
         ),
         h=dict(
             cls=widgets.Dropdown,
             options={'a': 1, 'b': 2},
             value=2
         ),
         j=dict(
             cls=widgets.Dropdown,
             options=['hi', 'there'],
             value='there'
         ),
     )
 
 def test_default_out_of_bounds():
     @annotate(f=(0, 10.), h={'a': 1}, j=['hi', 'there'])
     def f(f='hi', h=5, j='other'):
         pass
     
     c = interactive(f)
     check_widgets(c,
         f=dict(
             cls=widgets.FloatSlider,
             value=5.,
         ),
         h=dict(
             cls=widgets.Dropdown,
             options={'a': 1},
             value=1,
         ),
         j=dict(
             cls=widgets.Dropdown,
             options=['hi', 'there'],
             value='hi',
         ),
     )
 
 def test_annotations():
     @annotate(n=10, f=widgets.FloatText())
     def f(n, f):
         pass
     
     c = interactive(f)
     check_widgets(c,
         n=dict(
             cls=widgets.IntSlider,
             value=10,
         ),
         f=dict(
             cls=widgets.FloatText,
         ),
     )
 
 def test_priority():
     @annotate(annotate='annotate', kwarg='annotate')
     def f(kwarg='default', annotate='default', default='default'):
         pass
     
     c = interactive(f, kwarg='kwarg')
     check_widgets(c,
         kwarg=dict(
             cls=widgets.Text,
             value='kwarg',
         ),
         annotate=dict(
             cls=widgets.Text,
             value='annotate',
         ),
     )
 
 @nt.with_setup(clear_display)
 def test_decorator_kwarg():
     with patch.object(interaction, 'display', record_display):
         @interact(a=5)
         def foo(a):
             pass
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.IntSlider,
         value=5,
     )
 
 @nt.with_setup(clear_display)
 def test_interact_instancemethod():
     class Foo(object):
         def show(self, x):
             print(x)
 
     f = Foo()
     
     with patch.object(interaction, 'display', record_display):
         g = interact(f.show, x=(1,10))
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.IntSlider,
         value=5,
     )
 
 @nt.with_setup(clear_display)
 def test_decorator_no_call():
     with patch.object(interaction, 'display', record_display):
         @interact
         def foo(a='default'):
             pass
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.Text,
         value='default',
     )
 
 @nt.with_setup(clear_display)
 def test_call_interact():
     def foo(a='default'):
         pass
     with patch.object(interaction, 'display', record_display):
         ifoo = interact(foo)
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.Text,
         value='default',
     )
 
 @nt.with_setup(clear_display)
 def test_call_interact_kwargs():
     def foo(a='default'):
         pass
     with patch.object(interaction, 'display', record_display):
         ifoo = interact(foo, a=10)
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.IntSlider,
         value=10,
     )
 
 @nt.with_setup(clear_display)
 def test_call_decorated_on_trait_change():
     """test calling @interact decorated functions"""
     d = {}
     with patch.object(interaction, 'display', record_display):
         @interact
         def foo(a='default'):
             d['a'] = a
             return a
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.Text,
         value='default',
     )
     # test calling the function directly
     a = foo('hello')
     nt.assert_equal(a, 'hello')
     nt.assert_equal(d['a'], 'hello')
     
     # test that setting trait values calls the function
     w.value = 'called'
     nt.assert_equal(d['a'], 'called')
 
 @nt.with_setup(clear_display)
 def test_call_decorated_kwargs_on_trait_change():
     """test calling @interact(foo=bar) decorated functions"""
     d = {}
     with patch.object(interaction, 'display', record_display):
         @interact(a='kwarg')
         def foo(a='default'):
             d['a'] = a
             return a
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.Text,
         value='kwarg',
     )
     # test calling the function directly
     a = foo('hello')
     nt.assert_equal(a, 'hello')
     nt.assert_equal(d['a'], 'hello')
     
     # test that setting trait values calls the function
     w.value = 'called'
     nt.assert_equal(d['a'], 'called')
 
 def test_fixed():
     c = interactive(f, a=widgets.fixed(5), b='text')
     nt.assert_equal(len(c.children), 1)
     w = c.children[0]
     check_widget(w,
         cls=widgets.Text,
         value='text',
         description='b',
     )
 
 def test_default_description():
     c = interactive(f, b='text')
     w = c.children[0]
     check_widget(w,
         cls=widgets.Text,
         value='text',
         description='b',
     )
 
 def test_custom_description():
     d = {}
     def record_kwargs(**kwargs):
         d.clear()
         d.update(kwargs)
     
     c = interactive(record_kwargs, b=widgets.Text(value='text', description='foo'))
     w = c.children[0]
     check_widget(w,
         cls=widgets.Text,
         value='text',
         description='foo',
     )
     w.value = 'different text'
     nt.assert_equal(d, {'b': 'different text'})
 
 def test_interact_manual_button():
     c = interactive(f, __manual=True)
     w = c.children[0]
     check_widget(w, cls=widgets.Button)
 
 def test_interact_manual_nocall():
     callcount = 0
     def calltest(testarg):
         callcount += 1
     c = interactive(calltest, testarg=5, __manual=True)
     c.children[0].value = 10
     nt.assert_equal(callcount, 0)
 
 def test_int_range_logic():
     irsw = widgets.IntRangeSlider
     w = irsw(value=(2, 4), min=0, max=6)
     check_widget(w, cls=irsw, value=(2, 4), min=0, max=6)
     w.value = (4, 2)
     check_widget(w, cls=irsw, value=(2, 4), min=0, max=6)
     w.value = (-1, 7)
     check_widget(w, cls=irsw, value=(0, 6), min=0, max=6)
     w.min = 3
     check_widget(w, cls=irsw, value=(3, 6), min=3, max=6)
     w.max = 3
     check_widget(w, cls=irsw, value=(3, 3), min=3, max=3)
     
     w.min = 0
     w.max = 6
     w.lower = 2
     w.upper = 4
     check_widget(w, cls=irsw, value=(2, 4), min=0, max=6)
     w.value = (0, 1) #lower non-overlapping range
     check_widget(w, cls=irsw, value=(0, 1), min=0, max=6)
     w.value = (5, 6) #upper non-overlapping range
     check_widget(w, cls=irsw, value=(5, 6), min=0, max=6)
     w.value = (-1, 4) #semi out-of-range
     check_widget(w, cls=irsw, value=(0, 4), min=0, max=6)
     w.lower = 2
     check_widget(w, cls=irsw, value=(2, 4), min=0, max=6)
     w.value = (-2, -1) #wholly out of range
     check_widget(w, cls=irsw, value=(0, 0), min=0, max=6)
     w.value = (7, 8)
     check_widget(w, cls=irsw, value=(6, 6), min=0, max=6)
     
     with nt.assert_raises(ValueError):
         w.min = 7
     with nt.assert_raises(ValueError):
         w.max = -1
     with nt.assert_raises(ValueError):
         w.lower = 5
     with nt.assert_raises(ValueError):
         w.upper = 1
     
     w = irsw(min=2, max=3)
     check_widget(w, min=2, max=3)
     w = irsw(min=100, max=200)
     check_widget(w, lower=125, upper=175, value=(125, 175))
     
     with nt.assert_raises(ValueError):
         irsw(value=(2, 4), lower=3)
     with nt.assert_raises(ValueError):
         irsw(value=(2, 4), upper=3)
     with nt.assert_raises(ValueError):
         irsw(value=(2, 4), lower=3, upper=3)
     with nt.assert_raises(ValueError):
         irsw(min=2, max=1)
     with nt.assert_raises(ValueError):
         irsw(lower=5)
     with nt.assert_raises(ValueError):
         irsw(upper=5)
     
 
 def test_float_range_logic():
     frsw = widgets.FloatRangeSlider
     w = frsw(value=(.2, .4), min=0., max=.6)
     check_widget(w, cls=frsw, value=(.2, .4), min=0., max=.6)
     w.value = (.4, .2)
     check_widget(w, cls=frsw, value=(.2, .4), min=0., max=.6)
     w.value = (-.1, .7)
     check_widget(w, cls=frsw, value=(0., .6), min=0., max=.6)
     w.min = .3
     check_widget(w, cls=frsw, value=(.3, .6), min=.3, max=.6)
     w.max = .3
     check_widget(w, cls=frsw, value=(.3, .3), min=.3, max=.3)
     
     w.min = 0.
     w.max = .6
     w.lower = .2
     w.upper = .4
     check_widget(w, cls=frsw, value=(.2, .4), min=0., max=.6)
     w.value = (0., .1) #lower non-overlapping range
     check_widget(w, cls=frsw, value=(0., .1), min=0., max=.6)
     w.value = (.5, .6) #upper non-overlapping range
     check_widget(w, cls=frsw, value=(.5, .6), min=0., max=.6)
     w.value = (-.1, .4) #semi out-of-range
     check_widget(w, cls=frsw, value=(0., .4), min=0., max=.6)
     w.lower = .2
     check_widget(w, cls=frsw, value=(.2, .4), min=0., max=.6)
     w.value = (-.2, -.1) #wholly out of range
     check_widget(w, cls=frsw, value=(0., 0.), min=0., max=.6)
     w.value = (.7, .8)
     check_widget(w, cls=frsw, value=(.6, .6), min=.0, max=.6)
     
     with nt.assert_raises(ValueError):
         w.min = .7
     with nt.assert_raises(ValueError):
         w.max = -.1
     with nt.assert_raises(ValueError):
         w.lower = .5
     with nt.assert_raises(ValueError):
         w.upper = .1
     
     w = frsw(min=2, max=3)
     check_widget(w, min=2, max=3)
     w = frsw(min=1., max=2.)
     check_widget(w, lower=1.25, upper=1.75, value=(1.25, 1.75))
     
     with nt.assert_raises(ValueError):
         frsw(value=(2, 4), lower=3)
     with nt.assert_raises(ValueError):
         frsw(value=(2, 4), upper=3)
     with nt.assert_raises(ValueError):
         frsw(value=(2, 4), lower=3, upper=3)
     with nt.assert_raises(ValueError):
         frsw(min=.2, max=.1)
     with nt.assert_raises(ValueError):
         frsw(lower=5)
     with nt.assert_raises(ValueError):
         frsw(upper=5)
 
 
 def test_multiple_selection():
     smw = widgets.SelectMultiple
 
     # degenerate multiple select
     w = smw()
     check_widget(w, value=tuple(), options=None, selected_labels=tuple())
 
     # don't accept random other value when no options
     with nt.assert_raises(KeyError):
         w.value = (2,)
     check_widget(w, value=tuple(), selected_labels=tuple())
 
     # basic multiple select
     w = smw(options=[(1, 1)], value=[1])
     check_widget(w, cls=smw, value=(1,), options=[(1, 1)])
 
     # don't accept random other value
     with nt.assert_raises(KeyError):
         w.value = w.value + (2,)
     check_widget(w, value=(1,), selected_labels=(1,))
 
     # change options
     w.options = w.options + [(2, 2)]
     check_widget(w, options=[(1, 1), (2,2)])
 
     # change value
     w.value = w.value + (2,)
     check_widget(w, value=(1, 2), selected_labels=(1, 2))
 
     # change value name
     w.selected_labels = (1,)
     check_widget(w, value=(1,))
 
     # don't accept random other names when no options
     with nt.assert_raises(KeyError):
         w.selected_labels = (3,)
     check_widget(w, value=(1,))
 
     # don't accept selected_label (from superclass)
     with nt.assert_raises(AttributeError):
         w.selected_label = 3
 
     # don't return selected_label (from superclass)
     with nt.assert_raises(AttributeError):
         print(w.selected_label)
 
     # dict style
     w.options = {1: 1}
     check_widget(w, options={1: 1})
 
     # updating
     with nt.assert_raises(KeyError):
         w.value = (2,)
     check_widget(w, options={1: 1})

jupyter_notebook/widgets/tests/test_traits.py

@@ -1,83 +1,83
 """Test trait types of the widget packages."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from unittest import TestCase
 from IPython.utils.traitlets import HasTraits
 from traitlets.tests.test_traitlets import TraitTestBase
-from IPython.html.widgets import Color, EventfulDict, EventfulList
+from jupyter_notebook.widgets import Color, EventfulDict, EventfulList
 
 
 class ColorTrait(HasTraits):
     value = Color("black")
 
 
 class TestColor(TraitTestBase):
     obj = ColorTrait()
 
     _good_values = ["blue", "#AA0", "#FFFFFF"]
     _bad_values = ["vanilla", "blues"]
 
 
 class TestEventful(TestCase):
 
     def test_list(self):
         """Does the EventfulList work?"""
         event_cache = []
 
         class A(HasTraits):
             x = EventfulList([c for c in 'abc'])
         a = A()
         a.x.on_events(lambda i, x: event_cache.append('insert'), \
             lambda i, x: event_cache.append('set'), \
             lambda i: event_cache.append('del'), \
             lambda: event_cache.append('reverse'), \
             lambda *p, **k: event_cache.append('sort'))
 
         a.x.remove('c')
         # ab
         a.x.insert(0, 'z')
         # zab
         del a.x[1]
         # zb
         a.x.reverse()
         # bz 
         a.x[1] = 'o'
         # bo
         a.x.append('a')
         # boa
         a.x.sort()
         # abo
 
         # Were the correct events captured?
         self.assertEqual(event_cache, ['del', 'insert', 'del', 'reverse', 'set', 'set', 'sort'])
 
         # Is the output correct?
         self.assertEqual(a.x, [c for c in 'abo'])
 
     def test_dict(self):
         """Does the EventfulDict work?"""
         event_cache = []
 
         class A(HasTraits):
             x = EventfulDict({c: c for c in 'abc'})
         a = A()
         a.x.on_events(lambda k, v: event_cache.append('add'), \
             lambda k, v: event_cache.append('set'), \
             lambda k: event_cache.append('del'))
 
         del a.x['c']
         # ab
         a.x['z'] = 1
         # abz
         a.x['z'] = 'z'
         # abz
         a.x.pop('a')
         # bz 
 
         # Were the correct events captured?
         self.assertEqual(event_cache, ['del', 'add', 'set', 'del'])
 
         # Is the output correct?
         self.assertEqual(a.x, {c: c for c in 'bz'})

jupyter_notebook/widgets/widget_output.py

@@ -1,76 +1,76
 """Output class.  
 
 Represents a widget that can be used to display output within the widget area.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from .widget import DOMWidget
 import sys
 from IPython.utils.traitlets import Unicode, List
 from IPython.display import clear_output
 from IPython.kernel.zmq.session import Message
 
 class Output(DOMWidget):
     """Widget used as a context manager to display output.
 
     This widget can capture and display stdout, stderr, and rich output.  To use
     it, create an instance of it and display it.  Then use it as a context
     manager.  Any output produced while in it's context will be captured and
     displayed in it instead of the standard output area.
 
     Example
-        from IPython.html import widgets
+        from jupyter_notebook import widgets
         from IPython.display import display
         out = widgets.Output()
         display(out)
         
         print('prints to output area')
 
         with out:
             print('prints to output widget')"""
     _view_name = Unicode('OutputView', sync=True)
 
     def clear_output(self, *pargs, **kwargs):
         with self:
             clear_output(*pargs, **kwargs)
 
     def __enter__(self):
         """Called upon entering output widget context manager."""
         self._flush()
         kernel = get_ipython().kernel
         session = kernel.session
         send = session.send
         self._original_send = send
         self._session = session
 
         def send_hook(stream, msg_or_type, content=None, parent=None, ident=None,
              buffers=None, track=False, header=None, metadata=None): 
 
             # Handle both prebuild messages and unbuilt messages.
             if isinstance(msg_or_type, (Message, dict)):
                 msg_type = msg_or_type['msg_type']
                 msg = dict(msg_or_type)
             else:
                 msg_type = msg_or_type
                 msg = session.msg(msg_type, content=content, parent=parent, 
                     header=header, metadata=metadata)
 
             # If this is a message type that we want to forward, forward it.
             if stream is kernel.iopub_socket and msg_type in ['clear_output', 'stream', 'display_data']:
                 self.send(msg)
             else: 
                 send(stream, msg, ident=ident, buffers=buffers, track=track)
 
         session.send = send_hook
 
     def __exit__(self, exception_type, exception_value, traceback):
         """Called upon exiting output widget context manager."""
         self._flush()
         self._session.send = self._original_send
 
     def _flush(self):
         """Flush stdout and stderr buffers."""
         sys.stdout.flush()
         sys.stderr.flush()