##// END OF EJS Templates
IFrame + ScribdDocument
Eugene Van den Bulke -
Show More
@@ -1,332 +1,354 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
9 class VideoIFrame(object):
9 class IFrame(object):
10 10 """
11 Generic class to embed videos in a iframe
11 Generic class to embed an iframe in an IPython notebook
12 12 """
13 13
14 14 def __init__(self, id, width=400, height=300, **kwargs):
15 15 self.id = id
16 16 self.width = width
17 17 self.height = height
18 18 self.params = kwargs
19 19
20 20 def _repr_html_(self):
21 21 """return the embed iframe for this video id"""
22 22 if self.params:
23 23 from urllib import urlencode
24 24 params = "?" + urlencode(self.params)
25 25 else:
26 26 params = ""
27 27 return self.iframe.format(width=self.width,
28 28 height=self.height,
29 29 id=self.id,
30 30 params=params)
31 31
32 class YouTubeVideo(VideoIFrame):
32 class YouTubeVideo(IFrame):
33 33 """Class for embedding a YouTube Video in an IPython session, based on its video id.
34 34
35 35 e.g. to embed the video on this page:
36 36
37 37 http://www.youtube.com/watch?v=foo
38 38
39 39 you would do:
40 40
41 41 vid = YouTubeVideo("foo")
42 42 display(vid)
43 43
44 44 To start from 30 seconds:
45 45
46 46 vid = YouTubeVideo("abc", start=30)
47 47 display(vid)
48 48
49 49 To calculate seconds from time as hours, minutes, seconds use:
50 50 start=int(timedelta(hours=1, minutes=46, seconds=40).total_seconds())
51 51
52 52 Other parameters can be provided as documented at
53 53 https://developers.google.com/youtube/player_parameters#parameter-subheader
54 54 """
55 55
56 56 iframe = """
57 57 <iframe
58 58 width="{width}"
59 59 height={height}"
60 60 src="http://www.youtube.com/embed/{id}{params}"
61 61 frameborder="0"
62 62 allowfullscreen
63 63 ></iframe>
64 64 """
65 65
66 66 class VimeoVideo(VideoIFrame):
67 67 """
68 68 Class for embedding a Vimeo video in an IPython session, based on its video id.
69 69 """
70 70
71 71 iframe = """
72 72 <iframe
73 73 width = "{width}"
74 74 height = "{height}"
75 75 src="http://player.vimeo.com/video/{id}{params}"
76 76 frameborder="0"
77 77 webkitAllowFullScreen
78 78 mozallowfullscreen
79 79 allowFullScreen
80 80 ></iframe>
81 81 """
82 82
83 class ScribdDocument(IFrame):
84 """
85 Class for embedding a Scribd document in an IPython session
86
87 Use the start_page params to specify a starting point in the document
88 Use the view_mode params to specify display type one off scroll | slideshow | book
89
90 e.g to Display Wes' foundational paper about PANDAS in book mode from page 3
91
92 ScribdDocument(71048089, width=800, height=400, start_page=3, view_mode="book")
93 """
94
95 iframe = """
96 <iframe
97 width = "{width}"
98 height = "{height}"
99 src="http://www.scribd.com/embeds/{id}/content{params}"
100 data-auto-height="false"
101 scrolling="no"
102 frameborder="0">
103 </iframe>
104 """
83 105
84 106 class FileLink(object):
85 107 """Class for embedding a local file link in an IPython session, based on path
86 108
87 109 e.g. to embed a link that was generated in the IPython notebook as my/data.txt
88 110
89 111 you would do::
90 112
91 113 local_file = FileLink("my/data.txt")
92 114 display(local_file)
93 115
94 116 or in the HTML notebook, just::
95 117
96 118 FileLink("my/data.txt")
97 119 """
98 120
99 121 html_link_str = "<a href='%s' target='_blank'>%s</a>"
100 122
101 123 def __init__(self,
102 124 path,
103 125 url_prefix='files/',
104 126 result_html_prefix='',
105 127 result_html_suffix='<br>'):
106 128 """
107 129 Parameters
108 130 ----------
109 131 path : str
110 132 path to the file or directory that should be formatted
111 133 directory_prefix : str
112 134 prefix to be prepended to all files to form a working link [default:
113 135 'files']
114 136 result_html_prefix : str
115 137 text to append to beginning to link [default: none]
116 138 result_html_suffix : str
117 139 text to append at the end of link [default: '<br>']
118 140 """
119 141 if isdir(path):
120 142 raise ValueError,\
121 143 ("Cannot display a directory using FileLink. "
122 144 "Use FileLinks to display '%s'." % path)
123 145 self.path = path
124 146 self.url_prefix = url_prefix
125 147 self.result_html_prefix = result_html_prefix
126 148 self.result_html_suffix = result_html_suffix
127 149
128 150 def _format_path(self):
129 151 fp = ''.join([self.url_prefix,self.path])
130 152 return ''.join([self.result_html_prefix,
131 153 self.html_link_str % (fp, self.path),
132 154 self.result_html_suffix])
133 155
134 156 def _repr_html_(self):
135 157 """return html link to file
136 158 """
137 159 if not exists(self.path):
138 160 return ("Path (<tt>%s</tt>) doesn't exist. "
139 161 "It may still be in the process of "
140 162 "being generated, or you may have the "
141 163 "incorrect path." % self.path)
142 164
143 165 return self._format_path()
144 166
145 167 def __repr__(self):
146 168 """return absolute path to file
147 169 """
148 170 return abspath(self.path)
149 171
150 172 class FileLinks(FileLink):
151 173 """Class for embedding local file links in an IPython session, based on path
152 174
153 175 e.g. to embed links to files that were generated in the IPython notebook under my/data
154 176
155 177 you would do:
156 178
157 179 local_files = FileLinks("my/data")
158 180 display(local_files)
159 181
160 182 or in the HTML notebook, just
161 183
162 184 FileLinks("my/data")
163 185
164 186 """
165 187 def __init__(self,
166 188 path,
167 189 url_prefix='files/',
168 190 included_suffixes=None,
169 191 result_html_prefix='',
170 192 result_html_suffix='<br>',
171 193 notebook_display_formatter=None,
172 194 terminal_display_formatter=None):
173 195 """
174 196 included_suffixes : list of filename suffixes to include when
175 197 formatting output [default: include all files]
176 198
177 199 See the FileLink (baseclass of LocalDirectory) docstring for
178 200 information on additional parameters.
179 201
180 202 notebook_display_formatter : func used to format links for display
181 203 in the notebook. See discussion of formatter function below.
182 204
183 205 terminal_display_formatter : func used to format links for display
184 206 in the terminal. See discussion of formatter function below.
185 207
186 208
187 209 Passing custom formatter functions
188 210 ----------------------------------
189 211 Formatter functions must be of the form:
190 212 f(dirname, fnames, included_suffixes)
191 213 dirname : the name of a directory (a string),
192 214 fnames : a list of the files in that directory
193 215 included_suffixes : a list of the file suffixes that should be
194 216 included in the output (passing None means
195 217 to include all suffixes in the output in
196 218 the built-in formatters)
197 219
198 220 returns a list of lines that should will be print in the
199 221 notebook (if passing notebook_display_formatter) or the terminal
200 222 (if passing terminal_display_formatter). This function is iterated
201 223 over for each directory in self.path. Default formatters are in
202 224 place, can be passed here to support alternative formatting.
203 225
204 226 """
205 227 if isfile(path):
206 228 raise ValueError,\
207 229 ("Cannot display a file using FileLinks. "
208 230 "Use FileLink to display '%s'." % path)
209 231 self.included_suffixes = included_suffixes
210 232 # remove trailing slashs for more consistent output formatting
211 233 path = path.rstrip('/')
212 234
213 235 self.path = path
214 236 self.url_prefix = url_prefix
215 237 self.result_html_prefix = result_html_prefix
216 238 self.result_html_suffix = result_html_suffix
217 239
218 240 self.notebook_display_formatter = \
219 241 notebook_display_formatter or self._get_notebook_display_formatter()
220 242 self.terminal_display_formatter = \
221 243 terminal_display_formatter or self._get_terminal_display_formatter()
222 244
223 245 def _get_display_formatter(self,
224 246 dirname_output_format,
225 247 fname_output_format,
226 248 fp_format,
227 249 fp_cleaner=None):
228 250 """ generate built-in formatter function
229 251
230 252 this is used to define both the notebook and terminal built-in
231 253 formatters as they only differ by some wrapper text for each entry
232 254
233 255 dirname_output_format: string to use for formatting directory
234 256 names, dirname will be substituted for a single "%s" which
235 257 must appear in this string
236 258 fname_output_format: string to use for formatting file names,
237 259 if a single "%s" appears in the string, fname will be substituted
238 260 if two "%s" appear in the string, the path to fname will be
239 261 substituted for the first and fname will be substituted for the
240 262 second
241 263 fp_format: string to use for formatting filepaths, must contain
242 264 exactly two "%s" and the dirname will be subsituted for the first
243 265 and fname will be substituted for the second
244 266 """
245 267 def f(dirname, fnames, included_suffixes=None):
246 268 result = []
247 269 # begin by figuring out which filenames, if any,
248 270 # are going to be displayed
249 271 display_fnames = []
250 272 for fname in fnames:
251 273 if (isfile(join(dirname,fname)) and
252 274 (included_suffixes == None or
253 275 splitext(fname)[1] in included_suffixes)):
254 276 display_fnames.append(fname)
255 277
256 278 if len(display_fnames) == 0:
257 279 # if there are no filenames to display, don't print anything
258 280 # (not even the directory name)
259 281 pass
260 282 else:
261 283 # otherwise print the formatted directory name followed by
262 284 # the formatted filenames
263 285 dirname_output_line = dirname_output_format % dirname
264 286 result.append(dirname_output_line)
265 287 for fname in display_fnames:
266 288 fp = fp_format % (dirname,fname)
267 289 if fp_cleaner is not None:
268 290 fp = fp_cleaner(fp)
269 291 try:
270 292 # output can include both a filepath and a filename...
271 293 fname_output_line = fname_output_format % (fp, fname)
272 294 except TypeError:
273 295 # ... or just a single filepath
274 296 fname_output_line = fname_output_format % fname
275 297 result.append(fname_output_line)
276 298 return result
277 299 return f
278 300
279 301 def _get_notebook_display_formatter(self,
280 302 spacer="&nbsp;&nbsp;"):
281 303 """ generate function to use for notebook formatting
282 304 """
283 305 dirname_output_format = \
284 306 self.result_html_prefix + "%s/" + self.result_html_suffix
285 307 fname_output_format = \
286 308 self.result_html_prefix + spacer + self.html_link_str + self.result_html_suffix
287 309 fp_format = self.url_prefix + '%s/%s'
288 310 if sep == "\\":
289 311 # Working on a platform where the path separator is "\", so
290 312 # must convert these to "/" for generating a URI
291 313 def fp_cleaner(fp):
292 314 # Replace all occurences of backslash ("\") with a forward
293 315 # slash ("/") - this is necessary on windows when a path is
294 316 # provided as input, but we must link to a URI
295 317 return fp.replace('\\','/')
296 318 else:
297 319 fp_cleaner = None
298 320
299 321 return self._get_display_formatter(dirname_output_format,
300 322 fname_output_format,
301 323 fp_format,
302 324 fp_cleaner)
303 325
304 326 def _get_terminal_display_formatter(self,
305 327 spacer=" "):
306 328 """ generate function to use for terminal formatting
307 329 """
308 330 dirname_output_format = "%s/"
309 331 fname_output_format = spacer + "%s"
310 332 fp_format = '%s/%s'
311 333
312 334 return self._get_display_formatter(dirname_output_format,
313 335 fname_output_format,
314 336 fp_format)
315 337
316 338 def _format_path(self):
317 339 result_lines = []
318 340 walked_dir = list(walk(self.path))
319 341 walked_dir.sort()
320 342 for dirname, subdirs, fnames in walked_dir:
321 343 result_lines += self.notebook_display_formatter(dirname, fnames, self.included_suffixes)
322 344 return '\n'.join(result_lines)
323 345
324 346 def __repr__(self):
325 347 """return newline-separated absolute paths
326 348 """
327 349 result_lines = []
328 350 walked_dir = list(walk(self.path))
329 351 walked_dir.sort()
330 352 for dirname, subdirs, fnames in walked_dir:
331 353 result_lines += self.terminal_display_formatter(dirname, fnames, self.included_suffixes)
332 354 return '\n'.join(result_lines)
General Comments 0
You need to be logged in to leave comments. Login now