##// END OF EJS Templates
removing DirectoryLink class (which was an alias for FileLink) and modifying FileLink to raise an error if a directory is provided. @ellisonbg pointed out that these give a 404. I think removing this for now is the way to go as we don't have an immediate use case for DirectoryLink - FileLinks is what we would want users to call for linking to a directory.
Greg Caporaso -
Show More
@@ -1,285 +1,283 b''
1 1 """Various display related classes.
2 2
3 3 Authors : MinRK, gregcaporaso, dannystaple
4 4 """
5 5 import urllib
6 6
7 7 from os.path import exists, isfile, splitext, abspath, join, isdir
8 8 from os import walk
9 9
10 10
11 11 class YouTubeVideo(object):
12 12 """Class for embedding a YouTube Video in an IPython session, based on its video id.
13 13
14 14 e.g. to embed the video on this page:
15 15
16 16 http://www.youtube.com/watch?v=foo
17 17
18 18 you would do:
19 19
20 20 vid = YouTubeVideo("foo")
21 21 display(vid)
22 22
23 23 To start from 30 seconds:
24 24
25 25 vid = YouTubeVideo("abc", start=30)
26 26 display(vid)
27 27
28 28 To calculate seconds from time as hours, minutes, seconds use:
29 29 start=int(timedelta(hours=1, minutes=46, seconds=40).total_seconds())
30 30
31 31 Other parameters can be provided as documented at
32 32 https://developers.google.com/youtube/player_parameters#parameter-subheader
33 33 """
34 34
35 35 def __init__(self, id, width=400, height=300, **kwargs):
36 36 self.id = id
37 37 self.width = width
38 38 self.height = height
39 39 self.params = kwargs
40 40
41 41 def _repr_html_(self):
42 42 """return YouTube embed iframe for this video id"""
43 43 if self.params:
44 44 params = "?" + urllib.urlencode(self.params)
45 45 else:
46 46 params = ""
47 47 return """
48 48 <iframe
49 49 width="%i"
50 50 height="%i"
51 51 src="http://www.youtube.com/embed/%s%s"
52 52 frameborder="0"
53 53 allowfullscreen
54 54 ></iframe>
55 55 """ % (self.width, self.height, self.id, params)
56 56
57 57 class FileLink(object):
58 58 """Class for embedding a local file link in an IPython session, based on path
59 59
60 60 e.g. to embed a link that was generated in the IPython notebook as my/data.txt
61 61
62 62 you would do:
63 63
64 64 local_file = FileLink("my/data.txt")
65 65 display(local_file)
66 66
67 67 or in the HTML notebook, just
68 68
69 69 FileLink("my/data.txt")
70 70 """
71 71
72 72 html_link_str = "<a href='%s' target='_blank'>%s</a>"
73 73
74 74 def __init__(self,
75 75 path,
76 76 url_prefix='files/',
77 77 result_html_prefix='',
78 78 result_html_suffix='<br>'):
79 79 """
80 80 path : path to the file or directory that should be formatted
81 81 directory_prefix : prefix to be prepended to all files to form a
82 82 working link [default: 'files']
83 83 result_html_prefix : text to append to beginning to link
84 84 [default: none]
85 85 result_html_suffix : text to append at the end of link
86 86 [default: '<br>']
87 87 """
88 if isdir(path):
89 raise ValueError,\
90 ("Cannot display a directory as a FileLink object. "
91 "Use FileLinks to display '%s'." % path)
88 92 self.path = path
89 93 self.url_prefix = url_prefix
90 94 self.result_html_prefix = result_html_prefix
91 95 self.result_html_suffix = result_html_suffix
92 96
93 97 def _format_path(self):
94 98 fp = ''.join([self.url_prefix,self.path])
95 99 return ''.join([self.result_html_prefix,
96 100 self.html_link_str % (fp, self.path),
97 101 self.result_html_suffix])
98 102
99 103 def _repr_html_(self):
100 104 """return html link to file
101 105 """
102 106 if not exists(self.path):
103 107 return ("Path (<tt>%s</tt>) doesn't exist. "
104 108 "It may still be in the process of "
105 109 "being generated, or you may have the "
106 110 "incorrect path." % self.path)
107 111
108 112 return self._format_path()
109 113
110 114 def __repr__(self):
111 115 """return absolute path to file
112 116 """
113 117 return abspath(self.path)
114
115 # Create an alias for formatting a single directory name as a link.
116 # Right now this is the same as a formatting for a single file, but
117 # we'll encourage users to reference these with a different class in
118 # case we want to change this in the future.
119 DirectoryLink = FileLink
120 118
121 119 class FileLinks(FileLink):
122 120 """Class for embedding local file links in an IPython session, based on path
123 121
124 122 e.g. to embed links to files that were generated in the IPython notebook under my/data
125 123
126 124 you would do:
127 125
128 126 local_files = FileLinks("my/data")
129 127 display(local_files)
130 128
131 129 or in the HTML notebook, just
132 130
133 131 FileLinks("my/data")
134 132
135 133 """
136 134 def __init__(self,
137 135 path,
138 136 url_prefix='files/',
139 137 included_suffixes=None,
140 138 result_html_prefix='',
141 139 result_html_suffix='<br>',
142 140 notebook_display_formatter=None,
143 141 terminal_display_formatter=None):
144 142 """
145 143 included_suffixes : list of filename suffixes to include when
146 144 formatting output [default: include all files]
147 145
148 146 See the FileLink (baseclass of LocalDirectory) docstring for
149 147 information on additional parameters.
150 148
151 149 notebook_display_formatter : func used to format links for display
152 150 in the notebook. See discussion of formatter function below.
153 151
154 152 terminal_display_formatter : func used to format links for display
155 153 in the terminal. See discussion of formatter function below.
156 154
157 155
158 156 Passing custom formatter functions
159 157 ----------------------------------
160 158 Formatter functions must be of the form:
161 159 f(dirname, fnames, included_suffixes)
162 160 dirname : the name of a directory (a string),
163 161 fnames : a list of the files in that directory
164 162 included_suffixes : a list of the file suffixes that should be
165 163 included in the output (passing None means
166 164 to include all suffixes in the output in
167 165 the built-in formatters)
168 166
169 167 returns a list of lines that should will be print in the
170 168 notebook (if passing notebook_display_formatter) or the terminal
171 169 (if passing terminal_display_formatter). This function is iterated
172 170 over for each directory in self.path. Default formatters are in
173 171 place, can be passed here to support alternative formatting.
174 172
175 173 """
176 174 self.included_suffixes = included_suffixes
177 175 # remove trailing slashs for more consistent output formatting
178 176 path = path.rstrip('/')
179 FileLink.__init__(self,
180 path,
181 url_prefix,
182 result_html_prefix,
183 result_html_suffix)
177
178 self.path = path
179 self.url_prefix = url_prefix
180 self.result_html_prefix = result_html_prefix
181 self.result_html_suffix = result_html_suffix
184 182
185 183 self.notebook_display_formatter = \
186 184 notebook_display_formatter or self._get_notebook_display_formatter()
187 185 self.terminal_display_formatter = \
188 186 terminal_display_formatter or self._get_terminal_display_formatter()
189 187
190 188 def _get_display_formatter(self,
191 189 dirname_output_format,
192 190 fname_output_format,
193 191 fp_format):
194 192 """ generate built-in formatter function
195 193
196 194 this is used to define both the notebook and terminal built-in
197 195 formatters as they only differ by some wrapper text for each entry
198 196
199 197 dirname_output_format: string to use for formatting directory
200 198 names, dirname will be substituted for a single "%s" which
201 199 must appear in this string
202 200 fname_output_format: string to use for formatting file names,
203 201 if a single "%s" appears in the string, fname will be substituted
204 202 if two "%s" appear in the string, the path to fname will be
205 203 substituted for the first and fname will be substituted for the
206 204 second
207 205 fp_format: string to use for formatting filepaths, must contain
208 206 exactly two "%s" and the dirname will be subsituted for the first
209 207 and fname will be substituted for the second
210 208 """
211 209 def f(dirname, fnames, included_suffixes=None):
212 210 result = []
213 211 # begin by figuring out which filenames, if any,
214 212 # are going to be displayed
215 213 display_fnames = []
216 214 for fname in fnames:
217 215 if (isfile(join(dirname,fname)) and
218 216 (included_suffixes == None or
219 217 splitext(fname)[1] in included_suffixes)):
220 218 display_fnames.append(fname)
221 219
222 220 if len(display_fnames) == 0:
223 221 # if there are no filenames to display, don't print anything
224 222 # (not even the directory name)
225 223 pass
226 224 else:
227 225 # otherwise print the formatted directory name followed by
228 226 # the formatted filenames
229 227 dirname_output_line = dirname_output_format % dirname
230 228 result.append(dirname_output_line)
231 229 for fname in display_fnames:
232 230 fp = fp_format % (dirname,fname)
233 231 try:
234 232 # output can include both a filepath and a filename...
235 233 fname_output_line = fname_output_format % (fp, fname)
236 234 except TypeError:
237 235 # ... or just a single filepath
238 236 fname_output_line = fname_output_format % fname
239 237 result.append(fname_output_line)
240 238 return result
241 239 return f
242 240
243 241 def _get_notebook_display_formatter(self,
244 242 spacer="&nbsp;&nbsp;"):
245 243 """ generate function to use for notebook formatting
246 244 """
247 245 dirname_output_format = \
248 246 self.result_html_prefix + "%s/" + self.result_html_suffix
249 247 fname_output_format = \
250 248 self.result_html_prefix + spacer + self.html_link_str + self.result_html_suffix
251 249 fp_format = self.url_prefix + '%s/%s'
252 250
253 251 return self._get_display_formatter(dirname_output_format,
254 252 fname_output_format,
255 253 fp_format)
256 254
257 255 def _get_terminal_display_formatter(self,
258 256 spacer=" "):
259 257 """ generate function to use for terminal formatting
260 258 """
261 259 dirname_output_format = "%s/"
262 260 fname_output_format = spacer + "%s"
263 261 fp_format = '%s/%s'
264 262
265 263 return self._get_display_formatter(dirname_output_format,
266 264 fname_output_format,
267 265 fp_format)
268 266
269 267 def _format_path(self):
270 268 result_lines = []
271 269 walked_dir = list(walk(self.path))
272 270 walked_dir.sort()
273 271 for dirname, subdirs, fnames in walked_dir:
274 272 result_lines += self.notebook_display_formatter(dirname, fnames, self.included_suffixes)
275 273 return '\n'.join(result_lines)
276 274
277 275 def __repr__(self):
278 276 """return newline-separated absolute paths
279 277 """
280 278 result_lines = []
281 279 walked_dir = list(walk(self.path))
282 280 walked_dir.sort()
283 281 for dirname, subdirs, fnames in walked_dir:
284 282 result_lines += self.terminal_display_formatter(dirname, fnames, self.included_suffixes)
285 283 return '\n'.join(result_lines)
@@ -1,154 +1,140 b''
1 1 """Tests for IPython.lib.display.
2 2
3 3 """
4 4 #-----------------------------------------------------------------------------
5 5 # Copyright (c) 2012, the IPython Development Team.
6 6 #
7 7 # Distributed under the terms of the Modified BSD License.
8 8 #
9 9 # The full license is in the file COPYING.txt, distributed with this software.
10 10 #-----------------------------------------------------------------------------
11 11
12 12 #-----------------------------------------------------------------------------
13 13 # Imports
14 14 #-----------------------------------------------------------------------------
15 15 from __future__ import print_function
16 16 from tempfile import NamedTemporaryFile, mkdtemp
17 17 from os.path import split
18 18
19 19 # Third-party imports
20 20 import nose.tools as nt
21 21
22 22 # Our own imports
23 23 from IPython.lib import display
24 24
25 25 #-----------------------------------------------------------------------------
26 26 # Classes and functions
27 27 #-----------------------------------------------------------------------------
28 28
29 29 #--------------------------
30 30 # FileLink tests
31 31 #--------------------------
32 32
33 33 def test_instantiation_FileLink():
34 """Test classes can be instantiated"""
34 """FileLink: Test class can be instantiated"""
35 35 fl = display.FileLink('example.txt')
36 36
37 37 def test_warning_on_non_existant_path_FileLink():
38 """Calling _repr_html_ on non-existant files returns a warning"""
38 """FileLink: Calling _repr_html_ on non-existant files returns a warning
39 """
39 40 fl = display.FileLink('example.txt')
40 41 nt.assert_true(fl._repr_html_().startswith('Path (<tt>example.txt</tt>)'))
41 42
42 43 def test_existing_path_FileLink():
43 """ Calling _repr_html_ functions as expected on existing filepath """
44 """FileLink: Calling _repr_html_ functions as expected on existing filepath
45 """
44 46 tf = NamedTemporaryFile()
45 47 fl = display.FileLink(tf.name)
46 48 actual = fl._repr_html_()
47 49 expected = "<a href='files/%s' target='_blank'>%s</a><br>" % (tf.name,tf.name)
48 50 nt.assert_equal(actual,expected)
49 51
50 52 def test_existing_path_FileLink_repr():
51 """ Calling repr() functions as expected on existing filepath """
53 """FileLink: Calling repr() functions as expected on existing filepath
54 """
52 55 tf = NamedTemporaryFile()
53 56 fl = display.FileLink(tf.name)
54 57 actual = repr(fl)
55 58 expected = tf.name
56 59 nt.assert_equal(actual,expected)
57 60
58 61 #--------------------------
59 62 # FileLinks tests
60 63 #--------------------------
61 64
62 65 def test_instantiation_FileLinks():
63 """Test classes can be instantiated"""
66 """FileLinks: Test class can be instantiated
67 """
64 68 fls = display.FileLinks('example')
65 69
66 70 def test_warning_on_non_existant_path_FileLinks():
67 """Calling _repr_html_ on non-existant files returns a warning"""
71 """FileLinks: Calling _repr_html_ on non-existant files returns a warning
72 """
68 73 fls = display.FileLinks('example')
69 74 nt.assert_true(fls._repr_html_().startswith('Path (<tt>example</tt>)'))
70 75
71 76 def test_existing_path_FileLinks():
72 """ Calling _repr_html_ functions as expected on existing directory """
77 """FileLinks: Calling _repr_html_ functions as expected on existing dir
78 """
73 79 td = mkdtemp()
74 80 tf1 = NamedTemporaryFile(dir=td)
75 81 tf2 = NamedTemporaryFile(dir=td)
76 82 fl = display.FileLinks(td)
77 83 actual = fl._repr_html_()
78 84 actual = actual.split('\n')
79 85 actual.sort()
80 86 expected = ["%s/<br>" % td,
81 87 "&nbsp;&nbsp;<a href='files/%s' target='_blank'>%s</a><br>" % (tf2.name,split(tf2.name)[1]),
82 88 "&nbsp;&nbsp;<a href='files/%s' target='_blank'>%s</a><br>" % (tf1.name,split(tf1.name)[1])]
83 89 expected.sort()
84 90 # We compare the sorted list of links here as that's more reliable
85 91 nt.assert_equal(actual,expected)
86 92
87 93 def test_existing_path_FileLinks_alt_formatter():
88 """ Calling _repr_html_ functions as expected with an alternative formatter
94 """FileLinks: Calling _repr_html_ functions as expected w/ an alt formatter
89 95 """
90 96 td = mkdtemp()
91 97 tf1 = NamedTemporaryFile(dir=td)
92 98 tf2 = NamedTemporaryFile(dir=td)
93 99 def fake_formatter(dirname,fnames,included_suffixes):
94 100 return ["hello","world"]
95 101 fl = display.FileLinks(td,notebook_display_formatter=fake_formatter)
96 102 actual = fl._repr_html_()
97 103 actual = actual.split('\n')
98 104 actual.sort()
99 105 expected = ["hello","world"]
100 106 expected.sort()
101 107 # We compare the sorted list of links here as that's more reliable
102 108 nt.assert_equal(actual,expected)
103 109
104 110 def test_existing_path_FileLinks_repr():
105 """ Calling repr() functions as expected on existing directory """
111 """FileLinks: Calling repr() functions as expected on existing directory """
106 112 td = mkdtemp()
107 113 tf1 = NamedTemporaryFile(dir=td)
108 114 tf2 = NamedTemporaryFile(dir=td)
109 115 fl = display.FileLinks(td)
110 116 actual = repr(fl)
111 117 actual = actual.split('\n')
112 118 actual.sort()
113 119 expected = ['%s/' % td, ' %s' % split(tf1.name)[1],' %s' % split(tf2.name)[1]]
114 120 expected.sort()
115 121 # We compare the sorted list of links here as that's more reliable
116 122 nt.assert_equal(actual,expected)
117 123
118 124 def test_existing_path_FileLinks_repr_alt_formatter():
119 """ Calling repr() functions as expected with an alternative formatter
125 """FileLinks: Calling repr() functions as expected w/ alt formatter
120 126 """
121 127 td = mkdtemp()
122 128 tf1 = NamedTemporaryFile(dir=td)
123 129 tf2 = NamedTemporaryFile(dir=td)
124 130 def fake_formatter(dirname,fnames,included_suffixes):
125 131 return ["hello","world"]
126 132 fl = display.FileLinks(td,terminal_display_formatter=fake_formatter)
127 133 actual = repr(fl)
128 134 actual = actual.split('\n')
129 135 actual.sort()
130 136 expected = ["hello","world"]
131 137 expected.sort()
132 138 # We compare the sorted list of links here as that's more reliable
133 139 nt.assert_equal(actual,expected)
134 140
135 #--------------------------
136 # DirectoryLink tests
137 #--------------------------
138
139 def test_instantiation_DirectoryLink():
140 """Test classes can be instantiated"""
141 dl = display.DirectoryLink('example')
142
143 def test_warning_on_non_existant_path_DirectoryLink():
144 """Calling _repr_html_ on non-existant files returns a warning"""
145 dl = display.DirectoryLink('example')
146 nt.assert_true(dl._repr_html_().startswith('Path (<tt>example</tt>)'))
147
148 def test_existing_path_DirectoryLink():
149 """ Calling _repr_html_ functions as expected on existing directory """
150 td = mkdtemp()
151 dl = display.DirectoryLink(td)
152 actual = dl._repr_html_()
153 expected = "<a href='files/%s' target='_blank'>%s</a><br>" % (td,td)
154 nt.assert_equal(actual,expected)
General Comments 0
You need to be logged in to leave comments. Login now