Working versions of formatters for files and directories that are generated within an IPython notebook session. This is useful for integrating tools like QIIME with the IPython notebook as it allows users to generate QIIME's HTML visualizations and open them in new pages in their the web browser.

IPython/lib/display.py

@@ -1,8 +1,13 b''
 """Various display related classes.
 
-Authors : MinRK
+Authors : MinRK, gregcaporaso
 """
 
+from IPython.display import display, HTML
+from os import walk
+from os.path import join, exists, isfile, splitext
+
+
 class YouTubeVideo(object):
     """Class for embedding a YouTube Video in an IPython session, based on its video id.
 
@@ -33,3 +38,100 b' class YouTubeVideo(object):'
             ></iframe>
         """%(self.width, self.height, self.id)
 
+class LocalFile(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 = LocalFile("my/data.txt")
+    display(local_file)
+    """
+    
+    def __init__(self,
+                 path,
+                 _directory_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._directory_prefix = _directory_prefix
+        self._link_str = "<a href='%s' target='_blank'>%s</a>"
+        self._result_html_prefix = _result_html_prefix
+        self._result_html_suffix = _result_html_suffix
+    
+    def _format_path(self):
+        link = join(self._directory_prefix,self.path)
+        return ''.join([self._result_html_prefix,
+                        link,
+                        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.
+LocalDirectory = LocalFile
+
+class LocalFiles(LocalFile):
+    """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 = LocalFiles("my/data")
+    display(local_files)
+    """
+    def __init__(self,
+                 path,
+                 _directory_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 LocalFile (baseclass of LocalDirectory) docstring for 
+             information on additional parameters.
+        """
+        self._included_suffixes = _included_suffixes
+        LocalFile.__init__(self,
+                           path,
+                           _directory_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._directory_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)