modified to join urls with '/'.join instead of os.path.join. @takluyver pointed out that while os.path.join does work for this on OS X and Linux, it's not meant for constructing URLs, so fails on Windows where paths are constructed using \ rather than /.

IPython/lib/display.py

@@ -1,146 +1,146 b''
 """Various display related classes.
 
 Authors : MinRK, gregcaporaso
 """
 
 from os import walk
-from os.path import join, exists, isfile, splitext
+from os.path import exists, isfile, splitext
 
 
 class YouTubeVideo(object):
     """Class for embedding a YouTube Video in an IPython session, based on its video id.
 
     e.g. to embed the video on this page:
 
     http://www.youtube.com/watch?v=foo
 
     you would do:
 
     vid = YouTubeVideo("foo")
     display(vid)
     """
 
     def __init__(self, id, width=400, height=300):
         self.id = id
         self.width = width
         self.height = height
 
     def _repr_html_(self):
         """return YouTube embed iframe for this video id"""
         return """
             <iframe
                 width="%i"
                 height="%i"
                 src="http://www.youtube.com/embed/%s"
                 frameborder="0"
                 allowfullscreen
             ></iframe>
         """%(self.width, self.height, self.id)
 
 class FileLink(object):
     """Class for embedding a local file link in an IPython session, based on path
 
     e.g. to embed a link that was generated in the IPython notebook as my/data.txt
 
     you would do:
 
     local_file = FileLink("my/data.txt")
     display(local_file)
     
     or in the HTML notebook, just
     
     FileLink("my/data.txt")
     """
     
     link_str = "<a href='%s' target='_blank'>%s</a>"
     
     def __init__(self,
                  path,
                  url_prefix='files',
                  result_html_prefix='',
                  result_html_suffix='<br>'):
         """
             path : path to the file or directory that should be formatted
             directory_prefix : prefix to be prepended to all files to form a
              working link [default: 'files']
             result_html_prefix : text to append to beginning to link
              [default: none]
             result_html_suffix : text to append at the end of link
              [default: '<br>']
         """
         self.path = path
         self.url_prefix = url_prefix
         self.result_html_prefix = result_html_prefix
         self.result_html_suffix = result_html_suffix
     
     def _format_path(self):
-        fp = join(self.url_prefix,self.path)
+        fp = '/'.join([self.url_prefix,self.path])
         return ''.join([self.result_html_prefix,
                         self.link_str % (fp, self.path),
                         self.result_html_suffix])
         
     def _repr_html_(self):
         """return link to local file
         """
         if not exists(self.path):
             return ("Path (<tt>%s</tt>) doesn't exist. " 
                     "It may still be in the process of "
                     "being generated, or you may have the "
                     "incorrect path." % self.path)
         
         return self._format_path()
 
 # Create an alias for formatting a single directory name as a link.
 # Right now this is the same as a formatting for a single file, but 
 # we'll encorage users to reference these with a different class in
 # case we want to change this in the future.
 DirectoryLink = FileLink
 
 class FileLinks(FileLink):
     """Class for embedding local file links in an IPython session, based on path
 
     e.g. to embed links to files that were generated in the IPython notebook under my/data
 
     you would do:
 
     local_files = FileLinks("my/data")
     display(local_files)
     
     or in the HTML notebook, just
     
     FileLinks("my/data")
     
     """
     def __init__(self,
                  path,
                  url_prefix='files',
                  included_suffixes=None,
                  result_html_prefix='',
                  result_html_suffix='<br>'):
         """
             included_suffixes : list of filename suffixes to include when
              formatting output [default: include all files]
              
             See the FileLink (baseclass of LocalDirectory) docstring for 
              information on additional parameters.
         """
         self.included_suffixes = included_suffixes
         FileLink.__init__(self,
                            path,
                            url_prefix,
                            result_html_prefix,
                            result_html_suffix)
     
     def _format_path(self):
         result_entries = []
         for root, dirs, files in walk(self.path):
             for fn in files:
                 fp = join(self.url_prefix,root,fn)
                 # if all files are being included, or fp has a suffix
                 # that is in included_suffix, create a link to fp
                 if self.included_suffixes == None or \
                    splitext(fn)[1] in self.included_suffixes:
                     result_entries.append(''.join([self.result_html_prefix,
                                                    self.link_str % (fp,fn),
                                                    self.result_html_suffix]))
         return '\n'.join(result_entries)

IPython/lib/tests/test_display.py

@@ -1,112 +1,97 b''
 """Tests for IPython.lib.display.
 
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2012, 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
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 from tempfile import NamedTemporaryFile, mkdtemp
 
 
 # Third-party imports
 import nose.tools as nt
 
 # Our own imports
 from IPython.lib import display
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 #--------------------------
 # FileLink tests
 #--------------------------
 
 def test_instantiation_FileLink():
     """Test classes can be instantiated"""
     fl = display.FileLink('example.txt')
 
 def test_warning_on_non_existant_path_FileLink():
     """Calling _repr_html_ on non-existant files returns a warning"""
     fl = display.FileLink('example.txt')
     nt.assert_true(fl._repr_html_().startswith('Path (<tt>example.txt</tt>)'))
 
 def test_existing_path_FileLink():
     """ Calling _repr_html_ functions as expected on existing filepath """
     tf = NamedTemporaryFile()
     fl = display.FileLink(tf.name)
     actual = fl._repr_html_()
-    # Note: this is a bit awkward since tf.name has to be a full path
-    # for it to exist, but that won't happen in our applications. While
-    # in practice "files/" would be prepended to the href path, os.join
-    # doesn't do that if the second value is an absolute path. So, the
-    # expected here is slightly different than what we get in practice.
-    expected = "<a href='%s' target='_blank'>%s</a><br>" % (tf.name,tf.name)
+    expected = "<a href='files/%s' target='_blank'>%s</a><br>" % (tf.name,tf.name)
     nt.assert_equal(actual,expected)
 
 #--------------------------
 # FileLinks tests
 #--------------------------
 
 def test_instantiation_FileLinks():
     """Test classes can be instantiated"""
     fls = display.FileLinks('example')
 
 def test_warning_on_non_existant_path_FileLinks():
     """Calling _repr_html_ on non-existant files returns a warning"""
     fls = display.FileLinks('example')
     nt.assert_true(fls._repr_html_().startswith('Path (<tt>example</tt>)'))
 
 def test_existing_path_FileLinks():
     """ Calling _repr_html_ functions as expected on existing directory """
     td = mkdtemp()
     tf1 = NamedTemporaryFile(dir=td)
     tf2 = NamedTemporaryFile(dir=td)
     fl = display.FileLinks(td)
     actual = fl._repr_html_()
     actual = actual.split('\n')
     actual.sort()
-    # Note: this is a bit awkward since tf.name has to be a full path
-    # for it to exist, but that won't happen in our applications. While
-    # in practice "files/" would be prepended to the href path, os.join
-    # doesn't do that if the second value is an absolute path. So, the
-    # expected here is slightly different than what we get in practice.
-    expected = ["<a href='%s' target='_blank'>%s</a><br>" % (tf2.name,tf2.name.split('/')[-1]),
-                "<a href='%s' target='_blank'>%s</a><br>" % (tf1.name,tf1.name.split('/')[-1])]
+    expected = ["<a href='files/%s' target='_blank'>%s</a><br>" % (tf2.name,tf2.name),
+                "<a href='files/%s' target='_blank'>%s</a><br>" % (tf1.name,tf1.name)]
     expected.sort()
     # We compare the sorted list of links here as that's more reliable
     nt.assert_equal(actual,expected)
 
 #--------------------------
 # DirectoryLink tests
 #--------------------------
 
 def test_instantiation_DirectoryLink():
     """Test classes can be instantiated"""
     dl = display.DirectoryLink('example')
 
 def test_warning_on_non_existant_path_DirectoryLink():
     """Calling _repr_html_ on non-existant files returns a warning"""
     dl = display.DirectoryLink('example')
     nt.assert_true(dl._repr_html_().startswith('Path (<tt>example</tt>)'))
 
 def test_existing_path_FileLinks():
     """ Calling _repr_html_ functions as expected on existing directory """
     td = mkdtemp()
     dl = display.DirectoryLink(td)
     actual = dl._repr_html_()
-    # Note: this is a bit awkward since tf.name has to be a full path
-    # for it to exist, but that won't happen in our applications. While
-    # in practice "files/" would be prepended to the href path, os.join
-    # doesn't do that if the second value is an absolute path. So, the
-    # expected here is slightly different than what we get in practice.
-    expected = "<a href='%s' target='_blank'>%s</a><br>" % (td,td)
+    expected = "<a href='files/%s' target='_blank'>%s</a><br>" % (td,td)
     nt.assert_equal(actual,expected)