Show More
@@ -1,62 +1,62 | |||
|
1 | 1 | """Read and write notebooks in JSON format. |
|
2 | 2 | |
|
3 | 3 | Authors: |
|
4 | 4 | |
|
5 | 5 | * Brian Granger |
|
6 | 6 | """ |
|
7 | 7 | |
|
8 | 8 | #----------------------------------------------------------------------------- |
|
9 | 9 | # Copyright (C) 2008-2011 The IPython Development Team |
|
10 | 10 | # |
|
11 | 11 | # Distributed under the terms of the BSD License. The full license is in |
|
12 | 12 | # the file COPYING, distributed as part of this software. |
|
13 | 13 | #----------------------------------------------------------------------------- |
|
14 | 14 | |
|
15 | 15 | #----------------------------------------------------------------------------- |
|
16 | 16 | # Imports |
|
17 | 17 | #----------------------------------------------------------------------------- |
|
18 | 18 | |
|
19 | from base64 import encodestring | |
|
20 | 19 | from .nbbase import from_dict |
|
21 |
from .rwbase import NotebookReader, NotebookWriter, |
|
|
20 | from .rwbase import NotebookReader, NotebookWriter, restore_bytes | |
|
22 | 21 | import json |
|
23 | 22 | |
|
24 | 23 | #----------------------------------------------------------------------------- |
|
25 | 24 | # Code |
|
26 | 25 | #----------------------------------------------------------------------------- |
|
27 | 26 | |
|
28 | 27 | class BytesEncoder(json.JSONEncoder): |
|
28 | """A JSON encoder that accepts b64 (and other *ascii*) bytestrings.""" | |
|
29 | 29 | def default(self, obj): |
|
30 | 30 | if isinstance(obj, bytes): |
|
31 |
return |
|
|
31 | return obj.decode('ascii') | |
|
32 | 32 | return json.JSONEncoder.default(self, obj) |
|
33 | 33 | |
|
34 | 34 | |
|
35 | 35 | class JSONReader(NotebookReader): |
|
36 | 36 | |
|
37 | 37 | def reads(self, s, **kwargs): |
|
38 | 38 | nb = json.loads(s, **kwargs) |
|
39 | 39 | nb = self.to_notebook(nb, **kwargs) |
|
40 | 40 | return nb |
|
41 | 41 | |
|
42 | 42 | def to_notebook(self, d, **kwargs): |
|
43 |
return |
|
|
43 | return restore_bytes(from_dict(d)) | |
|
44 | 44 | |
|
45 | 45 | |
|
46 | 46 | class JSONWriter(NotebookWriter): |
|
47 | 47 | |
|
48 | 48 | def writes(self, nb, **kwargs): |
|
49 | 49 | kwargs['cls'] = BytesEncoder |
|
50 | 50 | kwargs['indent'] = 4 |
|
51 | 51 | return json.dumps(nb, **kwargs) |
|
52 | 52 | |
|
53 | 53 | |
|
54 | 54 | _reader = JSONReader() |
|
55 | 55 | _writer = JSONWriter() |
|
56 | 56 | |
|
57 | 57 | reads = _reader.reads |
|
58 | 58 | read = _reader.read |
|
59 | 59 | to_notebook = _reader.to_notebook |
|
60 | 60 | write = _writer.write |
|
61 | 61 | writes = _writer.writes |
|
62 | 62 |
@@ -1,74 +1,110 | |||
|
1 | 1 | """Base classes and utilities for readers and writers. |
|
2 | 2 | |
|
3 | 3 | Authors: |
|
4 | 4 | |
|
5 | 5 | * Brian Granger |
|
6 | 6 | """ |
|
7 | 7 | |
|
8 | 8 | #----------------------------------------------------------------------------- |
|
9 | 9 | # Copyright (C) 2008-2011 The IPython Development Team |
|
10 | 10 | # |
|
11 | 11 | # Distributed under the terms of the BSD License. The full license is in |
|
12 | 12 | # the file COPYING, distributed as part of this software. |
|
13 | 13 | #----------------------------------------------------------------------------- |
|
14 | 14 | |
|
15 | 15 | #----------------------------------------------------------------------------- |
|
16 | 16 | # Imports |
|
17 | 17 | #----------------------------------------------------------------------------- |
|
18 | 18 | |
|
19 | 19 | from base64 import encodestring, decodestring |
|
20 | 20 | import pprint |
|
21 | 21 | |
|
22 | from IPython.utils.py3compat import str_to_bytes | |
|
23 | ||
|
22 | 24 | #----------------------------------------------------------------------------- |
|
23 | 25 | # Code |
|
24 | 26 | #----------------------------------------------------------------------------- |
|
25 | 27 | |
|
28 | def restore_bytes(nb): | |
|
29 | """Restore bytes of image data from unicode-only formats. | |
|
30 | ||
|
31 | Base64 encoding is handled elsewhere. Bytes objects in the notebook are | |
|
32 | always b64-encoded. We DO NOT encode/decode around file formats. | |
|
33 | """ | |
|
34 | for ws in nb.worksheets: | |
|
35 | for cell in ws.cells: | |
|
36 | if cell.cell_type == 'code': | |
|
37 | for output in cell.outputs: | |
|
38 | if 'png' in output: | |
|
39 | output.png = str_to_bytes(output.png, 'ascii') | |
|
40 | if 'jpeg' in output: | |
|
41 | output.jpeg = str_to_bytes(output.jpeg, 'ascii') | |
|
42 | return nb | |
|
43 | ||
|
44 | ||
|
45 | # b64 encode/decode are never actually used, because all bytes objects in | |
|
46 | # the notebook are already b64-encoded, and we don't need/want to double-encode | |
|
47 | ||
|
26 | 48 | def base64_decode(nb): |
|
27 |
""" |
|
|
49 | """Restore all bytes objects in the notebook from base64-encoded strings. | |
|
50 | ||
|
51 | Note: This is never used | |
|
52 | """ | |
|
28 | 53 | for ws in nb.worksheets: |
|
29 | 54 | for cell in ws.cells: |
|
30 | 55 | if cell.cell_type == 'code': |
|
31 |
|
|
|
32 | cell.png = bytes(decodestring(cell.png)) | |
|
33 | if 'jpeg' in cell: | |
|
34 | cell.jpeg = bytes(decodestring(cell.jpeg)) | |
|
56 | for output in cell.outputs: | |
|
57 | if 'png' in output: | |
|
58 | if isinstance(output.png, unicode): | |
|
59 | output.png = output.png.encode('ascii') | |
|
60 | output.png = decodestring(output.png) | |
|
61 | if 'jpeg' in output: | |
|
62 | if isinstance(output.jpeg, unicode): | |
|
63 | output.jpeg = output.jpeg.encode('ascii') | |
|
64 | output.jpeg = decodestring(output.jpeg) | |
|
35 | 65 | return nb |
|
36 | 66 | |
|
37 | 67 | |
|
38 | 68 | def base64_encode(nb): |
|
39 |
"""Base64 |
|
|
69 | """Base64 encode all bytes objects in the notebook. | |
|
70 | ||
|
71 | These will be b64-encoded unicode strings | |
|
72 | ||
|
73 | Note: This is never used | |
|
74 | """ | |
|
40 | 75 | for ws in nb.worksheets: |
|
41 | 76 | for cell in ws.cells: |
|
42 | 77 | if cell.cell_type == 'code': |
|
43 |
|
|
|
44 | cell.png = unicode(encodestring(cell.png)) | |
|
45 | if 'jpeg' in cell: | |
|
46 | cell.jpeg = unicode(encodestring(cell.jpeg)) | |
|
78 | for output in cell.outputs: | |
|
79 | if 'png' in output: | |
|
80 | output.png = encodestring(output.png).decode('ascii') | |
|
81 | if 'jpeg' in output: | |
|
82 | output.jpeg = encodestring(output.jpeg).decode('ascii') | |
|
47 | 83 | return nb |
|
48 | 84 | |
|
49 | 85 | |
|
50 | 86 | class NotebookReader(object): |
|
51 | 87 | """A class for reading notebooks.""" |
|
52 | 88 | |
|
53 | 89 | def reads(self, s, **kwargs): |
|
54 | 90 | """Read a notebook from a string.""" |
|
55 | 91 | raise NotImplementedError("loads must be implemented in a subclass") |
|
56 | 92 | |
|
57 | 93 | def read(self, fp, **kwargs): |
|
58 | 94 | """Read a notebook from a file like object""" |
|
59 | 95 | return self.read(fp.read(), **kwargs) |
|
60 | 96 | |
|
61 | 97 | |
|
62 | 98 | class NotebookWriter(object): |
|
63 | 99 | """A class for writing notebooks.""" |
|
64 | 100 | |
|
65 | 101 | def writes(self, nb, **kwargs): |
|
66 | 102 | """Write a notebook to a string.""" |
|
67 | 103 | raise NotImplementedError("loads must be implemented in a subclass") |
|
68 | 104 | |
|
69 | 105 | def write(self, nb, fp, **kwargs): |
|
70 | 106 | """Write a notebook to a file like object""" |
|
71 | 107 | return fp.write(self.writes(nb,**kwargs)) |
|
72 | 108 | |
|
73 | 109 | |
|
74 | 110 |
@@ -1,103 +1,108 | |||
|
1 | import os | |
|
2 | from base64 import encodestring | |
|
3 | ||
|
1 | 4 | from ..nbbase import ( |
|
2 | 5 | NotebookNode, |
|
3 | 6 | new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output, |
|
4 | 7 | new_metadata, new_author |
|
5 | 8 | ) |
|
6 | 9 | |
|
7 | ||
|
10 | # some random base64-encoded *bytes* | |
|
11 | png = encodestring(os.urandom(5)) | |
|
12 | jpeg = encodestring(os.urandom(6)) | |
|
8 | 13 | |
|
9 | 14 | ws = new_worksheet(name='worksheet1') |
|
10 | 15 | |
|
11 | 16 | ws.cells.append(new_text_cell( |
|
12 | 17 | u'html', |
|
13 | 18 | source='Some NumPy Examples', |
|
14 | 19 | rendered='Some NumPy Examples' |
|
15 | 20 | )) |
|
16 | 21 | |
|
17 | 22 | |
|
18 | 23 | ws.cells.append(new_code_cell( |
|
19 | 24 | input='import numpy', |
|
20 | 25 | prompt_number=1, |
|
21 | 26 | collapsed=False |
|
22 | 27 | )) |
|
23 | 28 | |
|
24 | 29 | ws.cells.append(new_text_cell( |
|
25 | 30 | u'markdown', |
|
26 | 31 | source='A random array', |
|
27 | 32 | rendered='A random array' |
|
28 | 33 | )) |
|
29 | 34 | |
|
30 | 35 | ws.cells.append(new_code_cell( |
|
31 | 36 | input='a = numpy.random.rand(100)', |
|
32 | 37 | prompt_number=2, |
|
33 | 38 | collapsed=True |
|
34 | 39 | )) |
|
35 | 40 | |
|
36 | 41 | ws.cells.append(new_code_cell( |
|
37 | 42 | input='print a', |
|
38 | 43 | prompt_number=3, |
|
39 | 44 | collapsed=False, |
|
40 | 45 | outputs=[new_output( |
|
41 | 46 | output_type=u'pyout', |
|
42 | 47 | output_text=u'<array a>', |
|
43 | 48 | output_html=u'The HTML rep', |
|
44 | 49 | output_latex=u'$a$', |
|
45 |
output_png= |
|
|
46 |
output_jpeg= |
|
|
50 | output_png=png, | |
|
51 | output_jpeg=jpeg, | |
|
47 | 52 | output_svg=u'<svg>', |
|
48 | 53 | output_json=u'json data', |
|
49 | 54 | output_javascript=u'var i=0;', |
|
50 | 55 | prompt_number=3 |
|
51 | 56 | ),new_output( |
|
52 | 57 | output_type=u'display_data', |
|
53 | 58 | output_text=u'<array a>', |
|
54 | 59 | output_html=u'The HTML rep', |
|
55 | 60 | output_latex=u'$a$', |
|
56 |
output_png= |
|
|
57 |
output_jpeg= |
|
|
61 | output_png=png, | |
|
62 | output_jpeg=jpeg, | |
|
58 | 63 | output_svg=u'<svg>', |
|
59 | 64 | output_json=u'json data', |
|
60 | 65 | output_javascript=u'var i=0;' |
|
61 | 66 | ),new_output( |
|
62 | 67 | output_type=u'pyerr', |
|
63 | 68 | etype=u'NameError', |
|
64 | 69 | evalue=u'NameError was here', |
|
65 | 70 | traceback=[u'frame 0', u'frame 1', u'frame 2'] |
|
66 | 71 | )] |
|
67 | 72 | )) |
|
68 | 73 | |
|
69 | 74 | authors = [new_author(name='Bart Simpson',email='bsimpson@fox.com', |
|
70 | 75 | affiliation=u'Fox',url=u'http://www.fox.com')] |
|
71 | 76 | md = new_metadata(name=u'My Notebook',license=u'BSD',created=u'8601_goes_here', |
|
72 | 77 | modified=u'8601_goes_here',gistid=u'21341231',authors=authors) |
|
73 | 78 | |
|
74 | 79 | nb0 = new_notebook( |
|
75 | 80 | worksheets=[ws, new_worksheet(name='worksheet2')], |
|
76 | 81 | metadata=md |
|
77 | 82 | ) |
|
78 | 83 | |
|
79 | 84 | nb0_py = """# <nbformat>2</nbformat> |
|
80 | 85 | |
|
81 | 86 | # <htmlcell> |
|
82 | 87 | |
|
83 | 88 | # Some NumPy Examples |
|
84 | 89 | |
|
85 | 90 | # <codecell> |
|
86 | 91 | |
|
87 | 92 | import numpy |
|
88 | 93 | |
|
89 | 94 | # <markdowncell> |
|
90 | 95 | |
|
91 | 96 | # A random array |
|
92 | 97 | |
|
93 | 98 | # <codecell> |
|
94 | 99 | |
|
95 | 100 | a = numpy.random.rand(100) |
|
96 | 101 | |
|
97 | 102 | # <codecell> |
|
98 | 103 | |
|
99 | 104 | print a |
|
100 | 105 | |
|
101 | 106 | """ |
|
102 | 107 | |
|
103 | 108 |
General Comments 0
You need to be logged in to leave comments.
Login now