MAINT: Return dicts from CheckpointManager.get_checkpoint.

The output is going to get converted to a dict anyway, and this makes it
easier to pipe output from a CheckpointManager directly to a
ContentsManager.

IPython/html/services/contents/filemanager.py

@@ -1,761 +1,772 b''
 """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 base64
 from contextlib import contextmanager
 import errno
 import io
 import os
 import shutil
 import mimetypes
 
 from tornado import web
 
 from .manager import (
     CheckpointManager,
     ContentsManager,
 )
 from IPython import nbformat
 from IPython.utils.io import atomic_writing
 from IPython.utils.importstring import import_item
 from IPython.utils.path import ensure_dir_exists
 from IPython.utils.traitlets import Any, Unicode, Bool, TraitError
 from IPython.utils.py3compat import getcwd, string_types, str_to_unicode
 from IPython.utils import tz
 from IPython.html.utils import (
     is_hidden,
     to_api_path,
     to_os_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 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 FileCheckpointManager.
 
     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 into 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 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 web.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.
         """
         return to_os_path(path, self.root_dir)
 
     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 web.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 web.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 as e:
                 if format == 'text':
                     raise web.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 web.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 web.HTTPError(400, u'Encoding error saving %s: %s' % (os_path, e))
 
         with self.atomic_writing(os_path, text=False) as f:
             f.write(bcontent)
 
 
 class FileCheckpointManager(FileManagerMixin, CheckpointManager):
     """
     A CheckpointManager that caches checkpoints for files in adjacent
     directories.
     """
 
     checkpoint_dir = Unicode(
         '.ipynb_checkpoints',
         config=True,
         help="""The directory name in which to keep file checkpoints
 
         This is a path relative to the file's own directory.
 
         By default, it is .ipynb_checkpoints
         """,
     )
 
     root_dir = Unicode(config=True)
 
     def _root_dir_default(self):
         try:
             return self.parent.root_dir
         except AttributeError:
             return getcwd()
 
     # public checkpoint API
     def create_file_checkpoint(self, content, format, path):
         """Create a checkpoint from the current content of a notebook."""
         path = path.strip('/')
         # only the one checkpoint ID:
         checkpoint_id = u"checkpoint"
         os_checkpoint_path = self.checkpoint_path(checkpoint_id, path)
         self.log.debug("creating checkpoint for %s", path)
         with self.perm_to_403():
             self._save_file(os_checkpoint_path, content, format=format)
 
         # return the checkpoint info
         return self.checkpoint_model(checkpoint_id, os_checkpoint_path)
 
     def create_notebook_checkpoint(self, nb, path):
         """Create a checkpoint from the current content of a notebook."""
         path = path.strip('/')
         # only the one checkpoint ID:
         checkpoint_id = u"checkpoint"
         os_checkpoint_path = self.checkpoint_path(checkpoint_id, path)
         self.log.debug("creating checkpoint for %s", path)
         with self.perm_to_403():
             self._save_notebook(os_checkpoint_path, nb)
 
         # return the checkpoint info
         return self.checkpoint_model(checkpoint_id, os_checkpoint_path)
 
     def get_checkpoint(self, checkpoint_id, path, type):
         """Get the content of a checkpoint.
 
-        Returns a pair of (content, type).
+        Returns a model suitable for passing to ContentsManager.save.
         """
         path = path.strip('/')
         self.log.info("restoring %s from checkpoint %s", path, checkpoint_id)
         os_checkpoint_path = self.checkpoint_path(checkpoint_id, path)
         if not os.path.isfile(os_checkpoint_path):
             self.no_such_checkpoint(path, checkpoint_id)
         if type == 'notebook':
-            return self._read_notebook(os_checkpoint_path, as_version=4), None
+            return {
+                'type': type,
+                'content': self._read_notebook(
+                    os_checkpoint_path,
+                    as_version=4,
+                ),
+            }
         else:
-            return self._read_file(os_checkpoint_path, format=None)
+            content, format = self._read_file(os_checkpoint_path, format=None)
+            return {
+                'type': type,
+                'content': content,
+                'format': format,
+            }
 
     def rename_checkpoint(self, checkpoint_id, old_path, new_path):
         """Rename a checkpoint from old_path to new_path."""
         old_cp_path = self.checkpoint_path(checkpoint_id, old_path)
         new_cp_path = self.checkpoint_path(checkpoint_id, new_path)
         if os.path.isfile(old_cp_path):
             self.log.debug(
                 "Renaming checkpoint %s -> %s",
                 old_cp_path,
                 new_cp_path,
             )
             with self.perm_to_403():
                 shutil.move(old_cp_path, new_cp_path)
 
     def delete_checkpoint(self, checkpoint_id, path):
         """delete a file's checkpoint"""
         path = path.strip('/')
         cp_path = self.checkpoint_path(checkpoint_id, path)
         if not os.path.isfile(cp_path):
             self.no_such_checkpoint(path, checkpoint_id)
 
         self.log.debug("unlinking %s", cp_path)
         with self.perm_to_403():
             os.unlink(cp_path)
 
     def list_checkpoints(self, path):
         """list the checkpoints for a given file
 
         This contents manager currently only supports one checkpoint per file.
         """
         path = path.strip('/')
         checkpoint_id = "checkpoint"
         os_path = self.checkpoint_path(checkpoint_id, path)
         if not os.path.isfile(os_path):
             return []
         else:
             return [self.checkpoint_model(checkpoint_id, os_path)]
 
     # Checkpoint-related utilities
     def checkpoint_path(self, checkpoint_id, path):
         """find the path to a checkpoint"""
         path = path.strip('/')
         parent, name = ('/' + path).rsplit('/', 1)
         parent = parent.strip('/')
         basename, ext = os.path.splitext(name)
         filename = u"{name}-{checkpoint_id}{ext}".format(
             name=basename,
             checkpoint_id=checkpoint_id,
             ext=ext,
         )
         os_path = self._get_os_path(path=parent)
         cp_dir = os.path.join(os_path, self.checkpoint_dir)
         with self.perm_to_403():
             ensure_dir_exists(cp_dir)
         cp_path = os.path.join(cp_dir, filename)
         return cp_path
 
     def checkpoint_model(self, checkpoint_id, os_path):
         """construct the info dict for a given checkpoint"""
         stats = os.stat(os_path)
         last_modified = tz.utcfromtimestamp(stats.st_mtime)
         info = dict(
             id=checkpoint_id,
             last_modified=last_modified,
         )
         return info
 
     # Error Handling
     def no_such_checkpoint(self, path, checkpoint_id):
         raise web.HTTPError(
             404,
             u'Checkpoint does not exist: %s@%s' % (path, checkpoint_id)
         )
 
 
 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 _checkpoint_manager_class_default(self):
         return FileCheckpointManager
 
     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', 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')
 
         self.run_pre_save_hook(model=model, path=path)
 
         os_path = self._get_os_path(path)
         self.log.debug("Saving %s", os_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.checkpoint_manager.list_checkpoints(path):
                     self.checkpoint_manager.create_notebook_checkpoint(
                         nb,
                         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.checkpoint_manager, '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

IPython/html/services/contents/manager.py

@@ -1,541 +1,536 b''
 """A base class for contents managers."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from fnmatch import fnmatch
 import itertools
 import json
 import os
 import re
 
 from tornado.web import HTTPError
 
 from IPython import nbformat
 from IPython.config.configurable import LoggingConfigurable
 from IPython.nbformat import sign, validate, ValidationError
 from IPython.nbformat.v4 import new_notebook
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import (
     Any,
     Dict,
     Instance,
     List,
     TraitError,
     Type,
     Unicode,
 )
 from IPython.utils.py3compat import string_types
 
 copy_pat = re.compile(r'\-Copy\d*\.')
 
 
 class CheckpointManager(LoggingConfigurable):
     """
     Base class for managing checkpoints for a ContentsManager.
     """
     def create_file_checkpoint(self, content, format, path):
         """Create a checkpoint of the current state of a file
 
         Returns a checkpoint model for the new checkpoint.
         """
         raise NotImplementedError("must be implemented in a subclass")
 
     def create_notebook_checkpoint(self, nb, path):
         """Create a checkpoint of the current state of a file
 
         Returns a checkpoint model for the new checkpoint.
         """
         raise NotImplementedError("must be implemented in a subclass")
 
     def get_checkpoint(self, checkpoint_id, path, type):
         """Get the content of a checkpoint.
 
         Returns an unvalidated model with the same structure as
         the return value of ContentsManager.get
         """
         raise NotImplementedError("must be implemented in a subclass")
 
     def rename_checkpoint(self, checkpoint_id, old_path, new_path):
         """Rename a single checkpoint from old_path to new_path."""
         raise NotImplementedError("must be implemented in a subclass")
 
     def delete_checkpoint(self, checkpoint_id, path):
         """delete a checkpoint for a file"""
         raise NotImplementedError("must be implemented in a subclass")
 
     def list_checkpoints(self, path):
         """Return a list of checkpoints for a given file"""
         raise NotImplementedError("must be implemented in a subclass")
 
     def rename_all_checkpoints(self, old_path, new_path):
         """Rename all checkpoints for old_path to new_path."""
         for cp in self.list_checkpoints(old_path):
             self.rename_checkpoint(cp['id'], old_path, new_path)
 
     def delete_all_checkpoints(self, path):
         """Delete all checkpoints for the given path."""
         for checkpoint in self.list_checkpoints(path):
             self.delete_checkpoint(checkpoint['id'], path)
 
 
 class ContentsManager(LoggingConfigurable):
     """Base class for serving files and directories.
 
     This serves any text or binary file,
     as well as directories,
     with special handling for JSON notebook documents.
 
     Most APIs take a path argument,
     which is always an API-style unicode path,
     and always refers to a directory.
 
     - unicode, not url-escaped
     - '/'-separated
     - leading and trailing '/' will be stripped
     - if unspecified, path defaults to '',
       indicating the root path.
 
     """
 
     notary = Instance(sign.NotebookNotary)
     def _notary_default(self):
         return sign.NotebookNotary(parent=self)
 
     hide_globs = List(Unicode, [
             u'__pycache__', '*.pyc', '*.pyo',
             '.DS_Store', '*.so', '*.dylib', '*~',
         ], config=True, help="""
         Glob patterns to hide in file and directory listings.
     """)
 
     untitled_notebook = Unicode("Untitled", config=True,
         help="The base name used when creating untitled notebooks."
     )
 
     untitled_file = Unicode("untitled", config=True,
         help="The base name used when creating untitled files."
     )
 
     untitled_directory = Unicode("Untitled Folder", config=True,
         help="The base name used when creating untitled directories."
     )
 
     pre_save_hook = Any(None, config=True,
         help="""Python callable or importstring thereof
 
         To be called on a contents model prior to save.
 
         This can be used to process the structure,
         such as removing notebook outputs or other side effects that
         should not be saved.
 
         It will be called as (all arguments passed by keyword):
 
             hook(path=path, model=model, contents_manager=self)
 
         model: the model to be saved. Includes file contents.
                modifying this dict will affect the file that is stored.
         path: the API path of the save destination
         contents_manager: this ContentsManager instance
         """
     )
     def _pre_save_hook_changed(self, name, old, new):
         if new and isinstance(new, string_types):
             self.pre_save_hook = import_item(self.pre_save_hook)
         elif new:
             if not callable(new):
                 raise TraitError("pre_save_hook must be callable")
 
     def run_pre_save_hook(self, model, path, **kwargs):
         """Run the pre-save hook if defined, and log errors"""
         if self.pre_save_hook:
             try:
                 self.log.debug("Running pre-save hook on %s", path)
                 self.pre_save_hook(model=model, path=path, contents_manager=self, **kwargs)
             except Exception:
                 self.log.error("Pre-save hook failed on %s", path, exc_info=True)
 
     checkpoint_manager_class = Type(CheckpointManager, config=True)
     checkpoint_manager = Instance(CheckpointManager, config=True)
     checkpoint_manager_kwargs = Dict(allow_none=False, config=True)
 
     def _checkpoint_manager_default(self):
         return self.checkpoint_manager_class(**self.checkpoint_manager_kwargs)
 
     def _checkpoint_manager_kwargs_default(self):
         return dict(
             parent=self,
             log=self.log,
         )
 
     # ContentsManager API part 1: methods that must be
     # implemented in subclasses.
 
     def dir_exists(self, path):
         """Does the API-style path (directory) actually exist?
 
         Like os.path.isdir
 
         Override this method in subclasses.
 
         Parameters
         ----------
         path : string
             The path to check
 
         Returns
         -------
         exists : bool
             Whether the path does indeed exist.
         """
         raise NotImplementedError
 
     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 is hidden.
 
         """
         raise NotImplementedError
 
     def file_exists(self, path=''):
         """Does a file exist at the given path?
 
         Like os.path.isfile
 
         Override this method in subclasses.
 
         Parameters
         ----------
         name : string
             The name of the file you are checking.
         path : string
             The relative path to the file's directory (with '/' as separator)
 
         Returns
         -------
         exists : bool
             Whether the file exists.
         """
         raise NotImplementedError('must be implemented in a subclass')
 
     def exists(self, path):
         """Does a file or directory exist at the given path?
 
         Like os.path.exists
 
         Parameters
         ----------
         path : string
             The relative path to the file's directory (with '/' as separator)
 
         Returns
         -------
         exists : bool
             Whether the target exists.
         """
         return self.file_exists(path) or self.dir_exists(path)
 
     def get(self, path, content=True, type=None, format=None):
         """Get the model of a file or directory with or without content."""
         raise NotImplementedError('must be implemented in a subclass')
 
     def save(self, model, path):
         """Save the file or directory and return the model with no content.
 
         Save implementations should call self.run_pre_save_hook(model=model, path=path)
         prior to writing any data.
         """
         raise NotImplementedError('must be implemented in a subclass')
 
     def delete_file(self, path):
         """Delete file or directory by path."""
         raise NotImplementedError('must be implemented in a subclass')
 
     def rename_file(self, old_path, new_path):
         """Rename a file."""
         raise NotImplementedError('must be implemented in a subclass')
 
     # ContentsManager API part 2: methods that have useable default
     # implementations, but can be overridden in subclasses.
 
     def delete(self, path):
         """Delete a file/directory and any associated checkpoints."""
         self.delete_file(path)
         self.checkpoint_manager.delete_all_checkpoints(path)
 
     def rename(self, old_path, new_path):
         """Rename a file and any checkpoints associated with that file."""
         self.rename_file(old_path, new_path)
         self.checkpoint_manager.rename_all_checkpoints(old_path, new_path)
 
     def update(self, model, path):
         """Update the file's path
 
         For use in PATCH requests, to enable renaming a file without
         re-uploading its contents. Only used for renaming at the moment.
         """
         path = path.strip('/')
         new_path = model.get('path', path).strip('/')
         if path != new_path:
             self.rename(path, new_path)
         model = self.get(new_path, content=False)
         return model
 
     def info_string(self):
         return "Serving contents"
 
     def get_kernel_path(self, path, model=None):
         """Return the API path for the kernel
         
         KernelManagers can turn this value into a filesystem path,
         or ignore it altogether.
 
         The default value here will start kernels in the directory of the
         notebook server. FileContentsManager overrides this to use the
         directory containing the notebook.
         """
         return ''
 
     def increment_filename(self, filename, path='', insert=''):
         """Increment a filename until it is unique.
 
         Parameters
         ----------
         filename : unicode
             The name of a file, including extension
         path : unicode
             The API path of the target's directory
 
         Returns
         -------
         name : unicode
             A filename that is unique, based on the input filename.
         """
         path = path.strip('/')
         basename, ext = os.path.splitext(filename)
         for i in itertools.count():
             if i:
                 insert_i = '{}{}'.format(insert, i)
             else:
                 insert_i = ''
             name = u'{basename}{insert}{ext}'.format(basename=basename,
                 insert=insert_i, ext=ext)
             if not self.exists(u'{}/{}'.format(path, name)):
                 break
         return name
 
     def validate_notebook_model(self, model):
         """Add failed-validation message to model"""
         try:
             validate(model['content'])
         except ValidationError as e:
             model['message'] = u'Notebook Validation failed: {}:\n{}'.format(
                 e.message, json.dumps(e.instance, indent=1, default=lambda obj: '<UNKNOWN>'),
             )
         return model
     
     def new_untitled(self, path='', type='', ext=''):
         """Create a new untitled file or directory in path
         
         path must be a directory
         
         File extension can be specified.
         
         Use `new` to create files with a fully specified path (including filename).
         """
         path = path.strip('/')
         if not self.dir_exists(path):
             raise HTTPError(404, 'No such directory: %s' % path)
         
         model = {}
         if type:
             model['type'] = type
         
         if ext == '.ipynb':
             model.setdefault('type', 'notebook')
         else:
             model.setdefault('type', 'file')
         
         insert = ''
         if model['type'] == 'directory':
             untitled = self.untitled_directory
             insert = ' '
         elif model['type'] == 'notebook':
             untitled = self.untitled_notebook
             ext = '.ipynb'
         elif model['type'] == 'file':
             untitled = self.untitled_file
         else:
             raise HTTPError(400, "Unexpected model type: %r" % model['type'])
         
         name = self.increment_filename(untitled + ext, path, insert=insert)
         path = u'{0}/{1}'.format(path, name)
         return self.new(model, path)
     
     def new(self, model=None, path=''):
         """Create a new file or directory and return its model with no content.
         
         To create a new untitled entity in a directory, use `new_untitled`.
         """
         path = path.strip('/')
         if model is None:
             model = {}
         
         if path.endswith('.ipynb'):
             model.setdefault('type', 'notebook')
         else:
             model.setdefault('type', 'file')
         
         # no content, not a directory, so fill out new-file model
         if 'content' not in model and model['type'] != 'directory':
             if model['type'] == 'notebook':
                 model['content'] = new_notebook()
                 model['format'] = 'json'
             else:
                 model['content'] = ''
                 model['type'] = 'file'
                 model['format'] = 'text'
         
         model = self.save(model, path)
         return model
 
     def copy(self, from_path, to_path=None):
         """Copy an existing file and return its new model.
 
         If to_path not specified, it will be the parent directory of from_path.
         If to_path is a directory, filename will increment `from_path-Copy#.ext`.
 
         from_path must be a full path to a file.
         """
         path = from_path.strip('/')
         if to_path is not None:
             to_path = to_path.strip('/')
 
         if '/' in path:
             from_dir, from_name = path.rsplit('/', 1)
         else:
             from_dir = ''
             from_name = path
         
         model = self.get(path)
         model.pop('path', None)
         model.pop('name', None)
         if model['type'] == 'directory':
             raise HTTPError(400, "Can't copy directories")
         
         if to_path is None:
             to_path = from_dir
         if self.dir_exists(to_path):
             name = copy_pat.sub(u'.', from_name)
             to_name = self.increment_filename(name, to_path, insert='-Copy')
             to_path = u'{0}/{1}'.format(to_path, to_name)
         
         model = self.save(model, to_path)
         return model
 
     def log_info(self):
         self.log.info(self.info_string())
 
     def trust_notebook(self, path):
         """Explicitly trust a notebook
 
         Parameters
         ----------
         path : string
             The path of a notebook
         """
         model = self.get(path)
         nb = model['content']
         self.log.warn("Trusting notebook %s", path)
         self.notary.mark_cells(nb, True)
         self.save(model, path)
 
     def check_and_sign(self, nb, path=''):
         """Check for trusted cells, and sign the notebook.
 
         Called as a part of saving notebooks.
 
         Parameters
         ----------
         nb : dict
             The notebook dict
         path : string
             The notebook's path (for logging)
         """
         if self.notary.check_cells(nb):
             self.notary.sign(nb)
         else:
             self.log.warn("Saving untrusted notebook %s", path)
 
     def mark_trusted_cells(self, nb, path=''):
         """Mark cells as trusted if the notebook signature matches.
 
         Called as a part of loading notebooks.
 
         Parameters
         ----------
         nb : dict
             The notebook object (in current nbformat)
         path : string
             The notebook's path (for logging)
         """
         trusted = self.notary.check_signature(nb)
         if not trusted:
             self.log.warn("Notebook %s is not trusted", path)
         self.notary.mark_cells(nb, trusted)
 
     def should_list(self, name):
         """Should this file/directory name be displayed in a listing?"""
         return not any(fnmatch(name, glob) for glob in self.hide_globs)
 
     # Part 3: Checkpoints API
     def create_checkpoint(self, path):
         """Create a checkpoint."""
         model = self.get(path, content=True)
         type = model['type']
         if type == 'notebook':
             return self.checkpoint_manager.create_notebook_checkpoint(
                 model['content'],
                 path,
             )
         elif type == 'file':
             return self.checkpoint_manager.create_file_checkpoint(
                 model['content'],
                 model['format'],
                 path,
             )
 
     def list_checkpoints(self, path):
         return self.checkpoint_manager.list_checkpoints(path)
 
     def restore_checkpoint(self, checkpoint_id, path):
         """
         Restore a checkpoint.
         """
-        type = self.get(path, content=False)['type']
-        content, format = self.checkpoint_manager.get_checkpoint(
-            checkpoint_id,
-            path,
-            type,
+        return self.save(
+            model=self.checkpoint_manager.get_checkpoint(
+                checkpoint_id,
+                path,
+                self.get(path, content=False)['type']
+            ),
+            path=path,
         )
 
-        model = {
-            'type': type,
-            'content': content,
-            'format': format,
-        }
-        return self.save(model, path)
-
     def delete_checkpoint(self, checkpoint_id, path):
         return self.checkpoint_manager.delete_checkpoint(checkpoint_id, path)