##// END OF EJS Templates
recursive==False uses next(iter) for PY3 compatability; added tests to make sure it doesn't recurse
Doug Blank -
Show More
@@ -1,544 +1,544 b''
1 1 """Various display related classes.
2 2
3 3 Authors : MinRK, gregcaporaso, dannystaple
4 4 """
5 5 from os.path import exists, isfile, splitext, abspath, join, isdir
6 6 from os import walk, sep
7 7
8 8 from IPython.core.display import DisplayObject
9 9
10 10 __all__ = ['Audio', 'IFrame', 'YouTubeVideo', 'VimeoVideo', 'ScribdDocument',
11 11 'FileLink', 'FileLinks']
12 12
13 13
14 14 class Audio(DisplayObject):
15 15 """Create an audio object.
16 16
17 17 When this object is returned by an input cell or passed to the
18 18 display function, it will result in Audio controls being displayed
19 19 in the frontend (only works in the notebook).
20 20
21 21 Parameters
22 22 ----------
23 23 data : numpy array, list, unicode, str or bytes
24 24 Can be one of
25 25
26 26 * Numpy 1d array containing the desired waveform (mono)
27 27 * Numpy 2d array containing waveforms for each channel.
28 28 Shape=(NCHAN, NSAMPLES). For the standard channel order, see
29 29 http://msdn.microsoft.com/en-us/library/windows/hardware/dn653308(v=vs.85).aspx
30 30 * List of float or integer representing the waveform (mono)
31 31 * String containing the filename
32 32 * Bytestring containing raw PCM data or
33 33 * URL pointing to a file on the web.
34 34
35 35 If the array option is used the waveform will be normalized.
36 36
37 37 If a filename or url is used the format support will be browser
38 38 dependent.
39 39 url : unicode
40 40 A URL to download the data from.
41 41 filename : unicode
42 42 Path to a local file to load the data from.
43 43 embed : boolean
44 44 Should the image data be embedded using a data URI (True) or should
45 45 the original source be referenced. Set this to True if you want the
46 46 audio to playable later with no internet connection in the notebook.
47 47
48 48 Default is `True`, unless the keyword argument `url` is set, then
49 49 default value is `False`.
50 50 rate : integer
51 51 The sampling rate of the raw data.
52 52 Only required when data parameter is being used as an array
53 53 autoplay : bool
54 54 Set to True if the audio should immediately start playing.
55 55 Default is `False`.
56 56
57 57 Examples
58 58 --------
59 59 ::
60 60
61 61 # Generate a sound
62 62 import numpy as np
63 63 framerate = 44100
64 64 t = np.linspace(0,5,framerate*5)
65 65 data = np.sin(2*np.pi*220*t) + np.sin(2*np.pi*224*t))
66 66 Audio(data,rate=framerate)
67 67
68 68 # Can also do stereo or more channels
69 69 dataleft = np.sin(2*np.pi*220*t)
70 70 dataright = np.sin(2*np.pi*224*t)
71 71 Audio([dataleft, dataright],rate=framerate)
72 72
73 73 Audio("http://www.nch.com.au/acm/8k16bitpcm.wav") # From URL
74 74 Audio(url="http://www.w3schools.com/html/horse.ogg")
75 75
76 76 Audio('/path/to/sound.wav') # From file
77 77 Audio(filename='/path/to/sound.ogg')
78 78
79 79 Audio(b'RAW_WAV_DATA..) # From bytes
80 80 Audio(data=b'RAW_WAV_DATA..)
81 81
82 82 """
83 83 _read_flags = 'rb'
84 84
85 85 def __init__(self, data=None, filename=None, url=None, embed=None, rate=None, autoplay=False):
86 86 if filename is None and url is None and data is None:
87 87 raise ValueError("No image data found. Expecting filename, url, or data.")
88 88 if embed is False and url is None:
89 89 raise ValueError("No url found. Expecting url when embed=False")
90 90
91 91 if url is not None and embed is not True:
92 92 self.embed = False
93 93 else:
94 94 self.embed = True
95 95 self.autoplay = autoplay
96 96 super(Audio, self).__init__(data=data, url=url, filename=filename)
97 97
98 98 if self.data is not None and not isinstance(self.data, bytes):
99 99 self.data = self._make_wav(data,rate)
100 100
101 101 def reload(self):
102 102 """Reload the raw data from file or URL."""
103 103 import mimetypes
104 104 if self.embed:
105 105 super(Audio, self).reload()
106 106
107 107 if self.filename is not None:
108 108 self.mimetype = mimetypes.guess_type(self.filename)[0]
109 109 elif self.url is not None:
110 110 self.mimetype = mimetypes.guess_type(self.url)[0]
111 111 else:
112 112 self.mimetype = "audio/wav"
113 113
114 114 def _make_wav(self, data, rate):
115 115 """ Transform a numpy array to a PCM bytestring """
116 116 import struct
117 117 from io import BytesIO
118 118 import wave
119 119
120 120 try:
121 121 import numpy as np
122 122
123 123 data = np.array(data, dtype=float)
124 124 if len(data.shape) == 1:
125 125 nchan = 1
126 126 elif len(data.shape) == 2:
127 127 # In wave files,channels are interleaved. E.g.,
128 128 # "L1R1L2R2..." for stereo. See
129 129 # http://msdn.microsoft.com/en-us/library/windows/hardware/dn653308(v=vs.85).aspx
130 130 # for channel ordering
131 131 nchan = data.shape[0]
132 132 data = data.T.ravel()
133 133 else:
134 134 raise ValueError('Array audio input must be a 1D or 2D array')
135 135 scaled = np.int16(data/np.max(np.abs(data))*32767).tolist()
136 136 except ImportError:
137 137 # check that it is a "1D" list
138 138 idata = iter(data) # fails if not an iterable
139 139 try:
140 140 iter(idata.next())
141 141 raise TypeError('Only lists of mono audio are '
142 142 'supported if numpy is not installed')
143 143 except TypeError:
144 144 # this means it's not a nested list, which is what we want
145 145 pass
146 146 maxabsvalue = float(max([abs(x) for x in data]))
147 147 scaled = [int(x/maxabsvalue*32767) for x in data]
148 148 nchan = 1
149 149
150 150 fp = BytesIO()
151 151 waveobj = wave.open(fp,mode='wb')
152 152 waveobj.setnchannels(nchan)
153 153 waveobj.setframerate(rate)
154 154 waveobj.setsampwidth(2)
155 155 waveobj.setcomptype('NONE','NONE')
156 156 waveobj.writeframes(b''.join([struct.pack('<h',x) for x in scaled]))
157 157 val = fp.getvalue()
158 158 waveobj.close()
159 159
160 160 return val
161 161
162 162 def _data_and_metadata(self):
163 163 """shortcut for returning metadata with url information, if defined"""
164 164 md = {}
165 165 if self.url:
166 166 md['url'] = self.url
167 167 if md:
168 168 return self.data, md
169 169 else:
170 170 return self.data
171 171
172 172 def _repr_html_(self):
173 173 src = """
174 174 <audio controls="controls" {autoplay}>
175 175 <source src="{src}" type="{type}" />
176 176 Your browser does not support the audio element.
177 177 </audio>
178 178 """
179 179 return src.format(src=self.src_attr(),type=self.mimetype, autoplay=self.autoplay_attr())
180 180
181 181 def src_attr(self):
182 182 import base64
183 183 if self.embed and (self.data is not None):
184 184 data = base64=base64.b64encode(self.data).decode('ascii')
185 185 return """data:{type};base64,{base64}""".format(type=self.mimetype,
186 186 base64=data)
187 187 elif self.url is not None:
188 188 return self.url
189 189 else:
190 190 return ""
191 191
192 192 def autoplay_attr(self):
193 193 if(self.autoplay):
194 194 return 'autoplay="autoplay"'
195 195 else:
196 196 return ''
197 197
198 198 class IFrame(object):
199 199 """
200 200 Generic class to embed an iframe in an IPython notebook
201 201 """
202 202
203 203 iframe = """
204 204 <iframe
205 205 width="{width}"
206 206 height="{height}"
207 207 src="{src}{params}"
208 208 frameborder="0"
209 209 allowfullscreen
210 210 ></iframe>
211 211 """
212 212
213 213 def __init__(self, src, width, height, **kwargs):
214 214 self.src = src
215 215 self.width = width
216 216 self.height = height
217 217 self.params = kwargs
218 218
219 219 def _repr_html_(self):
220 220 """return the embed iframe"""
221 221 if self.params:
222 222 try:
223 223 from urllib.parse import urlencode # Py 3
224 224 except ImportError:
225 225 from urllib import urlencode
226 226 params = "?" + urlencode(self.params)
227 227 else:
228 228 params = ""
229 229 return self.iframe.format(src=self.src,
230 230 width=self.width,
231 231 height=self.height,
232 232 params=params)
233 233
234 234 class YouTubeVideo(IFrame):
235 235 """Class for embedding a YouTube Video in an IPython session, based on its video id.
236 236
237 237 e.g. to embed the video from https://www.youtube.com/watch?v=foo , you would
238 238 do::
239 239
240 240 vid = YouTubeVideo("foo")
241 241 display(vid)
242 242
243 243 To start from 30 seconds::
244 244
245 245 vid = YouTubeVideo("abc", start=30)
246 246 display(vid)
247 247
248 248 To calculate seconds from time as hours, minutes, seconds use
249 249 :class:`datetime.timedelta`::
250 250
251 251 start=int(timedelta(hours=1, minutes=46, seconds=40).total_seconds())
252 252
253 253 Other parameters can be provided as documented at
254 254 https://developers.google.com/youtube/player_parameters#parameter-subheader
255 255 """
256 256
257 257 def __init__(self, id, width=400, height=300, **kwargs):
258 258 src = "https://www.youtube.com/embed/{0}".format(id)
259 259 super(YouTubeVideo, self).__init__(src, width, height, **kwargs)
260 260
261 261 class VimeoVideo(IFrame):
262 262 """
263 263 Class for embedding a Vimeo video in an IPython session, based on its video id.
264 264 """
265 265
266 266 def __init__(self, id, width=400, height=300, **kwargs):
267 267 src="https://player.vimeo.com/video/{0}".format(id)
268 268 super(VimeoVideo, self).__init__(src, width, height, **kwargs)
269 269
270 270 class ScribdDocument(IFrame):
271 271 """
272 272 Class for embedding a Scribd document in an IPython session
273 273
274 274 Use the start_page params to specify a starting point in the document
275 275 Use the view_mode params to specify display type one off scroll | slideshow | book
276 276
277 277 e.g to Display Wes' foundational paper about PANDAS in book mode from page 3
278 278
279 279 ScribdDocument(71048089, width=800, height=400, start_page=3, view_mode="book")
280 280 """
281 281
282 282 def __init__(self, id, width=400, height=300, **kwargs):
283 283 src="https://www.scribd.com/embeds/{0}/content".format(id)
284 284 super(ScribdDocument, self).__init__(src, width, height, **kwargs)
285 285
286 286 class FileLink(object):
287 287 """Class for embedding a local file link in an IPython session, based on path
288 288
289 289 e.g. to embed a link that was generated in the IPython notebook as my/data.txt
290 290
291 291 you would do::
292 292
293 293 local_file = FileLink("my/data.txt")
294 294 display(local_file)
295 295
296 296 or in the HTML notebook, just::
297 297
298 298 FileLink("my/data.txt")
299 299 """
300 300
301 301 html_link_str = "<a href='%s' target='_blank'>%s</a>"
302 302
303 303 def __init__(self,
304 304 path,
305 305 url_prefix='',
306 306 result_html_prefix='',
307 307 result_html_suffix='<br>'):
308 308 """
309 309 Parameters
310 310 ----------
311 311 path : str
312 312 path to the file or directory that should be formatted
313 313 directory_prefix : str
314 314 prefix to be prepended to all files to form a working link [default:
315 315 'files']
316 316 result_html_prefix : str
317 317 text to append to beginning to link [default: none]
318 318 result_html_suffix : str
319 319 text to append at the end of link [default: '<br>']
320 320 """
321 321 if isdir(path):
322 322 raise ValueError("Cannot display a directory using FileLink. "
323 323 "Use FileLinks to display '%s'." % path)
324 324 self.path = path
325 325 self.url_prefix = url_prefix
326 326 self.result_html_prefix = result_html_prefix
327 327 self.result_html_suffix = result_html_suffix
328 328
329 329 def _format_path(self):
330 330 fp = ''.join([self.url_prefix,self.path])
331 331 return ''.join([self.result_html_prefix,
332 332 self.html_link_str % (fp, self.path),
333 333 self.result_html_suffix])
334 334
335 335 def _repr_html_(self):
336 336 """return html link to file
337 337 """
338 338 if not exists(self.path):
339 339 return ("Path (<tt>%s</tt>) doesn't exist. "
340 340 "It may still be in the process of "
341 341 "being generated, or you may have the "
342 342 "incorrect path." % self.path)
343 343
344 344 return self._format_path()
345 345
346 346 def __repr__(self):
347 347 """return absolute path to file
348 348 """
349 349 return abspath(self.path)
350 350
351 351 class FileLinks(FileLink):
352 352 """Class for embedding local file links in an IPython session, based on path
353 353
354 354 e.g. to embed links to files that were generated in the IPython notebook
355 355 under ``my/data``, you would do::
356 356
357 357 local_files = FileLinks("my/data")
358 358 display(local_files)
359 359
360 360 or in the HTML notebook, just::
361 361
362 362 FileLinks("my/data")
363 363 """
364 364 def __init__(self,
365 365 path,
366 366 url_prefix='',
367 367 included_suffixes=None,
368 368 result_html_prefix='',
369 369 result_html_suffix='<br>',
370 370 notebook_display_formatter=None,
371 371 terminal_display_formatter=None,
372 372 recursive=True):
373 373 """
374 374 See :class:`FileLink` for the ``path``, ``url_prefix``,
375 375 ``result_html_prefix`` and ``result_html_suffix`` parameters.
376 376
377 377 included_suffixes : list
378 378 Filename suffixes to include when formatting output [default: include
379 379 all files]
380 380
381 381 notebook_display_formatter : function
382 382 Used to format links for display in the notebook. See discussion of
383 383 formatter functions below.
384 384
385 385 terminal_display_formatter : function
386 386 Used to format links for display in the terminal. See discussion of
387 387 formatter functions below.
388 388
389 389 Formatter functions must be of the form::
390 390
391 391 f(dirname, fnames, included_suffixes)
392 392
393 393 dirname : str
394 394 The name of a directory
395 395 fnames : list
396 396 The files in that directory
397 397 included_suffixes : list
398 398 The file suffixes that should be included in the output (passing None
399 399 meansto include all suffixes in the output in the built-in formatters)
400 400 recursive : boolean
401 401 Whether to recurse into subdirectories. Default is True.
402 402
403 403 The function should return a list of lines that will be printed in the
404 404 notebook (if passing notebook_display_formatter) or the terminal (if
405 405 passing terminal_display_formatter). This function is iterated over for
406 406 each directory in self.path. Default formatters are in place, can be
407 407 passed here to support alternative formatting.
408 408
409 409 """
410 410 if isfile(path):
411 411 raise ValueError("Cannot display a file using FileLinks. "
412 412 "Use FileLink to display '%s'." % path)
413 413 self.included_suffixes = included_suffixes
414 414 # remove trailing slashs for more consistent output formatting
415 415 path = path.rstrip('/')
416 416
417 417 self.path = path
418 418 self.url_prefix = url_prefix
419 419 self.result_html_prefix = result_html_prefix
420 420 self.result_html_suffix = result_html_suffix
421 421
422 422 self.notebook_display_formatter = \
423 423 notebook_display_formatter or self._get_notebook_display_formatter()
424 424 self.terminal_display_formatter = \
425 425 terminal_display_formatter or self._get_terminal_display_formatter()
426 426
427 427 self.recursive = recursive
428 428
429 429 def _get_display_formatter(self,
430 430 dirname_output_format,
431 431 fname_output_format,
432 432 fp_format,
433 433 fp_cleaner=None):
434 434 """ generate built-in formatter function
435 435
436 436 this is used to define both the notebook and terminal built-in
437 437 formatters as they only differ by some wrapper text for each entry
438 438
439 439 dirname_output_format: string to use for formatting directory
440 440 names, dirname will be substituted for a single "%s" which
441 441 must appear in this string
442 442 fname_output_format: string to use for formatting file names,
443 443 if a single "%s" appears in the string, fname will be substituted
444 444 if two "%s" appear in the string, the path to fname will be
445 445 substituted for the first and fname will be substituted for the
446 446 second
447 447 fp_format: string to use for formatting filepaths, must contain
448 448 exactly two "%s" and the dirname will be subsituted for the first
449 449 and fname will be substituted for the second
450 450 """
451 451 def f(dirname, fnames, included_suffixes=None):
452 452 result = []
453 453 # begin by figuring out which filenames, if any,
454 454 # are going to be displayed
455 455 display_fnames = []
456 456 for fname in fnames:
457 457 if (isfile(join(dirname,fname)) and
458 458 (included_suffixes is None or
459 459 splitext(fname)[1] in included_suffixes)):
460 460 display_fnames.append(fname)
461 461
462 462 if len(display_fnames) == 0:
463 463 # if there are no filenames to display, don't print anything
464 464 # (not even the directory name)
465 465 pass
466 466 else:
467 467 # otherwise print the formatted directory name followed by
468 468 # the formatted filenames
469 469 dirname_output_line = dirname_output_format % dirname
470 470 result.append(dirname_output_line)
471 471 for fname in display_fnames:
472 472 fp = fp_format % (dirname,fname)
473 473 if fp_cleaner is not None:
474 474 fp = fp_cleaner(fp)
475 475 try:
476 476 # output can include both a filepath and a filename...
477 477 fname_output_line = fname_output_format % (fp, fname)
478 478 except TypeError:
479 479 # ... or just a single filepath
480 480 fname_output_line = fname_output_format % fname
481 481 result.append(fname_output_line)
482 482 return result
483 483 return f
484 484
485 485 def _get_notebook_display_formatter(self,
486 486 spacer="&nbsp;&nbsp;"):
487 487 """ generate function to use for notebook formatting
488 488 """
489 489 dirname_output_format = \
490 490 self.result_html_prefix + "%s/" + self.result_html_suffix
491 491 fname_output_format = \
492 492 self.result_html_prefix + spacer + self.html_link_str + self.result_html_suffix
493 493 fp_format = self.url_prefix + '%s/%s'
494 494 if sep == "\\":
495 495 # Working on a platform where the path separator is "\", so
496 496 # must convert these to "/" for generating a URI
497 497 def fp_cleaner(fp):
498 498 # Replace all occurences of backslash ("\") with a forward
499 499 # slash ("/") - this is necessary on windows when a path is
500 500 # provided as input, but we must link to a URI
501 501 return fp.replace('\\','/')
502 502 else:
503 503 fp_cleaner = None
504 504
505 505 return self._get_display_formatter(dirname_output_format,
506 506 fname_output_format,
507 507 fp_format,
508 508 fp_cleaner)
509 509
510 510 def _get_terminal_display_formatter(self,
511 511 spacer=" "):
512 512 """ generate function to use for terminal formatting
513 513 """
514 514 dirname_output_format = "%s/"
515 515 fname_output_format = spacer + "%s"
516 516 fp_format = '%s/%s'
517 517
518 518 return self._get_display_formatter(dirname_output_format,
519 519 fname_output_format,
520 520 fp_format)
521 521
522 522 def _format_path(self):
523 523 result_lines = []
524 524 if self.recursive:
525 525 walked_dir = list(walk(self.path))
526 526 else:
527 walked_dir = [walk(self.path).next()]
527 walked_dir = [next(walk(self.path))]
528 528 walked_dir.sort()
529 529 for dirname, subdirs, fnames in walked_dir:
530 530 result_lines += self.notebook_display_formatter(dirname, fnames, self.included_suffixes)
531 531 return '\n'.join(result_lines)
532 532
533 533 def __repr__(self):
534 534 """return newline-separated absolute paths
535 535 """
536 536 result_lines = []
537 537 if self.recursive:
538 538 walked_dir = list(walk(self.path))
539 539 else:
540 walked_dir = [walk(self.path).next()]
540 walked_dir = [next(walk(self.path))]
541 541 walked_dir.sort()
542 542 for dirname, subdirs, fnames in walked_dir:
543 543 result_lines += self.terminal_display_formatter(dirname, fnames, self.included_suffixes)
544 544 return '\n'.join(result_lines)
@@ -1,162 +1,178 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, join as pjoin, dirname
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 from IPython.testing.decorators import skipif_not_numpy
25 25
26 26 #-----------------------------------------------------------------------------
27 27 # Classes and functions
28 28 #-----------------------------------------------------------------------------
29 29
30 30 #--------------------------
31 31 # FileLink tests
32 32 #--------------------------
33 33
34 34 def test_instantiation_FileLink():
35 35 """FileLink: Test class can be instantiated"""
36 36 fl = display.FileLink('example.txt')
37 37
38 38 def test_warning_on_non_existant_path_FileLink():
39 39 """FileLink: Calling _repr_html_ on non-existant files returns a warning
40 40 """
41 41 fl = display.FileLink('example.txt')
42 42 nt.assert_true(fl._repr_html_().startswith('Path (<tt>example.txt</tt>)'))
43 43
44 44 def test_existing_path_FileLink():
45 45 """FileLink: Calling _repr_html_ functions as expected on existing filepath
46 46 """
47 47 tf = NamedTemporaryFile()
48 48 fl = display.FileLink(tf.name)
49 49 actual = fl._repr_html_()
50 50 expected = "<a href='%s' target='_blank'>%s</a><br>" % (tf.name,tf.name)
51 51 nt.assert_equal(actual,expected)
52 52
53 53 def test_existing_path_FileLink_repr():
54 54 """FileLink: Calling repr() functions as expected on existing filepath
55 55 """
56 56 tf = NamedTemporaryFile()
57 57 fl = display.FileLink(tf.name)
58 58 actual = repr(fl)
59 59 expected = tf.name
60 60 nt.assert_equal(actual,expected)
61 61
62 62 def test_error_on_directory_to_FileLink():
63 63 """FileLink: Raises error when passed directory
64 64 """
65 65 td = mkdtemp()
66 66 nt.assert_raises(ValueError,display.FileLink,td)
67 67
68 68 #--------------------------
69 69 # FileLinks tests
70 70 #--------------------------
71 71
72 72 def test_instantiation_FileLinks():
73 73 """FileLinks: Test class can be instantiated
74 74 """
75 75 fls = display.FileLinks('example')
76 76
77 77 def test_warning_on_non_existant_path_FileLinks():
78 78 """FileLinks: Calling _repr_html_ on non-existant files returns a warning
79 79 """
80 80 fls = display.FileLinks('example')
81 81 nt.assert_true(fls._repr_html_().startswith('Path (<tt>example</tt>)'))
82 82
83 83 def test_existing_path_FileLinks():
84 84 """FileLinks: Calling _repr_html_ functions as expected on existing dir
85 85 """
86 86 td = mkdtemp()
87 87 tf1 = NamedTemporaryFile(dir=td)
88 88 tf2 = NamedTemporaryFile(dir=td)
89 89 fl = display.FileLinks(td)
90 90 actual = fl._repr_html_()
91 91 actual = actual.split('\n')
92 92 actual.sort()
93 93 # the links should always have forward slashes, even on windows, so replace
94 94 # backslashes with forward slashes here
95 95 expected = ["%s/<br>" % td,
96 96 "&nbsp;&nbsp;<a href='%s' target='_blank'>%s</a><br>" %\
97 97 (tf2.name.replace("\\","/"),split(tf2.name)[1]),
98 98 "&nbsp;&nbsp;<a href='%s' target='_blank'>%s</a><br>" %\
99 99 (tf1.name.replace("\\","/"),split(tf1.name)[1])]
100 100 expected.sort()
101 101 # We compare the sorted list of links here as that's more reliable
102 102 nt.assert_equal(actual,expected)
103 103
104 104 def test_existing_path_FileLinks_alt_formatter():
105 105 """FileLinks: Calling _repr_html_ functions as expected w/ an alt formatter
106 106 """
107 107 td = mkdtemp()
108 108 tf1 = NamedTemporaryFile(dir=td)
109 109 tf2 = NamedTemporaryFile(dir=td)
110 110 def fake_formatter(dirname,fnames,included_suffixes):
111 111 return ["hello","world"]
112 112 fl = display.FileLinks(td,notebook_display_formatter=fake_formatter)
113 113 actual = fl._repr_html_()
114 114 actual = actual.split('\n')
115 115 actual.sort()
116 116 expected = ["hello","world"]
117 117 expected.sort()
118 118 # We compare the sorted list of links here as that's more reliable
119 119 nt.assert_equal(actual,expected)
120 120
121 121 def test_existing_path_FileLinks_repr():
122 122 """FileLinks: Calling repr() functions as expected on existing directory """
123 123 td = mkdtemp()
124 124 tf1 = NamedTemporaryFile(dir=td)
125 125 tf2 = NamedTemporaryFile(dir=td)
126 126 fl = display.FileLinks(td)
127 127 actual = repr(fl)
128 128 actual = actual.split('\n')
129 129 actual.sort()
130 130 expected = ['%s/' % td, ' %s' % split(tf1.name)[1],' %s' % split(tf2.name)[1]]
131 131 expected.sort()
132 132 # We compare the sorted list of links here as that's more reliable
133 133 nt.assert_equal(actual,expected)
134 134
135 135 def test_existing_path_FileLinks_repr_alt_formatter():
136 136 """FileLinks: Calling repr() functions as expected w/ alt formatter
137 137 """
138 138 td = mkdtemp()
139 139 tf1 = NamedTemporaryFile(dir=td)
140 140 tf2 = NamedTemporaryFile(dir=td)
141 141 def fake_formatter(dirname,fnames,included_suffixes):
142 142 return ["hello","world"]
143 143 fl = display.FileLinks(td,terminal_display_formatter=fake_formatter)
144 144 actual = repr(fl)
145 145 actual = actual.split('\n')
146 146 actual.sort()
147 147 expected = ["hello","world"]
148 148 expected.sort()
149 149 # We compare the sorted list of links here as that's more reliable
150 150 nt.assert_equal(actual,expected)
151 151
152 152 def test_error_on_file_to_FileLinks():
153 153 """FileLinks: Raises error when passed file
154 154 """
155 155 td = mkdtemp()
156 156 tf1 = NamedTemporaryFile(dir=td)
157 157 nt.assert_raises(ValueError,display.FileLinks,tf1.name)
158 158
159 def test_recursive_FileLinks():
160 """FileLinks: Does not recurse when recursive=False
161 """
162 td = mkdtemp()
163 tf = NamedTemporaryFile(dir=td)
164 subtd = mkdtemp(dir=td)
165 subtf = NamedTemporaryFile(dir=subtd)
166 fl = display.FileLinks(td)
167 actual = str(fl)
168 actual = actual.split('\n')
169 nt.assert_equal(len(actual), 4, actual)
170 fl = display.FileLinks(td, recursive=False)
171 actual = str(fl)
172 actual = actual.split('\n')
173 nt.assert_equal(len(actual), 2, actual)
174
159 175 @skipif_not_numpy
160 176 def test_audio_from_file():
161 177 path = pjoin(dirname(__file__), 'test.wav')
162 display.Audio(filename=path) No newline at end of file
178 display.Audio(filename=path)
General Comments 0
You need to be logged in to leave comments. Login now