Make the directory name be the default relpath

IPython/nbconvert/exporters/exporter.py

@@ -1,279 +1,280 b''
 """This module defines a base Exporter class. For Jinja template-based export,
 see templateexporter.py.
 """
 
 
 from __future__ import print_function, absolute_import
 
 import io
 import os
 import copy
 import collections
 import datetime
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.config import Config
 from IPython import nbformat
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List, TraitError
 from IPython.utils.importstring import import_item
 from IPython.utils import text, py3compat
 
 
 class ResourcesDict(collections.defaultdict):
     def __missing__(self, key):
         return ''
 
 
 class FilenameExtension(Unicode):
     """A trait for filename extensions."""
 
     default_value = u''
     info_text = 'a filename extension, beginning with a dot'
 
     def validate(self, obj, value):
         # cast to proper unicode
         value = super(FilenameExtension, self).validate(obj, value)
 
         # check that it starts with a dot
         if value and not value.startswith('.'):
             msg = "FileExtension trait '{}' does not begin with a dot: {!r}"
             raise TraitError(msg.format(self.name, value))
 
         return value
 
 
 class Exporter(LoggingConfigurable):
     """
     Class containing methods that sequentially run a list of preprocessors on a 
     NotebookNode object and then return the modified NotebookNode object and 
     accompanying resources dict.
     """
 
     file_extension = FilenameExtension(
         '.txt', config=True,
         help="Extension of the file that should be written to disk"
         )
 
     # MIME type of the result file, for HTTP response headers.
     # This is *not* a traitlet, because we want to be able to access it from
     # the class, not just on instances.
     output_mimetype = ''
 
     #Configurability, allows the user to easily add filters and preprocessors.
     preprocessors = List(config=True,
         help="""List of preprocessors, by name or namespace, to enable.""")
 
     _preprocessors = List()
 
     default_preprocessors = List(['IPython.nbconvert.preprocessors.coalesce_streams',
                                   'IPython.nbconvert.preprocessors.SVG2PDFPreprocessor',
                                   'IPython.nbconvert.preprocessors.ExtractOutputPreprocessor',
                                   'IPython.nbconvert.preprocessors.CSSHTMLHeaderPreprocessor',
                                   'IPython.nbconvert.preprocessors.RevealHelpPreprocessor',
                                   'IPython.nbconvert.preprocessors.LatexPreprocessor',
                                   'IPython.nbconvert.preprocessors.ClearOutputPreprocessor',
                                   'IPython.nbconvert.preprocessors.ExecutePreprocessor',
                                   'IPython.nbconvert.preprocessors.HighlightMagicsPreprocessor'],
         config=True,
         help="""List of preprocessors available by default, by name, namespace, 
         instance, or type.""")
 
 
     def __init__(self, config=None, **kw):
         """
         Public constructor
 
         Parameters
         ----------
         config : config
             User configuration instance.
         """
         with_default_config = self.default_config
         if config:
             with_default_config.merge(config)
         
         super(Exporter, self).__init__(config=with_default_config, **kw)
 
         self._init_preprocessors()
 
 
     @property
     def default_config(self):
         return Config()
 
     def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
 
         Parameters
         ----------
         nb : :class:`~IPython.nbformat.NotebookNode`
           Notebook node (dict-like with attr-access)
         resources : dict
           Additional resources that can be accessed read/write by
           preprocessors and filters.
         **kw
           Ignored (?)
         """
         nb_copy = copy.deepcopy(nb)
         resources = self._init_resources(resources)
         
         if 'language' in nb['metadata']:
             resources['language'] = nb['metadata']['language'].lower()
 
         # Preprocess
         nb_copy, resources = self._preprocess(nb_copy, resources)
 
         return nb_copy, resources
 
 
     def from_filename(self, filename, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
 
         # Pull the metadata from the filesystem.
         if resources is None:
             resources = ResourcesDict()
         if not 'metadata' in resources or resources['metadata'] == '':
             resources['metadata'] = ResourcesDict()
-        basename = os.path.basename(filename)
+        path, basename = os.path.split(filename)
         notebook_name = basename[:basename.rfind('.')]
         resources['metadata']['name'] = notebook_name
+        resources['metadata']['path'] = path
 
         modified_date = datetime.datetime.fromtimestamp(os.path.getmtime(filename))
         resources['metadata']['modified_date'] = modified_date.strftime(text.date_format)
 
         with io.open(filename, encoding='utf-8') as f:
             return self.from_notebook_node(nbformat.read(f, as_version=4), resources=resources, **kw)
 
 
     def from_file(self, file_stream, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         file_stream : file-like object
             Notebook file-like object to convert.
         """
         return self.from_notebook_node(nbformat.read(file_stream, as_version=4), resources=resources, **kw)
 
 
     def register_preprocessor(self, preprocessor, enabled=False):
         """
         Register a preprocessor.
         Preprocessors are classes that act upon the notebook before it is
         passed into the Jinja templating engine.  preprocessors are also
         capable of passing additional information to the Jinja
         templating engine.
 
         Parameters
         ----------
         preprocessor : preprocessor
         """
         if preprocessor is None:
             raise TypeError('preprocessor')
         isclass = isinstance(preprocessor, type)
         constructed = not isclass
 
         # Handle preprocessor's registration based on it's type
         if constructed and isinstance(preprocessor, py3compat.string_types):
             # Preprocessor is a string, import the namespace and recursively call
             # this register_preprocessor method
             preprocessor_cls = import_item(preprocessor)
             return self.register_preprocessor(preprocessor_cls, enabled)
 
         if constructed and hasattr(preprocessor, '__call__'):
             # Preprocessor is a function, no need to construct it.
             # Register and return the preprocessor.
             if enabled:
                 preprocessor.enabled = True
             self._preprocessors.append(preprocessor)
             return preprocessor
 
         elif isclass and isinstance(preprocessor, MetaHasTraits):
             # Preprocessor is configurable.  Make sure to pass in new default for 
             # the enabled flag if one was specified.
             self.register_preprocessor(preprocessor(parent=self), enabled)
 
         elif isclass:
             # Preprocessor is not configurable, construct it
             self.register_preprocessor(preprocessor(), enabled)
 
         else:
             # Preprocessor is an instance of something without a __call__ 
             # attribute.  
             raise TypeError('preprocessor')
 
 
     def _init_preprocessors(self):
         """
         Register all of the preprocessors needed for this exporter, disabled
         unless specified explicitly.
         """
         self._preprocessors = []
 
         # Load default preprocessors (not necessarly enabled by default).
         for preprocessor in self.default_preprocessors:
             self.register_preprocessor(preprocessor)
 
         # Load user-specified preprocessors.  Enable by default.
         for preprocessor in self.preprocessors:
             self.register_preprocessor(preprocessor, enabled=True)
 
 
     def _init_resources(self, resources):
 
         #Make sure the resources dict is of ResourcesDict type.
         if resources is None:
             resources = ResourcesDict()
         if not isinstance(resources, ResourcesDict):
             new_resources = ResourcesDict()
             new_resources.update(resources)
             resources = new_resources
 
         #Make sure the metadata extension exists in resources
         if 'metadata' in resources:
             if not isinstance(resources['metadata'], ResourcesDict):
                 new_metadata = ResourcesDict()
                 new_metadata.update(resources['metadata'])
                 resources['metadata'] = new_metadata
         else:
             resources['metadata'] = ResourcesDict()
             if not resources['metadata']['name']:
                 resources['metadata']['name'] = 'Notebook'
 
         #Set the output extension
         resources['output_extension'] = self.file_extension
         return resources
 
 
     def _preprocess(self, nb, resources):
         """
         Preprocess the notebook before passing it into the Jinja engine.
         To preprocess the notebook is to apply all of the
 
         Parameters
         ----------
         nb : notebook node
             notebook that is being exported.
         resources : a dict of additional resources that
             can be accessed read/write by preprocessors
         """
 
         # Do a copy.deepcopy first,
         # we are never safe enough with what the preprocessors could do.
         nbc =  copy.deepcopy(nb)
         resc = copy.deepcopy(resources)
 
         #Run each preprocessor on the notebook.  Carry the output along
         #to each preprocessor
         for preprocessor in self._preprocessors:
             nbc, resc = preprocessor(nbc, resc)
         return nbc, resc

IPython/nbconvert/writers/files.py

@@ -1,123 +1,131 b''
 """Contains writer for writing nbconvert output to filesystem."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import io
 import os
 import glob
 
 from IPython.utils.traitlets import Unicode
 from IPython.utils.path import link_or_copy, ensure_dir_exists
 from IPython.utils.py3compat import unicode_type
 
 from .base import WriterBase
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class FilesWriter(WriterBase):
     """Consumes nbconvert output and produces files."""
 
 
     build_directory = Unicode("", config=True,
                               help="""Directory to write output to.  Leave blank
                               to output to the current directory""")
 
     relpath = Unicode(
         "", config=True, 
         help="""When copying files that the notebook depends on, copy them in
         relation to this path, such that the destination filename will be
-        os.path.relpath(filename, relpath).""")
+        os.path.relpath(filename, relpath). If FilesWriter is operating on a
+        notebook that already exists elsewhere on disk, then the default will be
+        the directory containing that notebook.""")
 
 
     # Make sure that the output directory exists.
     def _build_directory_changed(self, name, old, new):
         if new:
             ensure_dir_exists(new)
 
 
     def __init__(self, **kw):
         super(FilesWriter, self).__init__(**kw)
         self._build_directory_changed('build_directory', self.build_directory, 
                                       self.build_directory)
     
     def _makedir(self, path):
         """Make a directory if it doesn't already exist"""
         if path:
             self.log.info("Making directory %s", path)
             ensure_dir_exists(path)
 
     def write(self, output, resources, notebook_name=None, **kw):
             """
             Consume and write Jinja output to the file system.  Output directory
             is set via the 'build_directory' variable of this instance (a 
             configurable).
 
             See base for more...
             """
 
             # Verify that a notebook name is provided.
             if notebook_name is None:
                 raise TypeError('notebook_name')
 
             # Pull the extension and subdir from the resources dict.
             output_extension = resources.get('output_extension', None)
 
+            # Get the relative path for copying files
+            if self.relpath == '':
+                relpath = resources.get('metadata', {}).get('path', '')
+            else:
+                relpath = self.relpath
+
             # Write all of the extracted resources to the destination directory.
             # NOTE: WE WRITE EVERYTHING AS-IF IT'S BINARY.  THE EXTRACT FIG
             # PREPROCESSOR SHOULD HANDLE UNIX/WINDOWS LINE ENDINGS...
             for filename, data in resources.get('outputs', {}).items():
 
                 # Determine where to write the file to
                 dest = os.path.join(self.build_directory, filename)
                 path = os.path.dirname(dest)
                 self._makedir(path)
 
                 # Write file
                 self.log.debug("Writing %i bytes to support file %s", len(data), dest)
                 with io.open(dest, 'wb') as f:
                     f.write(data)
 
             # Copy referenced files to output directory
             if self.build_directory:
                 for filename in self.files:
 
                     # Copy files that match search pattern
                     for matching_filename in glob.glob(filename):
 
                         # compute the relative path for the filename
-                        if self.relpath:
-                            dest_filename = os.path.relpath(matching_filename, self.relpath)
+                        if relpath != '':
+                            dest_filename = os.path.relpath(matching_filename, relpath)
                         else:
                             dest_filename = matching_filename
 
                         # Make sure folder exists.
                         dest = os.path.join(self.build_directory, dest_filename)
                         path = os.path.dirname(dest)
                         self._makedir(path)
 
                         # Copy if destination is different.
                         if not os.path.normpath(dest) == os.path.normpath(matching_filename):
                             self.log.info("Linking %s -> %s", matching_filename, dest)
                             link_or_copy(matching_filename, dest)
 
             # Determine where to write conversion results.
             if output_extension is not None:
                 dest = notebook_name + output_extension
             else:
                 dest = notebook_name
             if self.build_directory:
                 dest = os.path.join(self.build_directory, dest)
 
             # Write conversion results.
             self.log.info("Writing %i bytes to %s", len(output), dest)
             if isinstance(output, unicode_type):
                 with io.open(dest, 'w', encoding='utf-8') as f:
                     f.write(output)
             else:
                 with io.open(dest, 'wb') as f:
                     f.write(output)
                 
             return dest

IPython/nbconvert/writers/tests/test_files.py

@@ -1,238 +1,307 b''
 """
 Module with tests for files
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import sys
 import os
 
 from ...tests.base import TestsBase
 from ..files import FilesWriter
 from IPython.utils.py3compat import PY3
 
 if PY3:
     from io import StringIO
 else:
     from StringIO import StringIO
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class Testfiles(TestsBase):
     """Contains test functions for files.py"""
 
     def test_basic_output(self):
         """Is FilesWriter basic output correct?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             with open('z', 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
     def test_ext(self):
         """Does the FilesWriter add the correct extension to the output?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {'output_extension': '.txt'}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isfile('z.txt')
             with open('z.txt', 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
 
     def test_extract(self):
         """Can FilesWriter write extracted figures correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {'outputs': {os.path.join('z_files', 'a'): b'b'}}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             with open('z', 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check the output of the extracted file
             extracted_file_dest = os.path.join('z_files', 'a')
             assert os.path.isfile(extracted_file_dest)
             with open(extracted_file_dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'b')
 
 
     def test_builddir(self):
         """Can FilesWriter write to a build dir correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {'outputs': {os.path.join('z_files', 'a'): b'b'}}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.build_directory = u'build'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check the output of the extracted file
             extracted_file_dest = os.path.join(writer.build_directory, 'z_files', 'a')
             assert os.path.isfile(extracted_file_dest)
             with open(extracted_file_dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'b')
 
 
     def test_links(self):
         """Can the FilesWriter handle linked files correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create test file
             os.mkdir('sub')
             with open(os.path.join('sub', 'c'), 'w') as f:
                 f.write('d')
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.files = [os.path.join('sub', 'c')]
             writer.build_directory = u'build'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check to make sure the linked file was copied
             path = os.path.join(writer.build_directory, 'sub')
             assert os.path.isdir(path)
             dest = os.path.join(path, 'c')
             assert os.path.isfile(dest)
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'd')
 
     def test_glob(self):
         """Can the FilesWriter handle globbed files correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create test files
             os.mkdir('sub')
             with open(os.path.join('sub', 'c'), 'w') as f:
                 f.write('e')
             with open(os.path.join('sub', 'd'), 'w') as f:
                 f.write('e')
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.files = ['sub/*']
             writer.build_directory = u'build'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check to make sure the globbed files were copied
             path = os.path.join(writer.build_directory, 'sub')
             assert os.path.isdir(path)
             for filename in ['c', 'd']:
                 dest = os.path.join(path, filename)
                 assert os.path.isfile(dest)
                 with open(dest, 'r') as f:
                     output = f.read()
                     self.assertEqual(output, 'e')
 
     def test_relpath(self):
         """Can the FilesWriter handle relative paths for linked files correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create test file
             os.mkdir('sub')
             with open(os.path.join('sub', 'c'), 'w') as f:
                 f.write('d')
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.files = [os.path.join('sub', 'c')]
             writer.build_directory = u'build'
             writer.relpath = 'sub'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check to make sure the linked file was copied
             dest = os.path.join(writer.build_directory, 'c')
             assert os.path.isfile(dest)
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'd')
+
+    def test_relpath_default(self):
+        """Is the FilesWriter default relative path correct?"""
+
+        # Work in a temporary directory.
+        with self.create_temp_cwd():
+
+            # Create test file
+            os.mkdir('sub')
+            with open(os.path.join('sub', 'c'), 'w') as f:
+                f.write('d')
+
+            # Create the resoruces dictionary
+            res = dict(metadata=dict(path="sub"))
+
+            # Create files writer, test output
+            writer = FilesWriter()
+            writer.files = [os.path.join('sub', 'c')]
+            writer.build_directory = u'build'
+            writer.write(u'y', res, notebook_name="z")
+
+            # Check the output of the file
+            assert os.path.isdir(writer.build_directory)
+            dest = os.path.join(writer.build_directory, 'z')
+            with open(dest, 'r') as f:
+                output = f.read()
+                self.assertEqual(output, u'y')
+
+            # Check to make sure the linked file was copied
+            dest = os.path.join(writer.build_directory, 'c')
+            assert os.path.isfile(dest)
+            with open(dest, 'r') as f:
+                output = f.read()
+                self.assertEqual(output, 'd')
+
+    def test_relpath_default(self):
+        """Does the FilesWriter relpath option take precedence over the path?"""
+
+        # Work in a temporary directory.
+        with self.create_temp_cwd():
+
+            # Create test file
+            os.mkdir('sub')
+            with open(os.path.join('sub', 'c'), 'w') as f:
+                f.write('d')
+
+            # Create the resoruces dictionary
+            res = dict(metadata=dict(path="other_sub"))
+
+            # Create files writer, test output
+            writer = FilesWriter()
+            writer.files = [os.path.join('sub', 'c')]
+            writer.build_directory = u'build'
+            writer.relpath = 'sub'
+            writer.write(u'y', res, notebook_name="z")
+
+            # Check the output of the file
+            assert os.path.isdir(writer.build_directory)
+            dest = os.path.join(writer.build_directory, 'z')
+            with open(dest, 'r') as f:
+                output = f.read()
+                self.assertEqual(output, u'y')
+
+            # Check to make sure the linked file was copied
+            dest = os.path.join(writer.build_directory, 'c')
+            assert os.path.isfile(dest)
+            with open(dest, 'r') as f:
+                output = f.read()
+                self.assertEqual(output, 'd')