use cast_unicode in nbformat

IPython/nbformat/v3/nbbase.py

@@ -1,215 +1,216 b''
 """The basic dict based notebook format.
 
 The Python representation of a notebook is a nested structure of
 dictionary subclasses that support attribute access
 (IPython.utils.ipstruct.Struct). The functions in this module are merely
 helpers to build the structs in the right form.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import pprint
 import uuid
 
 from IPython.utils.ipstruct import Struct
+from IPython.utils.py3compat import cast_unicode
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 # Change this when incrementing the nbformat version
 nbformat = 3
 nbformat_minor = 0
 
 class NotebookNode(Struct):
     pass
 
 
 def from_dict(d):
     if isinstance(d, dict):
         newd = NotebookNode()
         for k,v in d.items():
             newd[k] = from_dict(v)
         return newd
     elif isinstance(d, (tuple, list)):
         return [from_dict(i) for i in d]
     else:
         return d
 
 
 def new_output(output_type=None, output_text=None, output_png=None,
     output_html=None, output_svg=None, output_latex=None, output_json=None,
     output_javascript=None, output_jpeg=None, prompt_number=None,
     ename=None, evalue=None, traceback=None, stream=None, metadata=None):
     """Create a new code cell with input and output"""
     output = NotebookNode()
     if output_type is not None:
         output.output_type = unicode(output_type)
 
     if metadata is None:
         metadata = {}
     if not isinstance(metadata, dict):
         raise TypeError("metadata must be dict")
     output.metadata = metadata
 
     if output_type != 'pyerr':
         if output_text is not None:
-            output.text = unicode(output_text)
+            output.text = cast_unicode(output_text)
         if output_png is not None:
-            output.png = unicode(output_png)
+            output.png = cast_unicode(output_png)
         if output_jpeg is not None:
-            output.jpeg = unicode(output_jpeg)
+            output.jpeg = cast_unicode(output_jpeg)
         if output_html is not None:
-            output.html = unicode(output_html)
+            output.html = cast_unicode(output_html)
         if output_svg is not None:
-            output.svg = unicode(output_svg)
+            output.svg = cast_unicode(output_svg)
         if output_latex is not None:
-            output.latex = unicode(output_latex)
+            output.latex = cast_unicode(output_latex)
         if output_json is not None:
-            output.json = unicode(output_json)
+            output.json = cast_unicode(output_json)
         if output_javascript is not None:
-            output.javascript = unicode(output_javascript)
+            output.javascript = cast_unicode(output_javascript)
 
     if output_type == u'pyout':
         if prompt_number is not None:
             output.prompt_number = int(prompt_number)
 
     if output_type == u'pyerr':
         if ename is not None:
-            output.ename = unicode(ename)
+            output.ename = cast_unicode(ename)
         if evalue is not None:
-            output.evalue = unicode(evalue)
+            output.evalue = cast_unicode(evalue)
         if traceback is not None:
-            output.traceback = [unicode(frame) for frame in list(traceback)]
+            output.traceback = [cast_unicode(frame) for frame in list(traceback)]
 
     if output_type == u'stream':
-        output.stream = 'stdout' if stream is None else unicode(stream)
+        output.stream = 'stdout' if stream is None else cast_unicode(stream)
     
     return output
 
 
 def new_code_cell(input=None, prompt_number=None, outputs=None,
     language=u'python', collapsed=False, metadata=None):
     """Create a new code cell with input and output"""
     cell = NotebookNode()
     cell.cell_type = u'code'
     if language is not None:
-        cell.language = unicode(language)
+        cell.language = cast_unicode(language)
     if input is not None:
-        cell.input = unicode(input)
+        cell.input = cast_unicode(input)
     if prompt_number is not None:
         cell.prompt_number = int(prompt_number)
     if outputs is None:
         cell.outputs = []
     else:
         cell.outputs = outputs
     if collapsed is not None:
         cell.collapsed = bool(collapsed)
     cell.metadata = NotebookNode(metadata or {})
 
     return cell
 
 def new_text_cell(cell_type, source=None, rendered=None, metadata=None):
     """Create a new text cell."""
     cell = NotebookNode()
     # VERSIONHACK: plaintext -> raw
     # handle never-released plaintext name for raw cells
     if cell_type == 'plaintext':
         cell_type = 'raw'
     if source is not None:
-        cell.source = unicode(source)
+        cell.source = cast_unicode(source)
     if rendered is not None:
-        cell.rendered = unicode(rendered)
+        cell.rendered = cast_unicode(rendered)
     cell.metadata = NotebookNode(metadata or {})
     cell.cell_type = cell_type
     return cell
 
 
 def new_heading_cell(source=None, rendered=None, level=1, metadata=None):
     """Create a new section cell with a given integer level."""
     cell = NotebookNode()
     cell.cell_type = u'heading'
     if source is not None:
-        cell.source = unicode(source)
+        cell.source = cast_unicode(source)
     if rendered is not None:
-        cell.rendered = unicode(rendered)
+        cell.rendered = cast_unicode(rendered)
     cell.level = int(level)
     cell.metadata = NotebookNode(metadata or {})
     return cell
 
 
 def new_worksheet(name=None, cells=None, metadata=None):
     """Create a worksheet by name with with a list of cells."""
     ws = NotebookNode()
     if name is not None:
-        ws.name = unicode(name)
+        ws.name = cast_unicode(name)
     if cells is None:
         ws.cells = []
     else:
         ws.cells = list(cells)
     ws.metadata = NotebookNode(metadata or {})
     return ws
 
 
 def new_notebook(name=None, metadata=None, worksheets=None):
     """Create a notebook by name, id and a list of worksheets."""
     nb = NotebookNode()
     nb.nbformat = nbformat
     nb.nbformat_minor = nbformat_minor
     if worksheets is None:
         nb.worksheets = []
     else:
         nb.worksheets = list(worksheets)
     if metadata is None:
         nb.metadata = new_metadata()
     else:
         nb.metadata = NotebookNode(metadata)
     if name is not None:
-        nb.metadata.name = unicode(name)
+        nb.metadata.name = cast_unicode(name)
     return nb
 
 
 def new_metadata(name=None, authors=None, license=None, created=None,
     modified=None, gistid=None):
     """Create a new metadata node."""
     metadata = NotebookNode()
     if name is not None:
-        metadata.name = unicode(name)
+        metadata.name = cast_unicode(name)
     if authors is not None:
         metadata.authors = list(authors)
     if created is not None:
-        metadata.created = unicode(created)
+        metadata.created = cast_unicode(created)
     if modified is not None:
-        metadata.modified = unicode(modified)
+        metadata.modified = cast_unicode(modified)
     if license is not None:
-        metadata.license = unicode(license)
+        metadata.license = cast_unicode(license)
     if gistid is not None:
-        metadata.gistid = unicode(gistid)
+        metadata.gistid = cast_unicode(gistid)
     return metadata
 
 def new_author(name=None, email=None, affiliation=None, url=None):
     """Create a new author."""
     author = NotebookNode()
     if name is not None:
-        author.name = unicode(name)
+        author.name = cast_unicode(name)
     if email is not None:
-        author.email = unicode(email)
+        author.email = cast_unicode(email)
     if affiliation is not None:
-        author.affiliation = unicode(affiliation)
+        author.affiliation = cast_unicode(affiliation)
     if url is not None:
-        author.url = unicode(url)
+        author.url = cast_unicode(url)
     return author
 

IPython/nbformat/v3/nbpy.py

@@ -1,204 +1,204 b''
 """Read and write notebooks as regular .py files.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import re
 from .rwbase import NotebookReader, NotebookWriter
 from .nbbase import (
     new_code_cell, new_text_cell, new_worksheet,
     new_notebook, new_heading_cell, nbformat, nbformat_minor,
 )
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 _encoding_declaration_re = re.compile(r"^#.*coding[:=]\s*([-\w.]+)")
 
 class PyReaderError(Exception):
     pass
 
 
 class PyReader(NotebookReader):
 
     def reads(self, s, **kwargs):
         return self.to_notebook(s,**kwargs)
 
     def to_notebook(self, s, **kwargs):
         lines = s.splitlines()
         cells = []
         cell_lines = []
         kwargs = {}
         state = u'codecell'
         for line in lines:
             if line.startswith(u'# <nbformat>') or _encoding_declaration_re.match(line):
                 pass
             elif line.startswith(u'# <codecell>'):
                 cell = self.new_cell(state, cell_lines, **kwargs)
                 if cell is not None:
                     cells.append(cell)
                 state = u'codecell'
                 cell_lines = []
                 kwargs = {}
             elif line.startswith(u'# <htmlcell>'):
                 cell = self.new_cell(state, cell_lines, **kwargs)
                 if cell is not None:
                     cells.append(cell)
                 state = u'htmlcell'
                 cell_lines = []
                 kwargs = {}
             elif line.startswith(u'# <markdowncell>'):
                 cell = self.new_cell(state, cell_lines, **kwargs)
                 if cell is not None:
                     cells.append(cell)
                 state = u'markdowncell'
                 cell_lines = []
                 kwargs = {}
             # VERSIONHACK: plaintext -> raw
             elif line.startswith(u'# <rawcell>') or line.startswith(u'# <plaintextcell>'):
                 cell = self.new_cell(state, cell_lines, **kwargs)
                 if cell is not None:
                     cells.append(cell)
                 state = u'rawcell'
                 cell_lines = []
                 kwargs = {}
             elif line.startswith(u'# <headingcell'):
                 cell = self.new_cell(state, cell_lines, **kwargs)
                 if cell is not None:
                     cells.append(cell)
                     cell_lines = []
                 m = re.match(r'# <headingcell level=(?P<level>\d)>',line)
                 if m is not None:
                     state = u'headingcell'
                     kwargs = {}
                     kwargs['level'] = int(m.group('level'))
                 else:
                     state = u'codecell'
                     kwargs = {}
                     cell_lines = []
             else:
                 cell_lines.append(line)
         if cell_lines and state == u'codecell':
             cell = self.new_cell(state, cell_lines)
             if cell is not None:
                 cells.append(cell)
         ws = new_worksheet(cells=cells)
         nb = new_notebook(worksheets=[ws])
         return nb
 
     def new_cell(self, state, lines, **kwargs):
         if state == u'codecell':
             input = u'\n'.join(lines)
             input = input.strip(u'\n')
             if input:
                 return new_code_cell(input=input)
         elif state == u'htmlcell':
             text = self._remove_comments(lines)
             if text:
                 return new_text_cell(u'html',source=text)
         elif state == u'markdowncell':
             text = self._remove_comments(lines)
             if text:
                 return new_text_cell(u'markdown',source=text)
         elif state == u'rawcell':
             text = self._remove_comments(lines)
             if text:
                 return new_text_cell(u'raw',source=text)
         elif state == u'headingcell':
             text = self._remove_comments(lines)
             level = kwargs.get('level',1)
             if text:
                 return new_heading_cell(source=text,level=level)
 
     def _remove_comments(self, lines):
         new_lines = []
         for line in lines:
             if line.startswith(u'#'):
                 new_lines.append(line[2:])
             else:
                 new_lines.append(line)
         text = u'\n'.join(new_lines)
         text = text.strip(u'\n')
         return text
 
     def split_lines_into_blocks(self, lines):
         if len(lines) == 1:
             yield lines[0]
             raise StopIteration()
         import ast
         source = '\n'.join(lines)
         code = ast.parse(source)
         starts = [x.lineno-1 for x in code.body]
         for i in range(len(starts)-1):
             yield '\n'.join(lines[starts[i]:starts[i+1]]).strip('\n')
         yield '\n'.join(lines[starts[-1]:]).strip('\n')
 
 
 class PyWriter(NotebookWriter):
 
     def writes(self, nb, **kwargs):
         lines = [u'# -*- coding: utf-8 -*-']
         lines.extend([
             u'# <nbformat>%i.%i</nbformat>' % (nbformat, nbformat_minor),
             u'',
         ])
         for ws in nb.worksheets:
             for cell in ws.cells:
                 if cell.cell_type == u'code':
                     input = cell.get(u'input')
                     if input is not None:
                         lines.extend([u'# <codecell>',u''])
                         lines.extend(input.splitlines())
                         lines.append(u'')
                 elif cell.cell_type == u'html':
                     input = cell.get(u'source')
                     if input is not None:
                         lines.extend([u'# <htmlcell>',u''])
                         lines.extend([u'# ' + line for line in input.splitlines()])
                         lines.append(u'')
                 elif cell.cell_type == u'markdown':
                     input = cell.get(u'source')
                     if input is not None:
                         lines.extend([u'# <markdowncell>',u''])
                         lines.extend([u'# ' + line for line in input.splitlines()])
                         lines.append(u'')
                 elif cell.cell_type == u'raw':
                     input = cell.get(u'source')
                     if input is not None:
                         lines.extend([u'# <rawcell>',u''])
                         lines.extend([u'# ' + line for line in input.splitlines()])
                         lines.append(u'')
                 elif cell.cell_type == u'heading':
                     input = cell.get(u'source')
                     level = cell.get(u'level',1)
                     if input is not None:
                         lines.extend([u'# <headingcell level=%s>' % level,u''])
                         lines.extend([u'# ' + line for line in input.splitlines()])
                         lines.append(u'')
         lines.append('')
-        return unicode('\n'.join(lines))
+        return u'\n'.join(lines)
 
 
 _reader = PyReader()
 _writer = PyWriter()
 
 reads = _reader.reads
 read = _reader.read
 to_notebook = _reader.to_notebook
 write = _writer.write
 writes = _writer.writes