add nbformat_minor for minor revisions to nbformat

IPython/nbformat/current.py

@@ -1,215 +1,217 b''
 """The official API for working with notebooks in the current format version.
 
 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
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function
 import json
 from xml.etree import ElementTree as ET
 import re
 
 from IPython.nbformat import v3
 from IPython.nbformat import v2
 from IPython.nbformat import v1
 
 from IPython.nbformat.v3 import (
     NotebookNode,
     new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet,
-    parse_filename, new_metadata, new_author, new_heading_cell, nbformat
+    parse_filename, new_metadata, new_author, new_heading_cell, nbformat,
+    nbformat_minor,
 )
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 current_nbformat = nbformat
+current_nbformat_minor = nbformat_minor
+
 
 
 class NBFormatError(Exception):
     pass
 
 
 def parse_json(s, **kwargs):
     """Parse a string into a (nbformat, dict) tuple."""
     d = json.loads(s, **kwargs)
-    nbf = d.get('nbformat',1)
-    return nbf, d
+    nbf = d.get('nbformat', 1)
+    nbm = d.get('nbformat_minor', 0)
+    return nbf, nbm, d
 
 
 def parse_py(s, **kwargs):
     """Parse a string into a (nbformat, string) tuple."""
     pattern = r'# <nbformat>(?P<nbformat>\d+)</nbformat>'
     m = re.search(pattern,s)
     if m is not None:
         nbf = int(m.group('nbformat'))
     else:
         nbf = current_nbformat
     return nbf, s
 
 
 def reads_json(s, **kwargs):
     """Read a JSON notebook from a string and return the NotebookNode object."""
-    nbf, d = parse_json(s, **kwargs)
-    # cast int for reading - 3.x notebooks should be readable on 3.0, etc.
-    nbf = int(nbf)
+    nbf, minor, d = parse_json(s, **kwargs)
     if nbf == 1:
         nb = v1.to_notebook_json(d, **kwargs)
         nb = v3.convert_to_this_nbformat(nb, orig_version=1)
     elif nbf == 2:
         nb = v2.to_notebook_json(d, **kwargs)
         nb = v3.convert_to_this_nbformat(nb, orig_version=2)
     elif nbf == 3:
         nb = v3.to_notebook_json(d, **kwargs)
+        nb = v3.convert_to_this_nbformat(nb, orig_version=3, orig_minor=minor)
     else:
         raise NBFormatError('Unsupported JSON nbformat version: %i' % nbf)
     return nb
 
 
 def writes_json(nb, **kwargs):
     return v3.writes_json(nb, **kwargs)
 
 
 def reads_py(s, **kwargs):
     """Read a .py notebook from a string and return the NotebookNode object."""
     nbf, s = parse_py(s, **kwargs)
-    # cast int for reading - 3.x notebooks should be readable on 3.0, etc.
-    nbf = int(nbf)
+    nbf = nbf
     if nbf == 2:
         nb = v2.to_notebook_py(s, **kwargs)
     elif nbf == 3:
         nb = v3.to_notebook_py(s, **kwargs)
     else:
         raise NBFormatError('Unsupported PY nbformat version: %i' % nbf)
     return nb
 
 
 def writes_py(nb, **kwargs):
     return v3.writes_py(nb, **kwargs)
 
 
 # High level API
 
 
 def reads(s, format, **kwargs):
     """Read a notebook from a string and return the NotebookNode object.
 
     This function properly handles notebooks of any version. The notebook
     returned will always be in the current version's format.
 
     Parameters
     ----------
     s : unicode
         The raw unicode string to read the notebook from.
     format : (u'json', u'ipynb', u'py')
         The format that the string is in.
 
     Returns
     -------
     nb : NotebookNode
         The notebook that was read.
     """
     format = unicode(format)
     if format == u'json' or format == u'ipynb':
         return reads_json(s, **kwargs)
     elif format == u'py':
         return reads_py(s, **kwargs)
     else:
         raise NBFormatError('Unsupported format: %s' % format)
 
 
 def writes(nb, format, **kwargs):
     """Write a notebook to a string in a given format in the current nbformat version.
 
     This function always writes the notebook in the current nbformat version.
 
     Parameters
     ----------
     nb : NotebookNode
         The notebook to write.
     format : (u'json', u'ipynb', u'py')
         The format to write the notebook in.
 
     Returns
     -------
     s : unicode
         The notebook string.
     """
     format = unicode(format)
     if format == u'json' or format == u'ipynb':
         return writes_json(nb, **kwargs)
     elif format == u'py':
         return writes_py(nb, **kwargs)
     else:
         raise NBFormatError('Unsupported format: %s' % format)
 
 
 def read(fp, format, **kwargs):
     """Read a notebook from a file and return the NotebookNode object.
 
     This function properly handles notebooks of any version. The notebook
     returned will always be in the current version's format.
 
     Parameters
     ----------
     fp : file
         Any file-like object with a read method.
     format : (u'json', u'ipynb', u'py')
         The format that the string is in.
 
     Returns
     -------
     nb : NotebookNode
         The notebook that was read.
     """
     return reads(fp.read(), format, **kwargs)
 
 
 def write(nb, fp, format, **kwargs):
     """Write a notebook to a file in a given format in the current nbformat version.
 
     This function always writes the notebook in the current nbformat version.
 
     Parameters
     ----------
     nb : NotebookNode
         The notebook to write.
     fp : file
         Any file-like object with a write method.
     format : (u'json', u'ipynb', u'py')
         The format to write the notebook in.
 
     Returns
     -------
     s : unicode
         The notebook string.
     """
     return fp.write(writes(nb, format, **kwargs))
 
 def _convert_to_metadata():
     """Convert to a notebook having notebook metadata."""
     import glob
     for fname in glob.glob('*.ipynb'):
         print('Converting file:',fname)
         with open(fname,'r') as f:
             nb = read(f,u'json')
         md = new_metadata()
         if u'name' in nb:
             md.name = nb.name
             del nb[u'name']            
         nb.metadata = md
         with open(fname,'w') as f:
             write(nb, f, u'json')
 

IPython/nbformat/v3/__init__.py

@@ -1,74 +1,74 b''
 """The main API for the v3 notebook format.
 
 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
 #-----------------------------------------------------------------------------
 
 from .nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet,
-    new_metadata, new_author, new_heading_cell, nbformat
+    new_metadata, new_author, new_heading_cell, nbformat, nbformat_minor
 )
 
 from .nbjson import reads as reads_json, writes as writes_json
 from .nbjson import reads as read_json, writes as write_json
 from .nbjson import to_notebook as to_notebook_json
 
 from .nbpy import reads as reads_py, writes as writes_py
 from .nbpy import reads as read_py, writes as write_py
 from .nbpy import to_notebook as to_notebook_py
 
 from .convert import convert_to_this_nbformat
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 def parse_filename(fname):
     """Parse a notebook filename.
 
     This function takes a notebook filename and returns the notebook
     format (json/py) and the notebook name. This logic can be
     summarized as follows:
 
     * notebook.ipynb -> (notebook.ipynb, notebook, json)
     * notebook.json  -> (notebook.json, notebook, json)
     * notebook.py    -> (notebook.py, notebook, py)
     * notebook       -> (notebook.ipynb, notebook, json)
 
     Parameters
     ----------
     fname : unicode
         The notebook filename. The filename can use a specific filename
         extention (.ipynb, .json, .py) or none, in which case .ipynb will
         be assumed.
 
     Returns
     -------
     (fname, name, format) : (unicode, unicode, unicode)
         The filename, notebook name and format.
     """
     if fname.endswith(u'.ipynb'):
         format = u'json'
     elif fname.endswith(u'.json'):
         format = u'json'
     elif fname.endswith(u'.py'):
         format = u'py'
     else:
         fname = fname + u'.ipynb'
         format = u'json'
     name = fname.split('.')[0]
     return fname, name, format
 

IPython/nbformat/v3/convert.py

@@ -1,51 +1,59 b''
 """Code for converting notebooks to and from the v2 format.
 
 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
 #-----------------------------------------------------------------------------
 
 from .nbbase import (
-    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output,
+    nbformat, nbformat_minor
 )
 
 from IPython.nbformat import v2
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
-def convert_to_this_nbformat(nb, orig_version=2):
+def convert_to_this_nbformat(nb, orig_version=2, orig_minor=0):
     """Convert a notebook to the v3 format.
 
     Parameters
     ----------
     nb : NotebookNode
         The Python representation of the notebook to convert.
     orig_version : int
         The original version of the notebook to convert.
+    orig_minor : int
+        The original minor version of the notebook to convert (only relevant for v >= 3).
     """
     if orig_version == 1:
         nb = v2.convert_to_this_nbformat(nb)
         orig_version = 2
     if orig_version == 2:
         # Mark the original nbformat so consumers know it has been converted.
-        nb.nbformat = 3
+        nb.nbformat = nbformat
+        nb.nbformat_minor = nbformat_minor
+        
         nb.orig_nbformat = 2
         return nb
     elif orig_version == 3:
+        if orig_minor != nbformat_minor:
+            nb.orig_nbformat_minor = orig_minor
+        nb.nbformat_minor = nbformat_minor
         return nb
     else:
         raise ValueError('Cannot convert a notebook from v%s to v3' % orig_version)
 

IPython/nbformat/v3/nbbase.py

@@ -1,204 +1,206 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
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 # Change this when incrementing the nbformat version
-nbformat = 3.0
+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,
     etype=None, evalue=None, traceback=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 output_type != 'pyerr':
         if output_text is not None:
             output.text = unicode(output_text)
         if output_png is not None:
             output.png = bytes(output_png)
         if output_jpeg is not None:
             output.jpeg = bytes(output_jpeg)
         if output_html is not None:
             output.html = unicode(output_html)
         if output_svg is not None:
             output.svg = unicode(output_svg)
         if output_latex is not None:
             output.latex = unicode(output_latex)
         if output_json is not None:
             output.json = unicode(output_json)
         if output_javascript is not None:
             output.javascript = 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 etype is not None:
             output.etype = unicode(etype)
         if evalue is not None:
             output.evalue = unicode(evalue)
         if traceback is not None:
             output.traceback = [unicode(frame) for frame in list(traceback)]
 
     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)
     if input is not None:
         cell.input = 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)
     if rendered is not None:
         cell.rendered = 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)
     if rendered is not None:
         cell.rendered = 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)
     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)
     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)
     if authors is not None:
         metadata.authors = list(authors)
     if created is not None:
         metadata.created = unicode(created)
     if modified is not None:
         metadata.modified = unicode(modified)
     if license is not None:
         metadata.license = unicode(license)
     if gistid is not None:
         metadata.gistid = 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)
     if email is not None:
         author.email = unicode(email)
     if affiliation is not None:
         author.affiliation = unicode(affiliation)
     if url is not None:
         author.url = unicode(url)
     return author