##// END OF EJS Templates
Merge pull request #6564 from rossant/iframe-height-quote-missing...
Thomas Kluyver -
r18019:53ec866d merge
parent child Browse files
Show More
@@ -1,533 +1,533 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 height={height}"
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 """
373 373 See :class:`FileLink` for the ``path``, ``url_prefix``,
374 374 ``result_html_prefix`` and ``result_html_suffix`` parameters.
375 375
376 376 included_suffixes : list
377 377 Filename suffixes to include when formatting output [default: include
378 378 all files]
379 379
380 380 notebook_display_formatter : function
381 381 Used to format links for display in the notebook. See discussion of
382 382 formatter functions below.
383 383
384 384 terminal_display_formatter : function
385 385 Used to format links for display in the terminal. See discussion of
386 386 formatter functions below.
387 387
388 388 Formatter functions must be of the form::
389 389
390 390 f(dirname, fnames, included_suffixes)
391 391
392 392 dirname : str
393 393 The name of a directory
394 394 fnames : list
395 395 The files in that directory
396 396 included_suffixes : list
397 397 The file suffixes that should be included in the output (passing None
398 398 meansto include all suffixes in the output in the built-in formatters)
399 399
400 400 The function should return a list of lines that will be printed in the
401 401 notebook (if passing notebook_display_formatter) or the terminal (if
402 402 passing terminal_display_formatter). This function is iterated over for
403 403 each directory in self.path. Default formatters are in place, can be
404 404 passed here to support alternative formatting.
405 405
406 406 """
407 407 if isfile(path):
408 408 raise ValueError("Cannot display a file using FileLinks. "
409 409 "Use FileLink to display '%s'." % path)
410 410 self.included_suffixes = included_suffixes
411 411 # remove trailing slashs for more consistent output formatting
412 412 path = path.rstrip('/')
413 413
414 414 self.path = path
415 415 self.url_prefix = url_prefix
416 416 self.result_html_prefix = result_html_prefix
417 417 self.result_html_suffix = result_html_suffix
418 418
419 419 self.notebook_display_formatter = \
420 420 notebook_display_formatter or self._get_notebook_display_formatter()
421 421 self.terminal_display_formatter = \
422 422 terminal_display_formatter or self._get_terminal_display_formatter()
423 423
424 424 def _get_display_formatter(self,
425 425 dirname_output_format,
426 426 fname_output_format,
427 427 fp_format,
428 428 fp_cleaner=None):
429 429 """ generate built-in formatter function
430 430
431 431 this is used to define both the notebook and terminal built-in
432 432 formatters as they only differ by some wrapper text for each entry
433 433
434 434 dirname_output_format: string to use for formatting directory
435 435 names, dirname will be substituted for a single "%s" which
436 436 must appear in this string
437 437 fname_output_format: string to use for formatting file names,
438 438 if a single "%s" appears in the string, fname will be substituted
439 439 if two "%s" appear in the string, the path to fname will be
440 440 substituted for the first and fname will be substituted for the
441 441 second
442 442 fp_format: string to use for formatting filepaths, must contain
443 443 exactly two "%s" and the dirname will be subsituted for the first
444 444 and fname will be substituted for the second
445 445 """
446 446 def f(dirname, fnames, included_suffixes=None):
447 447 result = []
448 448 # begin by figuring out which filenames, if any,
449 449 # are going to be displayed
450 450 display_fnames = []
451 451 for fname in fnames:
452 452 if (isfile(join(dirname,fname)) and
453 453 (included_suffixes == None or
454 454 splitext(fname)[1] in included_suffixes)):
455 455 display_fnames.append(fname)
456 456
457 457 if len(display_fnames) == 0:
458 458 # if there are no filenames to display, don't print anything
459 459 # (not even the directory name)
460 460 pass
461 461 else:
462 462 # otherwise print the formatted directory name followed by
463 463 # the formatted filenames
464 464 dirname_output_line = dirname_output_format % dirname
465 465 result.append(dirname_output_line)
466 466 for fname in display_fnames:
467 467 fp = fp_format % (dirname,fname)
468 468 if fp_cleaner is not None:
469 469 fp = fp_cleaner(fp)
470 470 try:
471 471 # output can include both a filepath and a filename...
472 472 fname_output_line = fname_output_format % (fp, fname)
473 473 except TypeError:
474 474 # ... or just a single filepath
475 475 fname_output_line = fname_output_format % fname
476 476 result.append(fname_output_line)
477 477 return result
478 478 return f
479 479
480 480 def _get_notebook_display_formatter(self,
481 481 spacer="&nbsp;&nbsp;"):
482 482 """ generate function to use for notebook formatting
483 483 """
484 484 dirname_output_format = \
485 485 self.result_html_prefix + "%s/" + self.result_html_suffix
486 486 fname_output_format = \
487 487 self.result_html_prefix + spacer + self.html_link_str + self.result_html_suffix
488 488 fp_format = self.url_prefix + '%s/%s'
489 489 if sep == "\\":
490 490 # Working on a platform where the path separator is "\", so
491 491 # must convert these to "/" for generating a URI
492 492 def fp_cleaner(fp):
493 493 # Replace all occurences of backslash ("\") with a forward
494 494 # slash ("/") - this is necessary on windows when a path is
495 495 # provided as input, but we must link to a URI
496 496 return fp.replace('\\','/')
497 497 else:
498 498 fp_cleaner = None
499 499
500 500 return self._get_display_formatter(dirname_output_format,
501 501 fname_output_format,
502 502 fp_format,
503 503 fp_cleaner)
504 504
505 505 def _get_terminal_display_formatter(self,
506 506 spacer=" "):
507 507 """ generate function to use for terminal formatting
508 508 """
509 509 dirname_output_format = "%s/"
510 510 fname_output_format = spacer + "%s"
511 511 fp_format = '%s/%s'
512 512
513 513 return self._get_display_formatter(dirname_output_format,
514 514 fname_output_format,
515 515 fp_format)
516 516
517 517 def _format_path(self):
518 518 result_lines = []
519 519 walked_dir = list(walk(self.path))
520 520 walked_dir.sort()
521 521 for dirname, subdirs, fnames in walked_dir:
522 522 result_lines += self.notebook_display_formatter(dirname, fnames, self.included_suffixes)
523 523 return '\n'.join(result_lines)
524 524
525 525 def __repr__(self):
526 526 """return newline-separated absolute paths
527 527 """
528 528 result_lines = []
529 529 walked_dir = list(walk(self.path))
530 530 walked_dir.sort()
531 531 for dirname, subdirs, fnames in walked_dir:
532 532 result_lines += self.terminal_display_formatter(dirname, fnames, self.included_suffixes)
533 533 return '\n'.join(result_lines)
General Comments 0
You need to be logged in to leave comments. Login now