trac_7650-sagenb_doctesting_v2.patch on Ticket #7650 – Attachment – Sage

sagenb/notebook/all.py

# HG changeset patch
# User Mitesh Patel <qed777@gmail.com>
# Date 1260713762 28800
# Node ID 489b4173fb8360449f181e891fc2f43e4239cabb
# Parent  c45cf8480e88c25ec55fe4c74456a7ae0d8dbc7e
#7650/sagenb: Fix doctesting under sagenb/

diff --git a/sagenb/notebook/all.py b/sagenb/notebook/all.py

a	b	from sage_email import email
15	15	from notebook_object import notebook, inotebook
16	16
17	17	from interact import interact, input_box, slider, range_slider, selector, checkbox, input_grid, text_control, color_selector
	18
	19	# For doctesting.
	20	import sagenb

sagenb/notebook/avatars.py

diff --git a/sagenb/notebook/avatars.py b/sagenb/notebook/avatars.py

  def user_type(avatarId):
         Traceback (most recent call last):
         ...
         AttributeError: 'NoneType' object has no attribute 'user_is_admin'
         sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+        sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
         sage: nb.create_default_users('password')
         Creating default users.
         sage: sagenb.notebook.twist.notebook = nb

sagenb/notebook/cell.py

diff --git a/sagenb/notebook/cell.py b/sagenb/notebook/cell.py

  class Cell_generic:
         """
         Returns True if this cell contains the use of interact either as a
         function call or a decorator.
         EXAMPLES::
             sage: from sagenb.notebook.cell import Cell_generic
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: Cell_generic.is_interactive_cell(C)
-…
+ class Cell_generic:
         """
         Delete all output in this cell. This is not executed - it is an
         abstract function that must be overwritten in a derived class.
         EXAMPLES: This function just raises a NotImplementedError, since it
+        most be defined in derived class.
+        ::
+        most be defined in derived class.::
             sage: C = sagenb.notebook.cell.Cell_generic()
             sage: C.delete_output()
             Traceback (most recent call last):
-…
+ class Cell_generic:
     def html_new_cell_before(self):
         """
         Returns the HTML code for inserting a new cell before self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: print C.html_new_cell_before()
             <div class="insert_new_cell" id="insert_new_cell_before0">...
-…
+ class Cell_generic:
     def html_new_cell_after(self):
         """
         Returns the HTML code for inserting a new cell after self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: print C.html_new_cell_after()
             <div class="insert_new_cell" id="insert_new_cell_after0">...
-…
+ class TextCell(Cell_generic):
     def __init__(self, id, text, worksheet):
         """
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C == loads(dumps(C))
             True
-…
+ class TextCell(Cell_generic):
     def __repr__(self):
         """
         String representation of this text cell.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C.__repr__()
             'TextCell 0: 2+3'
-…
+ class TextCell(Cell_generic):
         """
         Delete all output in this cell. This does nothing since text cells
         have no output.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C
             TextCell 0: 2+3
-…
+ class TextCell(Cell_generic):
     def set_input_text(self, input_text):
         """
         Sets the input text of self to be input_text.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C
             TextCell 0: 2+3
-…
+ class TextCell(Cell_generic):
             TextCell 0: 3+2
         """
         self.__text = input_text
     def set_worksheet(self, worksheet, id=None):
         """
         Sets the worksheet object of self to be worksheet and optionally
         changes the id of self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: W = "worksheet object"
             sage: C.set_worksheet(W)
-…
+ class TextCell(Cell_generic):
     def worksheet(self):
         """
         Returns the worksheet object associated to self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', 'worksheet object')
             sage: C.worksheet()
             'worksheet object'
-…
+ class TextCell(Cell_generic):
         Returns an HTML version of self as a string.
         INPUT:
         - ``do_math_parse`` - bool (default: True)
           If True, call math_parse (defined in cell.py)
           on the html.
+          on the html.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C.html()
             '<div class="text_cell" id="cell_text_0">2+3...'
+            '...<div class="text_cell" id="cell_text_0">2+3...'
             sage: C.set_input_text("$2+3$")
             sage: C.html(do_math_parse=True)
             '<div class="text_cell" id="cell_text_0"><span class="math">2+3</span>...'
+            '...<div class="text_cell" id="cell_text_0"><span class="math">2+3</span>...'
         """
         s = '<span id="cell_outer_%s">'%self.__id
-…
+ class TextCell(Cell_generic):
             s += self.html_new_cell_before()
         s += """<div class="text_cell" id="cell_text_%s">%s</div>"""%(
             self.__id,
+            self.__id,
             self.html_inner(ncols=ncols, do_print=do_print, do_math_parse=do_math_parse, editing=editing))
         if JEDITABLE_TINYMCE and hasattr(self.worksheet(),'is_published') and not self.worksheet().is_published() and not self.worksheet().docbrowser() and not do_print:
-…
+ class TextCell(Cell_generic):
                 print msg
                 # better to get the worksheet at all than to get a blank screen and nothing.
                 z = self.__text
             s += """<script>$("#cell_text_%s").unbind('dblclick').editable(function(value,settings) {
 evaluate_text_cell_input(%s,value,settings);
 return(value);
 }, {
+}, {
       tooltip   : "",
       placeholder : "",
 //      type   : 'textarea',
-…
+ return(value);
         Returns an HTML version of the content of self as a string.
         INPUT:
         - ``do_math_parse`` - bool (default: True)
           If True, call math_parse (defined in cell.py)
           on the html.
+          on the html.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C.html_inner()
             '2+3...'
-…
+ return(value);
                 pass
         s = """%s"""%t
         return s
     def plain_text(self, prompts=False):
         """
         Returns a plain text version of self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C.plain_text()
             '2+3'
-…
+ return(value);
     def edit_text(self):
         """
         Returns the text to be displayed in the Edit window.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C.edit_text()
             '2+3'
-…
+ return(value);
         OUTPUT:
         - int -- self's ID.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C.id()
-…
+ return(value);
     def is_auto_cell(self):
         """
         Returns True if self is automatically evaluated.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C.is_auto_cell()
             False
-…
+ return(value);
     def __cmp__(self, right):
         """
         Compares cells by ID.
         EXAMPLES::
             sage: C1 = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C2 = sagenb.notebook.cell.TextCell(0, '3+2', None)
             sage: C3 = sagenb.notebook.cell.TextCell(1, '2+3', None)
-…
+ return(value);
     def set_cell_output_type(self, typ='wrap'):
         """
         This does nothing for TextCells.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
             sage: C.set_cell_output_type("wrap")
         """
         pass # ignored
 class Cell(Cell_generic):
     def __init__(self, id, input, out, worksheet):
         """
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C == loads(dumps(C))
             True
-…
+ class Cell(Cell_generic):
         self.__asap = False
         self.__version = -1
         self.set_input_text(str(input).replace('\r',''))
     def set_asap(self, asap):
         """
         Set whether this cell is evaluated as soon as possible.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.is_asap()
             False
-…
+ class Cell(Cell_generic):
         """
         Return True if this is an asap cell, i.e., evaluation of it is done
         as soon as possible.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.is_asap()
             False
-…
+ class Cell(Cell_generic):
     def delete_output(self):
         """
         Delete all output in this cell.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None); C
             Cell 0; in=2+3, out=5
             sage: C.delete_output()
-…
+ class Cell(Cell_generic):
         r"""
         Return True if this cell has been successfully evaluated in a
         currently running session.
         This is not about whether the output of the cell is valid given the
         input.
         OUTPUT:
         -  ``bool`` - whether or not this cell has been
            evaluated in this session
         EXAMPLES: We create a worksheet with a cell that has wrong output::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: W.edit_save('Sage\n{{{\n2+3\n///\n20\n}}}')
+            sage: W.edit_save('{{{\n2+3\n///\n20\n}}}')
             sage: C = W.cell_list()[0]
             sage: C
             Cell 0; in=2+3, out=
         We re-evaluate that input cell::
             sage: C.evaluate()
+            sage: W.check_comp(wait=9999)
+            ('d', Cell 0; in=2+3, out=
+            )
+            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
+            ('w', Cell 0; in=2+3, out=)
         Now the output is right::
             sage: C
+            sage: C     # random output -- depends on computer speed
             Cell 0; in=2+3, out=
+        And the cell is considered to have been evaluated.
+        And the cell is considered to have been evaluated.::
+            sage: C.evaluated()     # random output -- depends on computer speed
+            True
         ::
+            sage: C.evaluated()
+            True
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: W.quit()
+            sage: nb.delete()
         """
         # Cells are never considered evaluated in a new session.
         if not self.worksheet().compute_process_has_been_started():
-…
+ class Cell(Cell_generic):
                 return False
             return self.__evaluated
         except AttributeError:
             # Default assumption is that cell has not been evaluated.
+            # Default assumption is that cell has not been evaluated.
             self.__evaluated = False
             return False
-…
+ class Cell(Cell_generic):
         """
         Sets whether or not this is an no_output cell, i.e., a cell for
         which we don't care at all about the output.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.is_no_output()
             False
-…
+ class Cell(Cell_generic):
         """
         Return True if this is an no_output cell, i.e., a cell for which
         we don't care at all about the output.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.is_no_output()
             False
-…
+ class Cell(Cell_generic):
     def set_cell_output_type(self, typ='wrap'):
         """
         Sets the cell output type.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.cell_output_type()
             'wrap'
-…
+ class Cell(Cell_generic):
     def cell_output_type(self):
         """
         Returns the cell output type.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.cell_output_type()
             'wrap'
-…
+ class Cell(Cell_generic):
         """
         Sets the worksheet object of self to be worksheet and optionally
         changes the id of self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: W = "worksheet object"
             sage: C.set_worksheet(W)
-…
+ class Cell(Cell_generic):
     def worksheet(self):
         """
         Returns the worksheet object associated to self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', 'worksheet object')
             sage: C.worksheet()
             'worksheet object'
-…
+ class Cell(Cell_generic):
         """
         Update the list of files with html-style links or embeddings for
         this cell.
         For interactive cells the html output section is always empty,
         mainly because there is no good way to distinguish content (e.g.,
         images in the current directory) that goes into the interactive
-…
+ class Cell(Cell_generic):
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
             sage: C.evaluate()
             sage: W.check_comp(wait=9999)
+            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
             ('d', Cell 0; in=plot(sin(x),0,5), out=
             <html><font color='black'><img src='cell://sage0.png'></font></html>
             <BLANKLINE>
+            )
             sage: C.update_html_output()
             sage: C.output_html()
+            sage: C.output_html()     # random output -- depends on computer speed
             '<img src="/home/sage/0/cells/0/sage0.png?...">'
+            sage: W.quit()
+            sage: nb.delete()
         """
         if self.is_interactive_cell():
             self.__out_html = ""
-…
+ class Cell(Cell_generic):
     def id(self):
         """
         Returns the id of self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.id()
-…
+ class Cell(Cell_generic):
     def set_id(self, id):
         """
         Sets the id of self to id.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.set_id(2)
             sage: C.id()
-…
+ class Cell(Cell_generic):
     def worksheet(self):
         """
         Returns the workseet associated to self.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
             sage: C.worksheet() is W
             True
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         return self.__worksheet
     def worksheet_filename(self):
         """
         Returns the filename of the worksheet associated to self.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
             sage: C.worksheet_filename()
             'sage/0'
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         return self.__worksheet.filename()
-…
+ class Cell(Cell_generic):
     def notebook(self):
         """
         Returns the notebook object associated to self.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
             sage: C.notebook() is nb
             True
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         return self.__worksheet.notebook()
-…
+ class Cell(Cell_generic):
         """
         Returns the directory associated to self. If the directory doesn't
         already exist, then this method creates it.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
             sage: C.directory()
+            '.../worksheets/sage/0/cells/0'
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            '.../home/sage/0/cells/0'
+            sage: nb.delete()
         """
         dir = self._directory_name()
         if not os.path.exists(dir):
-…
+ class Cell(Cell_generic):
     def _directory_name(self):
         """
         Returns a string of the directory associated to self.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
             sage: C._directory_name()
+            '.../worksheets/sage/0/cells/0'
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            '.../home/sage/0/cells/0'
+            sage: nb.delete()
         """
         return os.path.join(self.__worksheet.directory(), 'cells', str(self.id()))
-…
+ class Cell(Cell_generic):
     def __cmp__(self, right):
         """
         Compares cells by their IDs.
         EXAMPLES::
             sage: C1 = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C2 = sagenb.notebook.cell.Cell(0, '3+2', '5', None)
             sage: C3 = sagenb.notebook.cell.Cell(1, '2+3', '5', None)
-…
+ class Cell(Cell_generic):
     def __repr__(self):
         """
         Returns a string representation of self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None); C
             Cell 0; in=2+3, out=5
         """
-…
+ class Cell(Cell_generic):
         """
         Returns the number of columns for word wrapping. This defaults to
 , but the default setting for a notebook is 72.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.word_wrap_cols()
+        ::
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
             sage: C.word_wrap_cols()
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         try:
             return self.notebook().conf()['word_wrap_cols']
         except AttributeError:
             return 70
     def plain_text(self, ncols=0, prompts=True, max_out=None):
         r"""
         Returns the plain text version of self.
-…
+ class Cell(Cell_generic):
         input_lines = self.__in
         pr = 'sage: '
         if prompts:
             input_lines = input_lines.splitlines()
             has_prompt = False
-…
+ class Cell(Cell_generic):
         if not max_out is None and len(out) > max_out:
             out = out[:max_out] + '...'
         # Get rid of spurious carriage returns
+        # Get rid of spurious carriage returns
         s = s.strip('\n')
         out = out.strip('\n').strip('\r').strip('\r\n')
         s = s + '\n' + out
-…
+ class Cell(Cell_generic):
         if not prompts:
             s = s.rstrip('\n')
         return s
     def edit_text(self, ncols=0, prompts=False, max_out=None):
         r"""
         Returns the text displayed in the Edit window.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.edit_text()
             '{{{id=0|\n2+3\n///\n5\n}}}'
-…
+ class Cell(Cell_generic):
     def is_last(self):
         """
         Returns True if self is the last cell in the worksheet.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = W.new_cell_after(0, "2^2"); C
             Cell 1; in=2^2, out=
+            Cell 2; in=2^2, out=
             sage: C.is_last()
             True
             sage: C = W.get_cell_with_id(0)
             sage: C.is_last()
             False
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         return self.__worksheet.cell_list()[-1] == self
-…
+ class Cell(Cell_generic):
         Returns the id of the next cell in the worksheet associated to
         self. If self is not in the worksheet or self is the last cell in
         the cell_list, then the id of the first cell is returned.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
+            sage: C = W.new_cell_after(0, "2^2")
+            sage: C = W.get_cell_with_id(0)
+            sage: C = W.new_cell_after(1, "2^2")
+            sage: C = W.get_cell_with_id(1)
+            sage: C.next_id()
+            sage: C = W.get_cell_with_id(2)
             sage: C.next_id()
+            sage: C = W.get_cell_with_id(1)
+            sage: C.next_id()
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         L = self.__worksheet.cell_list()
         try:
-…
+ class Cell(Cell_generic):
     def interrupt(self):
         """
         Record that the calculation running in this cell was interrupted.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = W.new_cell_after(0, "2^2")
-…
+ class Cell(Cell_generic):
             True
             sage: C.evaluated()
             False
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         self.__interrupted = True
         self.__evaluated = False
-…
+ class Cell(Cell_generic):
     def interrupted(self):
         """
         Returns True if the evaluation of this cell has been interrupted.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = W.new_cell_after(0, "2^2")
             sage: C.interrupt()
             sage: C.interrupted()
             True
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         return self.__interrupted
     def computing(self):
         """
         Returns True if self is in its worksheet's queue.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = W.new_cell_after(0, "2^2")
             sage: C.computing()
             False
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         return self in self.__worksheet.queue()
-…
+ class Cell(Cell_generic):
         r"""
         Return True if this cell contains the use of interact either as a
         function call or a decorator.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = W.new_cell_after(0, "@interact\ndef f(a=slider(0,10,1,5):\n    print a^2")
-…
+ class Cell(Cell_generic):
             sage: C = W.new_cell_after(C.id(), "2+2")
             sage: C.is_interactive_cell()
             False
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: nb.delete()
         """
         # Do *not* cache
         s = strip_string_literals(self.input_text())
-…
+ class Cell(Cell_generic):
     def is_interacting(self):
         r"""
         Returns True if this cell is currently interacting with the user.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = W.new_cell_after(0, "@interact\ndef f(a=slider(0,10,1,5):\n    print a^2")
-…
+ class Cell(Cell_generic):
         """
         Stops interaction with user.
         TODO: Add doctests for :meth:`stop_interacting`.
+        TODO: Add doctests for :meth:`stop_interacting`.
         """
         if self.is_interacting():
             del self.interact
-…
+ class Cell(Cell_generic):
     def set_input_text(self, input):
         """
         Sets the input text of self to be the string input.
         TODO: Add doctests for the code dealing with interact.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = W.new_cell_after(0, "2^2")
             sage: C.evaluate()
             sage: W.check_comp(wait=9999)
+            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
             ('d', Cell 1; in=2^2, out=
+            )
             sage: C.version()
-        ::
             sage: C.set_input_text('3+3')
             sage: C.input_text()
             '3+3'
-…
+ class Cell(Cell_generic):
             False
             sage: C.version()
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: W.quit()
+            sage: nb.delete()
         """
         # Stuff to deal with interact
         if input.startswith('%__sage_interact__'):
-…
+ class Cell(Cell_generic):
             except AttributeError:
                 pass
         # We have updated the input text so the cell can't have
         # been evaluated.
+        # We have updated the input text so the cell can't have
+        # been evaluated.
         self.__evaluated = False
         self.__version = self.version() + 1
         self.__in = input
-…
+ class Cell(Cell_generic):
         #Run get the input text with all of the percent
         #directives parsed
         self._cleaned_input = self.parse_percent_directives()
     def input_text(self):
         """
         Returns self's input text.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.input_text()
             '2+3'
-…
+ class Cell(Cell_generic):
         text is returned.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '%hide\n%maxima\n2+3', '5', None)
             sage: C.cleaned_input_text()
             '2+3'
         """
         if self.is_interacting():
             return self.interact
-…
+ class Cell(Cell_generic):
         with the percent directives at the top removed.  As it's doing
         this, it computes a list of all the directives and which
         system (if any) the cell should be run under.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '%hide\n%maxima\n2+3', '5', None)
             sage: C.parse_percent_directives()
             '2+3'
             sage: C.percent_directives()
             ['hide', 'maxima']
         """
         self._system = None
         text = self.input_text().splitlines()
-…
+ class Cell(Cell_generic):
                 pass
             else:
                 self._system = line[1:]
             directives.append(line[1:])
         self._percent_directives = directives
         return "\n".join(text[i:]).strip()
     def percent_directives(self):
         r"""
         Returns a list of all the percent directives that appear
         in this cell.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '%hide\n%maxima\n2+3', '5', None)
             sage: C.percent_directives()
             ['hide', 'maxima']
         """
         return self._percent_directives
-…
+ class Cell(Cell_generic):
         worksheet's default system.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '%maxima\n2+3', '5', None)
             sage: C.system()
             'maxima'
-…
+ class Cell(Cell_generic):
     def is_auto_cell(self):
         r"""
         Returns True if self is an auto cell.
         An auto cell is a cell that is automatically evaluated when the
         worksheet starts up.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.is_auto_cell()
             False
-…
+ class Cell(Cell_generic):
         Returns the changed input text for the cell. If there was any
         changed input text, then it is reset to " before this method
         returns.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.changed_input_text()
             ''
-…
+ class Cell(Cell_generic):
         """
         Note that this does not update the version of the cell. This is
         typically used for things like tab completion.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.set_changed_input_text('3+3')
             sage: C.input_text()
-…
+ class Cell(Cell_generic):
         Sets the output text for self.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: len(C.plain_text())
-…
+ class Cell(Cell_generic):
             output = ''
         # In interacting mode, we just save the computed output
         # (do not overwrite).
+        # (do not overwrite).
         if self.is_interacting():
             self._interact_output = (output, html)
             return
         if hasattr(self, '_html_cache'):
             del self._html_cache
-…
+ class Cell(Cell_generic):
     def sage(self):
         """
         TODO: Figure out what exactly this does.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.sage() is None
             True
-…
+ class Cell(Cell_generic):
         Returns the HTML for self's output.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.output_html()
             ''
-…
+ class Cell(Cell_generic):
         except AttributeError:
             self.__out_html = ''
             return ''
     def process_cell_urls(self, urls):
         """
         Processes URLs of the form ``'cell://.*?'`` by replacing the
-…
+ class Cell(Cell_generic):
         - ``urls`` - a string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
-…
+ class Cell(Cell_generic):
         INPUT:
         - ``ncols`` -- maximum number of columns
         - ``html`` -- boolean stating whether to output HTML
         - ``raw`` -- boolean stating whether to output raw text
           (takes precedence over HTML)
-…
+ class Cell(Cell_generic):
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
-…
+ class Cell(Cell_generic):
                 return '<h2>Click to the left again to hide and once more to show the dynamic interactive window</h2>'
         else:
             s = self.__out
         if raw:
             return s
-…
+ class Cell(Cell_generic):
         if not is_interact and not self.is_html() and len(s.strip()) > 0:
             s = '<pre class="shrunk">' + s.strip('\n') + '</pre>'
         return s.strip('\n')
     def parse_html(self, s, ncols):
-…
+ class Cell(Cell_generic):
         Parse HTML for output.
         INPUT:
         - ``s`` -- the input string containing HTML
         - ``ncols`` -- maximum number of columns
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
-…
+ class Cell(Cell_generic):
                 j = t[i:].lower().find('</script>')
                 if j == -1: break
                 t = t[:i] + t[i+j+len('</script>'):]
         return t
     def has_output(self):
         """
         Returns True if there is output for this cell.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.has_output()
             True
-…
+ class Cell(Cell_generic):
         r"""
         Returns True if this is an HTML cell. An HTML cell whose system is
         'html' and is typically specified by ``%html``.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, "%html\nTest HTML", None, None)
             sage: C.system()
             'html'
-…
+ class Cell(Cell_generic):
             sage: C = sagenb.notebook.cell.Cell(0, "Test HTML", None, None)
             sage: C.is_html()
             False
         """
         try:
             return self.__is_html
-…
+ class Cell(Cell_generic):
     def set_is_html(self, v):
         """
         Sets whether or not this cell is an HTML cell.
         This is called by check_for_system_switching in worksheet.py.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.is_html()
             False
-…
+ class Cell(Cell_generic):
     #################
     # Introspection #
     #################
     def set_introspect_html(self, html, completing=False, verbose=False, raw=False):
+    def set_introspect_html(self, html, completing=False, raw=False):
         """
-        If ``verbose`` is True, print verbose output about notebook
-        introspection to the command-line.  However, the argument
-        ``verbose`` is not easily accessible now -- if you need to
-        debug, you have to edit this file, changing its value to True,
-        and run 'sage -b'.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
             sage: C.introspect()
             False
             sage: C.evaluate(username='sage')
             sage: W.check_comp(9999)
+            sage: W.check_comp(9999)     # random output -- depends on computer speed
             ('d', Cell 0; in=sage?, out=)
             sage: C.set_introspect_html('foobar')
             sage: C.introspect_html()
             '<div class="docstring"><pre>foobar</pre></div>'
+            'foobar'
             sage: C.set_introspect_html('`foobar`')
             sage: C.introspect_html()
+            '<div class="docstring">...<span class="math">foobar</span>...</div>'
+            '`foobar`'
+            sage: W.quit()
+            sage: nb.delete()
         """
         self.__introspect_html = html
         self.introspection_status = 'done'
     def get_introspection_status(self):
         try:
             return self.__introspection_status
-…
+ class Cell(Cell_generic):
         self.__introspection_status = value
     introspection_status = property(get_introspection_status, set_introspection_status)
     def introspect_html(self):
         """
         Returns HTML for introspection.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
             sage: C.introspect()
             False
             sage: C.evaluate(username='sage')
             sage: W.check_comp(9999)
+            sage: W.check_comp(9999)     # random output -- depends on computer speed
             ('d', Cell 0; in=sage?, out=)
+            sage: C.introspect_html()
+            u'<div class="docstring">...</pre></div>'
+            sage: C.introspect_html()     # random output -- depends on computer speed
+            u'...<div class="docstring">...sage...</pre></div>...'
+            sage: W.quit()
+            sage: nb.delete()
         """
         if not self.introspect():
             return ''
-…
+ class Cell(Cell_generic):
     def introspect(self):
         """
         Returns self's introspection text.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
             sage: C.introspect()
             False
             sage: C.evaluate(username='sage')
             sage: W.check_comp(9999)
+            sage: W.check_comp(9999)     # random output -- depends on computer speed
             ('d', Cell 0; in=sage?, out=)
             sage: C.introspect()
             ['sage?', '']
+            sage: W.quit()
+            sage: nb.delete()
         """
         try:
             return self.__introspect
-…
+ class Cell(Cell_generic):
     def unset_introspect(self):
         """
         Unsets self's introspection text.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
             sage: C.introspect()
             False
             sage: C.evaluate(username='sage')
             sage: W.check_comp(9999)
+            sage: W.check_comp(9999)     # random output -- depends on computer speed
             ('d', Cell 0; in=sage?, out=)
             sage: C.introspect()
             ['sage?', '']
             sage: C.unset_introspect()
             sage: C.introspect()
             False
+            sage: W.quit()
+            sage: nb.delete()
         """
         self.__introspect = False
     def set_introspect(self, before_prompt, after_prompt):
         """
         Set self's introspection text.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.set_introspect("a", "b")
             sage: C.introspect()
-…
+ class Cell(Cell_generic):
     def evaluate(self, introspect=False, time=None, username=None):
         r"""
         INPUT:
         -  ``username`` - name of user doing the evaluation
         -  ``time`` - if True return time computation takes
         -  ``introspect`` - either False or a pair
            [before_cursor, after_cursor] of strings.
         EXAMPLES:
         We create a notebook, worksheet, and cell and evaluate it
         in order to compute `3^5`::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: W.edit_save('Sage\n{{{\n3^5\n}}}')
+            sage: W.edit_save('{{{\n3^5\n}}}')
             sage: C = W.cell_list()[0]; C
             Cell 0; in=3^5, out=
             sage: C.evaluate(username='sage')
             sage: W.check_comp(wait=9999)
+            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
             ('d', Cell 0; in=3^5, out=
+            )
             sage: C
+            sage: C     # random output -- depends on computer speed
             Cell 0; in=3^5, out=
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: W.quit()
+            sage: nb.delete()
         """
         self.__interrupted = False
         self.__evaluated = True
-…
+ class Cell(Cell_generic):
                     shutil.rmtree(F)
                 except:
                     pass
     def version(self):
         """
         Returns the version number of this cell.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.version()
-…
+ class Cell(Cell_generic):
         r"""
         Returns True if the time it takes to evaluate this cell should be
         printed.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: C.time()
             False
-…
+ class Cell(Cell_generic):
         if div_wrap:
             s = '\n\n<div id="cell_outer_%s" class="cell_visible"><div id="cell_%s" class="%s">'%(self.id(), self.id(), cls) + s + '</div></div>'
         return s
     def html(self, wrap=None, div_wrap=True, do_print=False):
         r"""
         Returns the HTML for self.
-…
+ class Cell(Cell_generic):
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
-…
+ class Cell(Cell_generic):
         if div_wrap:
             s = '\n\n<div id="cell_outer_%s" class="cell_visible"><div id="cell_%s" class="%s">'%(self.id(), self.id(), cls) + s + '</div></div>'
         #self._html_cache[key] = s
         return s
     def html_in(self, do_print=False, ncols=80):
         """
         Returns the HTML code for the input of this cell.
         EXAMPLES::
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
             sage: print C.html_in()
             <div class="insert_new_cell" id="insert_new_cell_0"...</a>
+            <div class="insert_new_cell" id="insert_new_cell_before0"...</a>
         """
         s = ''
         id = self.__id
         t = self.__in.rstrip()
         cls = "cell_input_hide" if 'hide' in self.percent_directives() else "cell_input"
         if not do_print:
             s += self.html_new_cell_before()
-…
+ class Cell(Cell_generic):
            s+= '<a href="javascript:evaluate_cell(%s,0)" class="eval_button" id="eval_button%s" alt="Click here or press shift-return to evaluate">evaluate</a>'%(id,id)
         t = escape(t)+" "
         return s
-…
+ class Cell(Cell_generic):
         Returns a notebook URL for this cell.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
             sage: C.url_to_self()
             '/home/sage/0/cells/0'
         """
         try:
             return self.__url_to_self
-…
+ class Cell(Cell_generic):
     def files(self):
         """
         Returns a list of all the files in self's directory.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
             sage: C.evaluate()
             sage: W.check_comp(wait=9999)
+            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
             ('d', Cell 0; in=plot(sin(x),0,5), out=
             <html><font color='black'><img src='cell://sage0.png'></font></html>
             <BLANKLINE>
+            )
             sage: C.files()
+            sage: C.files()     # random output -- depends on computer speed
             ['sage0.png']
+        ::
+            sage: import shutil; shutil.rmtree(nb.directory())
+            sage: W.quit()
+            sage: nb.delete()
         """
         dir = self.directory()
         D = os.listdir(dir)
-…
+ class Cell(Cell_generic):
     def delete_files(self):
         """
         Deletes all of the files associated with this cell.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
             sage: C.evaluate()
             sage: W.check_comp(wait=9999)
+            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
             ('d', Cell 0; in=plot(sin(x),0,5), out=
             <html><font color='black'><img src='cell://sage0.png'></font></html>
             <BLANKLINE>
+            )
             sage: C.files()
+            sage: C.files()     # random output -- depends on computer speed
             ['sage0.png']
             sage: C.delete_files()
             sage: C.files()
             []
+            sage: W.quit()
+            sage: nb.delete()
         """
         try:
             dir = self._directory_name()
-…
+ class Cell(Cell_generic):
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
             sage: C.evaluate()
             sage: W.check_comp(wait=9999)
+            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
             ('d', Cell 0; in=plot(sin(x),0,5), out=
             <html><font color='black'><img src='cell://sage0.png'></font></html>
             <BLANKLINE>
+            )
             sage: C.files_html('')
+            sage: C.files_html('')     # random output -- depends on computer speed
             '<img src="/home/sage/0/cells/0/sage0.png?...">'
+            sage: W.quit()
+            sage: nb.delete()
         """
         import time
         D = self.files()
-…
+ class Cell(Cell_generic):
                     jmol_file = open(jmol_name, 'r')
                     jmol_script = jmol_file.read()
                     jmol_file.close()
                     jmol_script = jmol_script.replace('defaultdirectory "', 'defaultdirectory "' + self.url_to_self() + '/')
                     jmol_file = open(jmol_name, 'w')
                     jmol_file.write(jmol_script)
                     jmol_file.close()
                 script = '<div><script>jmol_applet(%s, "%s?%d");</script></div>' % (size, url, time.time())
                 images.append(script)
             elif F.endswith('.jmol.zip'):
-…
+ class Cell(Cell_generic):
         Returns the HTML for self's output.
         INPUT:
         - ``do_print`` -- a boolean stating whether to output HTML
           for print
-…
+ class Cell(Cell_generic):
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
-…
+ class Cell(Cell_generic):
         """
         if do_print and self.cell_output_type() == 'hidden':
             return '<pre>\n</pre>'
         out_nowrap = self.output_text(0, html=True)
         out_html = self.output_html()
-…
+ class Cell(Cell_generic):
             out_wrap = out_nowrap
         else:
             out_wrap = self.output_text(ncols, html=True)
         typ = self.cell_output_type()
         if self.computing():
             cls = "cell_div_output_running"
         else:
-…
+ class Cell(Cell_generic):
             out = out_wrap + out_html
         else:
             out = out_wrap + out_nowrap + out_html
         s = top + out + '</div>'
         r = ''
-…
+ class Cell(Cell_generic):
                    r, s)
         return tbl
 ########
-…
+ class Cell(Cell_generic):
 def format_exception(s0, ncols):
     r"""
     Make it so exceptions don't appear expanded by default.
     INPUT:
+    -  ``s0`` - string
+    -  ``ncols`` - integer
+    OUTPUT: string
+    If s0 contains "notracebacks" then this function always returns s0
+    - ``s0`` - string
+    - ``ncols`` - integer
+    OUTPUT:
+    - a string
+    If s0 contains "notracebacks" then this function always returns
+    s0.
     EXAMPLES::
         sage: sagenb.notebook.cell.format_exception(sagenb.notebook.cell.TRACEBACK,80)
         '\nTraceback (click to the left of this block for traceback)\n...\nTraceback (most recent call last):'
         sage: sagenb.notebook.cell.format_exception(sagenb.notebook.cell.TRACEBACK + "notracebacks",80)
         'Traceback (most recent call last):notracebacks'
     """
     s = s0.lstrip()
+    # Add a notracebacks option -- if it is in the string then tracebacks aren't shrunk.
+    # This is currently used by the sage.server.support.help command.
+    # Add a notracebacks option -- if it is in the string then
+    # tracebacks aren't shrunk.  This is currently used by the
+    # sage.server.support.help command.
     if TRACEBACK not in s or 'notracebacks' in s:
         return s0
     if ncols > 0:
-…
+ def format_exception(s0, ncols):
         s = s.replace("exec compile(ur'","")
         s = s.replace("' + '\\n', '', 'single')", "")
     return s
 ComputeCell=Cell
 def number_of_rows(txt, ncols):
     r"""
     Returns the number of rows needed to display the string in txt if
     there are a maximum of ncols columns per row.
     EXAMPLES::
         sage: from sagenb.notebook.cell import number_of_rows
         sage: s = "asdfasdf\nasdfasdf\n"
         sage: number_of_rows(s, 8)

sagenb/notebook/interact.py

diff --git a/sagenb/notebook/interact.py b/sagenb/notebook/interact.py

  class ColorInput(InputBox):
         EXAMPLES::
             sage: sagenb.notebook.interact.ColorInput('c', Color('red')).render()
             '<table>...'
+            '...<table>...'
             """
         return html_color_selector('color-selector-%s-%s'%(self.var(),
                                                            self.cell_id()),
-…
+ def interact(f):
         sage: v = []
         sage: html('<h2>Quadratic Root Etch-a-sketch</h2>')
         <html><h2>Quadratic Root Etch-a-sketch</h2></html>
+        <html>...<h2>Quadratic Root Etch-a-sketch</h2>...</html>
         sage: @interact
         ... def _(a=[-10..10], b=[-10..10], c=[-10..10]):
         ...       f = a*x^2 + b*x + c == 0; show(f)
-…
+ def list_of_first_n(v,n):
     EXAMPLES::
+        sage: sagenb.notebook.interact.list_of_first_n(Primes(), 10)
+        sage: from itertools import takewhile
+        sage: p100 = takewhile(lambda x: x < 100, Primes())
+        sage: sagenb.notebook.interact.list_of_first_n(p100, 10)
         [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
         sage: sagenb.notebook.interact.list_of_first_n((1..5), 10)
         [1, 2, 3, 4, 5]

sagenb/notebook/notebook.py

diff --git a/sagenb/notebook/notebook.py b/sagenb/notebook/notebook.py

  USE_REFERENCE_WORKSHEET_PROCESSES = Fals
 # System libraries
 import os
 import random
 import re
+import re
 import shutil
 import socket
 import time
-…
+ class Notebook(object):
         for username in self.__users.keys():
             for w in S.worksheets(username):
                 W['%s/%s'%(username, w.id_number())] = w
         self.__worksheets = W
     def delete(self):
         """
         Delete all files related to this notebook.
         This is used for doctesting mainly. This command is obviously
         *VERY* dangerous to use on a notebook you actually care about.
         You could easily lose all data.
         EXAMPLES::
             sage: tmp = tmp_dir()
             sage: nb = sagenb.notebook.notebook.Notebook(tmp)
             sage: sorted(os.listdir(tmp))
             ['backups', 'nb2.sobj', 'objects', 'worksheets']
+            sage: tmp = tmp_dir() + '.sagenb'
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp)
+            sage: sorted(os.listdir(tmp))
+            ['home']
             sage: nb.delete()
+        Now the directory is gone.
+        ::
+        Now the directory is gone.::
             sage: os.listdir(tmp)
             Traceback (most recent call last):
             ...
-…
+ class Notebook(object):
     def system_names(self):
         return SYSTEM_NAMES
     ##########################################################
     # Users
     ##########################################################
     def create_default_users(self, passwd):
         """
         Create the default users for a notebook.
         INPUT:
         -  ``passwd`` - a string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: list(sorted(nb.users().iteritems()))
-…
+ class Notebook(object):
     def user_exists(self, username):
         """
         Return whether a user with the given ``username`` exists.
         INPUT:
         - ``username`` - a string
-…
+ class Notebook(object):
         - a bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: nb.user_exists('admin')
-…
+ class Notebook(object):
             True
         """
         return username in self.users()
     def users(self):
         """
         Return a dictionary of users in a notebook.
         OUTPUT:
         - a string:User instance dictionary
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: list(sorted(nb.users().iteritems()))
-…
+ class Notebook(object):
         """
         Return an instance of the User class given the ``username`` of a user
         in a notebook.
         INPUT:
         - ``username`` - a string
-…
+ class Notebook(object):
         - an instance of User
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: nb.user('admin')
             admin
             sage: nb.user('admin')._User__email
+            sage: nb.user('admin').get_email()
             ''
             sage: nb.user('admin')._User__password
+            sage: nb.user('admin').password()
             'aajfMKNH1hTm2'
         """
         if not isinstance(username, str) or '/' in username:
-…
+ class Notebook(object):
     def create_user_with_same_password(self, user, other_user):
         r"""
         Change the password of ``user`` to that of ``other_user``.
         INPUT:
         -  ``user`` - a string
         -  ``other_user`` - a string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('bob', 'an**d', 'bob@gmail.com', force=True)
             sage: nb.user('bob').password()
             'aa4Q6Jbx/MiUs'
-…
+ class Notebook(object):
         INPUT:
         - ``user`` - an instance of User
         OUTPUT:
         - a bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('Administrator', 'password', '', 'admin', True)
             sage: nb.add_user('RegularUser', 'password', '', 'user', True)
             sage: nb.user_is_admin('Administrator')
-…
+ class Notebook(object):
         INPUT:
         - ``username`` - a string
         OUTPUT:
         - a bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: nb.user_is_guest('guest')
-…
+ class Notebook(object):
             return self.user(username).is_guest()
         except KeyError:
             return False
     def user_list(self):
         """
         Return a list of user objects.
         OUTPUT:
         - a list of User instances
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: sorted(nb.user_list(), key=lambda k: k.username())
-…
+ class Notebook(object):
     def usernames(self):
         """
         Return a list of usernames.
         OUTPUT:
         - a list of strings
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: sorted(nb.usernames())
-…
+ class Notebook(object):
     def valid_login_names(self):
         """
         Return a list of users that can log in.
         OUTPUT:
         - a list of strings
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: nb.valid_login_names()
-…
+ class Notebook(object):
         confronted with the Sage notebook login page.  Currently, this
         returns 'admin' if that is the *only* user.  Otherwise it
         returns an empty string ('').
         OUTPUT:
         - a string - the default username.
+        - a string - the default username.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: nb.default_user()
-…
+ class Notebook(object):
         Set the accounts attribute of the server configuration to
         ``value``.  This property determines whether users can create
         new accounts.
         INPUT:
         - ``value`` - a bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.get_accounts()
             False
             sage: nb.set_accounts(True)
-…
+ class Notebook(object):
     def get_accounts(self):
         r"""
         Return whether or not users can create new accounts.
+        Return whether or not users can create new accounts.
         OUTPUT:
         - a bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.get_accounts()
             False
             sage: nb.set_accounts(True)
-…
+ class Notebook(object):
         Add a user with the given credentials.
         INPUT:
         -  ``username`` - the username
         -  ``password`` - the password
         -  ``email`` - the email address
         -  ``account_type`` - one of 'user', 'admin', or 'guest'
         -  ``force`` - a bool (default: False)
         If the method :meth:`get_accounts` returns False then user can
         only be added if ``force`` is True.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('Mark', 'password', '', force=True)
             sage: nb.user('Mark')
             Mark
-…
+ class Notebook(object):
         """
         if not self.get_accounts() and not force:
             raise ValueError, "creating new accounts disabled."
         us = self.users()
         if us.has_key(username):
             print "WARNING: User '%s' already exists -- and is now being replaced."%username
-…
+ class Notebook(object):
         # Save the user database
         self.__storage.save_users(self.users())
     def change_password(self, username, password):
         """
         Change a user's password.
         INPUT:
         - ``username`` - a string, the username
         - ``password`` - a string, the user's new password
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('Mark', 'password', '', force=True)
             sage: nb.user('Mark').password()
             'aajfMKNH1hTm2'
-…
+ class Notebook(object):
     def del_user(self, username):
         """
         Delete the given user.
         INPUT:
         - ``username`` - a string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('Mark', 'password', '', force=True)
             sage: nb.user('Mark')
             Mark
-…
+ class Notebook(object):
     def passwords(self):
         """
         Return a username:password dictionary.
         OUTPUT:
         - a string:string dictionary
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: nb.add_user('Mark', 'password', '', force=True)
-…
+ class Notebook(object):
     def user_conf(self, username):
         """
         Return a user's configuration object.
         OUTPUT:
         - an instance of Configuration.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.create_default_users('password')
             Creating default users.
             sage: config = nb.user_conf('admin')
             sage: config['max_history_length']
             sage: config['system']
+            sage: config['default_system']
             'sage'
             sage: config['autosave_interval']
             sage: config['default_pretty_print']
             False
         """
+        """
         return self.users()[username].conf()
     ##########################################################
-…
+ class Notebook(object):
         r"""
         Publish a user's worksheet.  This creates a new worksheet in
         the 'pub' directory with the same contents as ``worksheet``.
         INPUT:
         - ``worksheet`` - an instance of Worksheet
-…
+ class Notebook(object):
         - a new or existing published instance of Worksheet
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('Mark','password','',force=True)
             sage: W = nb.new_worksheet_with_title_from_text('First steps', owner='Mark')
             sage: nb.worksheet_names()
             ['Mark/0']
             sage: nb.publish_worksheet(nb.get_worksheet_with_filename('Mark/0'), 'Mark')
+            <BLANKLINE>
+            [Cell 0; in=, out=]
+            pub/1: [Cell 1; in=, out=]
             sage: sorted(nb.worksheet_names())
             ['Mark/0', 'pub/0']
+            ['Mark/0', 'pub/1']
         """
         for X in self.__worksheets.itervalues():
             if X.is_published() and X.worksheet_that_was_published() == worksheet:
-…
+ class Notebook(object):
     def empty_trash(self, username):
         """
         Empty the trash for the given user.
         INPUT:
         -  ``username`` - a string
         This empties the trash for the given user and cleans up all files
         associated with the worksheets that are in the trash.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.new_worksheet_with_title_from_text('Sage', owner='sage')
             sage: W.move_to_trash('sage')
-…
+ class Notebook(object):
     def worksheet_names(self):
         """
         Return a list of all the names of worksheets in this notebook.
         OUTPUT:
         - a list of strings.
         EXAMPLES:
+        EXAMPLES:
         We make a new notebook with two users and two worksheets,
         then list their names::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.new_worksheet_with_title_from_text('Sage', owner='sage')
             sage: nb.add_user('wstein','sage','wstein@sagemath.org',force=True)
             sage: W2 = nb.new_worksheet_with_title_from_text('Elliptic Curves', owner='wstein')
             sage: nb.worksheet_names()
             ['sage/0', 'wstein/0']
+            ['sage/0', 'wstein/1']
         """
         W = self.__worksheets.keys()
         W.sort()
-…
+ class Notebook(object):
     ##########################################################
     # Information about the pool of worksheet compute servers
     ##########################################################
+    ##########################################################
     def server_pool(self):
         return self.conf()['server_pool']
-…
+ class Notebook(object):
         ulimit = self.get_ulimit()
         from sagenb.interfaces import ProcessLimits
         # We have to parse the ulimit format to our ProcessLimits.
         # The typical format is.
+        # The typical format is.
         # '-u 400 -v 1000000 -t 3600'
         # Despite -t being cputime for ulimit, we map it to walltime,
         # since that is the only thing that really makes sense for a
-…
+ class Notebook(object):
                 if x.startswith(k): tbl[k] = int(x.split()[1].strip())
         if tbl['v'] is not None:
             tbl['v'] = tbl['v']/1000.0
         process_limits = ProcessLimits(max_vmem=tbl['v'], max_walltime=tbl['t'],
                                        max_processes=tbl['u'])
         server_pool = self.server_pool()
         if not server_pool or len(server_pool) == 0:
             return WorksheetProcess_ExpectImplementation(process_limits=process_limits)
-…
+ class Notebook(object):
             return WorksheetProcess_RemoteExpectImplementation(user_at_host=user_at_host,
                              process_limits=process_limits,
                              remote_python=python_command)
     def _python_command(self):
         """
         """
         try: return self.__python_command
         except AttributeError: pass
     ##########################################################
     # The default math software system for new worksheets for
     # a given user or the whole notebook (if username is None).
     ##########################################################
     def system(self, username=None):
         return self.user(username).conf()['default_system']
-…
+ class Notebook(object):
     # The default typeset setting for new worksheets for
     # a given user or the whole notebook (if username is None).
     ##########################################################
     # TODO -- only implemented for the notebook right now
     def pretty_print(self, username=None):
         return self.user(username).conf()['default_pretty_print']
-…
+ class Notebook(object):
         W = self.create_new_worksheet(name, username)
         W.edit_save('Log Worksheet\n' + self.user_history_text(username, maxlen=None))
         return W
     def user_history_text(self, username, maxlen=None):
         H = self.user_history(username)
         if maxlen:
-…
+ class Notebook(object):
     def export_worksheet(self, worksheet_filename, output_filename, title=None):
         """
         Export a worksheet, creating a sws file on the file system.
         INPUT:
             -  ``worksheet_filename`` - a string e.g., 'username/id_number'
             -  ``output_filename`` - a string, e.g., 'worksheet.sws'
             - ``title`` - title to use for the exported worksheet (if
-…
+ class Notebook(object):
             - ``id_number`` - nonnegative integer or None (default)
         """
         S = self.__storage
         if id_number is None:
+        if id_number is None:
             id_number = self.new_id_number(username)
         return S.load_worksheet(username, id_number)
     def new_id_number(self, username):
         """
         Find the next worksheet id for the given user.
-…
+ class Notebook(object):
         Import a worksheet with the given ``filename`` and set its
         ``owner``.  If the file extension is not txt or sws, raise a
         ValueError.
         INPUT:
         -  ``filename`` - a string
         -  ``owner`` - a string
         OUTPUT:
         -  ``worksheet`` - a newly created Worksheet instance
         EXAMPLES:
+        EXAMPLES:
         We create a notebook and import a plain text worksheet
         into it.
         ::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
             sage: name = tmp_filename() + '.txt'
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
+            sage: name = tmp_filename() + '.txt'
             sage: open(name,'w').write('foo\n{{{\n2+3\n}}}')
             sage: W = nb.import_worksheet(name, 'admin')
         W is our newly-created worksheet, with the 2+3 cell in it::
             sage: W.name()
             'foo'
             sage: W.cell_list()
             [Cell 0; in=2+3, out=]
+            [TextCell 0: foo, Cell 1; in=2+3, out=]
         """
         if not os.path.exists(filename):
             raise ValueError, "no file %s"%filename
-…
+ class Notebook(object):
             raise ValueError, "unknown extension '%s'"%ext
         self.__worksheets[W.filename()] = W
         return W
     def _import_worksheet_txt(self, filename, owner):
         r"""
         Import a plain text file as a new worksheet.
         INPUT:
         -  ``filename`` - a string; a filename that ends in .txt
         -  ``owner`` - a string; the imported worksheet's owner
         OUTPUT:
         -  a new instance of Worksheet
         EXAMPLES:
+        EXAMPLES:
         We write a plain text worksheet to a file and import it
+        using this function.
+        ::
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: name = tmp_filename() + '.txt'
+        using this function.::
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
+            sage: name = tmp_filename() + '.txt'
             sage: open(name,'w').write('foo\n{{{\na = 10\n}}}')
             sage: W = nb._import_worksheet_txt(name, 'admin'); W
             [Cell 0; in=a = 10, out=]
+            admin/0: [TextCell 0: foo, Cell 1; in=a = 10, out=]
         """
         # Open the worksheet txt file and load it in.
         worksheet_txt = open(filename).read()
-…
+ class Notebook(object):
         # Set the new worksheet to have the contents specified by that file.
         worksheet.edit_save(worksheet_txt)
         return worksheet
     def _import_worksheet_sws(self, filename, username, verbose=True):
+    def _import_worksheet_sws(self, filename, username):
         r"""
         Import an sws format worksheet into this notebook as a new
+        worksheet.  If the worksheet cannot be read, raise a
+        ValueError.
+        worksheet.
         INPUT:
         - ``filename`` - a string; a filename that ends in .sws;
            internally it must be a tar'd bz2'd file.
         - ``username`` - a string
+        - ``verbose`` - a bool (default: True) if True print some the
+           tar command used to extract the sws file.
         OUTPUT:
         - a new Worksheet instance
         EXAMPLES: We create a notebook, then make a worksheet from a plain
+        text file first.
         ::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
             sage: name = tmp_filename() + '.txt'
             sage: open(name,'w').write('foo\n{{{\n2+3\n}}}')
+        EXAMPLES:
+        We create a notebook, then make a worksheet from a plain text
+        file first.::
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
+            sage: name = tmp_filename() + '.txt'
+            sage: open(name,'w').write('{{{id=0\n2+3\n}}}')
             sage: W = nb.import_worksheet(name, 'admin')
             sage: W.filename()
             'admin/0'
+        We then export the worksheet to an sws file.
+        ::
+            sage: nb.export_worksheet(W.filename(),  'tmp.sws', verbose=False)
+        Now we import the sws.
+        ::
+            sage: nb._import_worksheet_sws('tmp.sws', 'admin', verbose=False)
+            [Cell 0; in=2+3, out=]
+        We then export the worksheet to an sws file.::
+            sage: sws = os.path.join(tmp_dir(), 'tmp.sws')
+            sage: nb.export_worksheet(W.filename(), sws)
+        Now we import the sws.::
+            sage: W = nb._import_worksheet_sws(sws, 'admin')
+            sage: nb._Notebook__worksheets[W.filename()] = W
         Yes, it's there now (as admin/2)::
             sage: nb.worksheet_names()
             ['admin/0', 'admin/2']
+            ['admin/0', 'admin/1']
         """
         id_number = self.new_id_number(username)
         worksheet = self.__storage.import_worksheet(username, id_number, filename)
-…
+ class Notebook(object):
         # support multiple worksheets with the same title very well
         # already.  So it's commented out.
         # self.change_worksheet_name_to_avoid_collision(worksheet)
         return worksheet
     def change_worksheet_name_to_avoid_collision(self, worksheet):
-…
+ class Notebook(object):
                 i += 1
             name = name + " (%s)"%i
             worksheet.set_name(name)
     ##########################################################
     # Importing and exporting worksheets to a plain text format
-…
+ class Notebook(object):
         Return HTML containing the plain text version of a worksheet.
         INPUT:
         - ``filename`` - a string; filename of a worksheet
         - ``prompts`` - a bool (default: True); whether to format the
           text for inclusion in docstrings
         OUTPUT:
         - a string - the worksheet's HTML representation
         """
         worksheet = self.get_worksheet_with_filename(filename)
-…
+ class Notebook(object):
             for W in self.__worksheets.itervalues():
                 if W.docbrowser() and W.compute_process_has_been_started():
                     W.quit_if_idle(DOC_TIMEOUT)
             return
+            return
         for W in self.__worksheets.itervalues():
             if W.compute_process_has_been_started():
                 W.quit_if_idle(timeout)
     ##########################################################
     # Worksheet HTML generation
-…
+ class Notebook(object):
         Return the HTML for a given worksheet.
         INPUT:
         - ``filename`` - a string; the worksheet's filename
         - ``do_print`` - a bool (default: False); whether this is a
           printed worksheet
         OUTPUT:
         - a string - the worksheet rendered as HTML
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: nb.worksheet_html(W.filename())
             '\n<!D...ript type="text/javascript">cell_id_list=[0];</script>\n\n\n\n\n\n    </body>\n</html>'
+            '\n<!D...Test...cell_id_list=[1]...</body>...</html>'
         """
         worksheet = self.get_worksheet_with_filename(filename)
         return template(os.path.join("html", "notebook", "worksheet.html"),
-…
+ class Notebook(object):
                  worksheet_html = worksheet.html(include_title=False, do_print=do_print),
                         do_print = do_print)
     def worksheet_list_for_public(self, username, sort='last_edited', reverse=False, search=None):
         W = [x for x in self.__worksheets.itervalues() if x.is_published() and not x.is_trashed(user)]
-…
+ class Notebook(object):
         Return HTML for the revision list of a worksheet.
         INPUT:
         - ``username`` - a string
         - ``worksheet`` - an instance of Worksheet
         OUTPUT:
-…
+ class Notebook(object):
         - a string - the HTML for the revision list
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
+            sage: W.body()
+            '\n\n{{{id=1|\n\n///\n}}}'
+            sage: W.save_snapshot('admin')
             sage: nb.html_worksheet_revision_list('admin', W)
             '\n<!D...seconds ago</span></td>\n    </tr>\n\n</table>\n\n\n    </body>\n</html>'
         """
-…
+ class Notebook(object):
         Return the HTML for a specific revision of a worksheet.
         INPUT:
         - ``username`` - a string
         - ``ws`` - an instance of Worksheet
         - ``rev`` - a string containing the key of the revision
         OUTPUT:
         - a string - the revision rendered as HTML
         """
         t = time.time() - float(rev[:-4])
         time_ago = worksheet.convert_seconds_to_meaningful_time_span(t)
         filename = ws.get_snapshot_text_filename(rev)
         txt = bz2.decompress(open(filename).read())
         W = self.scratch_worksheet()
-…
+ class Notebook(object):
                 if i < len(data)-1:
                     next_rev = data[i+1][1]
                 break
         return template(os.path.join("html", "notebook", "specific_revision.html"),
                         worksheet = ws, worksheet_filename = ws.filename(),
                         username = username, rev = rev, prev_rev = prev_rev,
-…
+ class Notebook(object):
         Return the HTML for the "share" page of a worksheet.
         INPUT:
         - ``username`` - a string
         - ``worksheet`` - an instance of Worksheet
         OUTPUT:
         - string - the share page's HTML representation
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: nb.html_share(W, 'admin')
             '\n<!D...span class="username">Sage Users:</span>\n<span class="users">\n    \n</span>\n\n\n\n    </body>\n</html>'
-…
+ class Notebook(object):
         Return the HTML for the download or delete datafile page.
         INPUT:
         - ``username`` - a string
         - ``ws`` - an instance of Worksheet
         - ``filename`` - a string; the name of the file
         OUTPUT:
         - a string - the page rendered as HTML
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: nb.html_download_or_delete_datafile(W, 'admin', 'bar')
             '\n<!D...ploaded to this worksheet.</p>\n\n<hr class="usercontrol" />\n\n\n\n\n    </body>\n</html>'
-…
+ class Notebook(object):
         worksheets = self.get_worksheets_with_viewer(username)
         active_worksheets = [worksheet for worksheet in worksheets if worksheet.is_active(username)]
         sort_worksheet_list(active_worksheets, 'name', False)
         ext = os.path.splitext(filename)[1].lower()
         file_is_image, file_is_text = False, False
         text_file_content = ""
         if ext in ['.png', '.jpg', '.gif']:
             file_is_image = True
         if ext in ['.txt', '.tex', '.sage', '.spyx', '.py', '.f', '.f90', '.c']:
-…
+ class Notebook(object):
     ##########################################################
     # Accessing all worksheets with certain properties.
+    # Accessing all worksheets with certain properties.
     ##########################################################
     def get_all_worksheets(self):
         return [x for x in self.__worksheets.itervalues() if not x.owner() in ['_sage_', 'pub']]
     def get_worksheets_with_collaborator(self, user):
         if self.user_is_admin(user): return self.get_all_worksheets()
+        if self.user_is_admin(user): return self.get_all_worksheets()
         return [w for w in self.__worksheets.itervalues() if w.user_is_collaborator(user)]
     def get_worksheet_names_with_collaborator(self, user):
-…
+ class Notebook(object):
         return [w for w in self.get_worksheets_with_owner(owner) if w.user_is_viewer(user)]
     def get_worksheet_names_with_viewer(self, user):
         if self.user_is_admin(user): return [W.name() for W in self.get_all_worksheets()]
+        if self.user_is_admin(user): return [W.name() for W in self.get_all_worksheets()]
         return [W.name() for W in self.get_worksheets_with_viewer(user) if not W.docbrowser()]
     def get_worksheet_with_name(self, name):
-…
+ class Notebook(object):
         """
         Get the worksheet with the given filename.  If there is no
         such worksheet, raise a ``KeyError``.
         INPUT:
         - ``filename`` - a string
-…
+ class Notebook(object):
         Return the HTML for the debug window.
         OUTPUT:
         - a string - the debug window rendered as HTML
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.html_debug_window()
             "\n<div class='debug_window'>...</div>"
         """
         return template(os.path.join("html", "notebook", "debug_window.html"))
     def html_plain_text_window(self, worksheet, username):
         r"""
         Return HTML for the window that displays a plain text version
-…
+ class Notebook(object):
         - a string - the plain text window rendered as HTML
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: nb.html_plain_text_window(W, 'admin')
             '\n<!D...>\n\n<pre class="plaintext" id="cell_intext" name="textfield"></pre>\n\n\n    </body>\n</html>'
         """
         plain_text = worksheet.plain_text(prompts=True, banner=False)
         plain_text = escape(plain_text).strip()
         return template(os.path.join("html", "notebook", "plain_text_window.html"),
                         worksheet = worksheet,
                         worksheet_filename = worksheet.filename(),
                         username = username, plain_text = plain_text,
                         JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
     def html_edit_window(self, worksheet, username):
         r"""
         Return HTML for a window for editing ``worksheet``.
         INPUT:
         - ``username`` - a string containing the username
         - ``worksheet`` - a Worksheet instance
         OUTPUT:
         - a string - the editing window's HTML representation
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: nb.html_edit_window(W, 'admin')
             '\n<!D...Test\nsystem:sage\n\n{{{id=0|\n\n///\n}}}</textarea>\n</form>\n\n\n    </body>\n</html>'
+            '\n<!D...Test...\n\n{{{id=1|\n\n///\n}}}</textarea>\n</form>\n\n\n    </body>\n</html>'
         """
         text = worksheet.edit_text()
         text = escape(text)
         n_lines = text.count("\n")+1
         return template(os.path.join("html", "notebook", "edit_window.html"),
                         worksheet = worksheet,
                         worksheet_filename = worksheet.filename(),
                         username = username, text = text, n_lines = n_lines,
                         JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
     def html_beforepublish_window(self, worksheet, username):
         r"""
         Return HTML for the warning and decision page displayed prior
         to publishing the given worksheet.
         INPUT:
         - ``worksheet`` - an instance of Worksheet
         - ``username`` - a string
         OUTPUT:
-…
+ class Notebook(object):
         - a string - the pre-publication page rendered as HTML
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: nb.html_beforepublish_window(W, 'admin')
             '\n<!D...publish when changes are made</form></span>\n<br /><br /><br />\n\n\n    </body>\n</html>'
-…
+ class Notebook(object):
                         worksheet_filename = worksheet.filename(),
                         username = username,
                         JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
     def html_afterpublish_window(self, worksheet, username, url, dtime):
         r"""
         Return HTML for a given worksheet's post-publication page.
         INPUT:
         - ``worksheet`` - an instance of Worksheet
         - ``username`` - a string
         - ``url`` - a string representing the URL of the published
           worksheet
         - ``dtime`` - an instance of time.struct_time representing the
           publishing time
         OUTPUT:
         - a string - the post-publication page rendered as HTML
         """
         from time import strftime
         time = strftime("%B %d, %Y %I:%M %p", dtime)
         return template(os.path.join("html", "notebook", "afterpublish_window.html"),
                         worksheet = worksheet,
                         worksheet_filename = worksheet.filename(),
-…
+ class Notebook(object):
         Return HTML for the "Upload Data" window.
         INPUT:
         - ``worksheet`` - an instance of Worksheet
         - ``username`` - a string
         OUTPUT:
-…
+ class Notebook(object):
         - a string - the HTML representation of the data upload window
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: nb.html_upload_data_window(W, 'admin')
             '\n<!D...orksheet_menu" value="Upload File" onClick="form.submit()...r />\n</div>\n\n\n    </body>\n</html>'
+            '\n<!D...orksheet_menu" value="Upload or Create Data File" onClick="form.submit()...r />\n</div>\n\n\n    </body>\n</html>'
         """
         return template(os.path.join("html", "notebook", "upload_data_window.html"),
                         worksheet = ws, worksheet_filename = ws.filename(),
-…
+ class Notebook(object):
         Return the HTML for a worksheet's index page.
         INPUT:
         - ``worksheet_filename`` - a string (default: None)
         - ``username`` - a string (default: 'guest')
         - ``show_debug`` - a bool (default: False)
         - ``admin`` - a bool (default: False)
         OUTPUT:
-…
+ class Notebook(object):
         - a string - the worksheet rendered as HTML
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: nb.html(W.filename(), 'admin')
             '\n<!D...ipt type="text/javascript">worksheet_locked=false;</script>\n\n\n\n    </body>\n</html>'
-…
+ class Notebook(object):
         template_page = os.path.join("html", "notebook", "index.html")
         if W.docbrowser():
             template_page = os.path.join("html", "notebook", "doc_page.html")
         return template(template_page, worksheet = W,
                         worksheet_filename = W.filename(),
                         worksheet_html = W.html(), notebook = self,
-…
+ class Notebook(object):
     def html_doc(self, username):
         r"""
         Return the HTML for the a documentation page.
         INPUT:
         - ``username`` - a string
         OUTPUT:
         - a string - the doc page rendered as HTML
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: nb.html_doc('admin')
             '\n<!D...c Documentation</a><br /><br />\n        <a href="/help/">Sage Notebook Howto...   </body>\n</html>'
-…
+ class Notebook(object):
         return template(os.path.join("html", "notebook", "doc.html"),
                         username = username,
                         JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
 ####################################################################
-…
+ def load_notebook(dir, address=None, por
     """
     Load and return a notebook from a given directory.  Create a new
     one in that directory, if one isn't already there.
     INPUT:
     -  ``dir`` - a string that defines a directory name
     -  ``address`` - the address the server listens at
     -  ``port`` - the port the server listens on
     -  ``secure`` - whether the notebook is secure
     OUTPUT:
-…
+ def load_notebook(dir, address=None, por
                 raise KeyboardInterrupt, "Interrupted notebook migration.  Delete the directory '%s' and try again."%(os.path.abspath(dir+'.sagenb'))
             return nb
         dir += '.sagenb'
     dir = make_path_relative(dir)
     nb = Notebook(dir)
     nb.address = address
-…
+ def migrate_old_notebook_v1(dir):
     """
     nb_sobj = os.path.join(dir, 'nb.sobj')
     old_nb = cPickle.loads(open(nb_sobj).read())
     ######################################################################
     # Tell user what is going on and make a backup
     ######################################################################
     print ""
     print "*"*80
     print "*"
+    print "*"
     print "* The Sage notebook at"
     print "*"
+    print "*"
     print "*      '%s'"%os.path.abspath(dir)
     print "*"
+    print "*"
     print "* will be upgraded to a new format and stored in"
     print "*"
     print "*      '%s.sagenb'."%os.path.abspath(dir)
-…
+ def migrate_old_notebook_v1(dir):
     # Create new notebook
     new_nb = Notebook(dir+'.sagenb')
     # Define a function for transfering the attributes of one object to another.
+    # Define a function for transfering the attributes of one object to another.
     def transfer_attributes(old, new, attributes):
         for attr_old, attr_new in attributes:
             if hasattr(old, attr_old):
                 setattr(new, attr_new,  getattr(old, attr_old))
     # Transfer all the notebook attributes to our new notebook object
     new_nb.conf().confs = old_nb.conf().confs
     for t in ['pretty_print', 'server_pool', 'ulimit', 'system']:
         if hasattr(old_nb, '_Notebook__' + t):
             new_nb.conf().confs[t] = getattr(old_nb, '_Notebook__' + t)
     # Now update the user data from the old notebook to the new one:
     print "Migrating %s user accounts..."%len(old_nb.users())
     users = new_nb.users()
-…
+ def migrate_old_notebook_v1(dir):
         # Fix the __conf field, which is also an instance of a class
         new_user.conf().confs = old_user.conf().confs
         users[new_user.username()] = new_user
     ######################################################################
     # Set the worksheets of the new notebook equal to the ones from
     # the old one.
     ######################################################################
     ######################################################################
     def migrate_old_worksheet(old_worksheet):
         """
         Migrates an old worksheet to the new format.
+        Migrates an old worksheet to the new format.
         """
         old_ws_dirname = old_ws._Worksheet__filename.partition(os.path.sep)[-1]
         new_ws = new_nb.worksheet(old_ws.owner(), old_ws_dirname)
-…
+ def migrate_old_notebook_v1(dir):
                 if isinstance(user,str):
                     # There was a bug in the old notebook where sometimes the
                     # user was the *module* "user", so we don't include that
                     # invalid data.
+                    # invalid data.
                     tags[user] = [val]
         except AttributeError:
             pass
-…
+ def migrate_old_notebook_v1(dir):
         ws_pub = old_ws.worksheet_that_was_published().filename().split('/')
         ws_pub = (ws_pub[0],int(ws_pub[1]))
         obj = {'name':old_ws.name(), 'system':old_ws.system(),
                'viewers':old_ws.viewers(), 'collaborators':old_ws.collaborators(),
                'pretty_print':old_ws.pretty_print(), 'ratings':old_ws.ratings(),
-…
+ def migrate_old_notebook_v1(dir):
+               }
         new_ws.reconstruct_from_basic(obj)
         base = os.path.join(dir, 'worksheets', old_ws.filename())
         worksheet_file = os.path.join(base, 'worksheet.txt')
         if os.path.exists(worksheet_file):
-…
+ def migrate_old_notebook_v1(dir):
                 shutil.copytree(old_ws.cells_directory(), dest)
         except Exception, msg:
             print msg
         return new_ws
     worksheets = {}
     num_worksheets = len(old_nb._Notebook__worksheets)
     print "Migrating (at most) %s worksheets..."%num_worksheets
-…
+ def make_path_relative(dir):
     INPUT:
     - ``dir`` - a string containing, e.g., a directory name
+    - ``dir`` - a string containing, e.g., a directory name
     OUTPUT:
-…
+ def make_path_relative(dir):
 ##########################################################
 # Misc
 ##########################################################
+##########################################################
 def clean_name(name):
     return ''.join([x if (x.isalnum() or x == '_') else '_' for x in name])
-…
+ def sort_worksheet_list(v, sort, reverse
     Sort a given list on a given key, in a given order.
     INPUT:
     - ``sort`` - a string; 'last_edited', 'owner', 'rating', or 'name'
     - ``reverse`` - a bool; if True, reverse the order of the sort.
     OUTPUT:

sagenb/notebook/notebook_object.py

diff --git a/sagenb/notebook/notebook_object.py b/sagenb/notebook/notebook_object.py

  def test_notebook(admin_passwd, secure=F
         sage: passwd = str(randint(1,1<<128))
         sage: nb = test_notebook(passwd, address='localhost', port=8060)
         sage: import urllib
         sage: h = urllib.urlopen('https://localhost:8060')
+        sage: h = urllib.urlopen('http://localhost:8060')
         sage: homepage = h.read()
         sage: h.close()
         sage: 'html' in homepage
-…
+ def test_notebook(admin_passwd, secure=F
         except pexpect.EOF:
             pass
         p.close(force=True)
         shutil.rmtree(nb.directory())
+        shutil.rmtree(nb._dir)
     p.dispose = dispose
     if verbose:
         print "Notebook started."

sagenb/notebook/twist.py

diff --git a/sagenb/notebook/twist.py b/sagenb/notebook/twist.py

  TESTS:
 It is important that this file never be imported by default on
 startup by Sage, since it is very expensive, since importing Twisted
 is expensive. This doctest verifies that twist.py isn't imported on
+startup.
+::
+startup.::
     sage: os.system("sage -startuptime | grep twisted\.web2 1>/dev/null") != 0  # !=0 means not found
     True
-…
+ class Worksheet_do_upload_data(Worksheet
             if not os.path.isfile(dest):
                 return HTMLResponse(stream=message('Suspicious filename "%s" encountered uploading file.%s' % (name, backlinks), worksheet_url))
             os.unlink(dest)
         response = http.RedirectResponse(worksheet_url + '/datafile?name=%s' % name)
         if url != '':
-…
+ class SettingsPage(resource.PostableReso
         autosave = int(request.args.get('autosave', [0])[0]) * 60
         if autosave:
             nu['autosave_interval'] = autosave
             redirect_to_home = True
+            redirect_to_home = True
         old = request.args.get('Oldpass', [None])[0]
         new = request.args.get('Newpass', [None])[0]
-…
+ def render_worksheet_list(args, pub, use
     -  ``username`` - the user whose worksheets we are
        listing
     OUTPUT:
+    OUTPUT:
     a string
     """
-…
+ class EmptyTrash(resource.Resource):
         This twisted resource empties the trash of the current user when it
         is rendered.
+        EXAMPLES:
+        We create an instance of this resource.
+        ::
+        EXAMPLES:
+        We create an instance of this resource.::
             sage: import sagenb.notebook.twist
             sage: E = sagenb.notebook.twist.EmptyTrash('sage'); E
-…
+ class EmptyTrash(resource.Resource):
         Rendering this resource (1) empties the trash, and (2) returns a
         message.
         EXAMPLES:
+        EXAMPLES:
         We create a notebook with a worksheet, put it in the
         trash, then empty the trash by creating and rendering this
+        worksheet.
+        ::
+            sage: n = sagenb.notebook.notebook.Notebook('notebook-test')
+        worksheet.::
+            sage: n = sagenb.notebook.notebook.load_notebook('notebook-test.sagenb')
             sage: n.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = n.new_worksheet_with_title_from_text('Sage', owner='sage')
             sage: W.move_to_trash('sage')
-…
+ class EmptyTrash(resource.Resource):
             sage: sagenb.notebook.twist.notebook = n
             sage: E = sagenb.notebook.twist.EmptyTrash('sage'); E
             <sagenb.notebook.twist.EmptyTrash object at ...>
+            sage: E.render(None)
+            <twisted.web2.http.Response code=200, streamlen=...>
+            sage: from sagenb.notebook.twist import HTMLResponse
+            sage: ctx = HTMLResponse(stream = 'foo')
+            sage: ctx.headers.addRawHeader('referer', 'over there')
+            sage: E.render(ctx)
+            <RedirectResponse 301 Document moved to over there.>
         Finally we verify that the trashed worksheet is gone::
-…
+ class JSMath_js(resource.Resource):
         s = template(os.path.join('js', 'jsmath.js'),
                      jsmath_macros = jsmath_macros,
                      jsmath_image_fonts = jsmath_image_fonts)
         return http.Response(stream=s)
 class Main_js(resource.Resource):
-…
+ import re
 re_valid_username = re.compile('[a-z|A-Z|0-9|_|.|@]*')
 def is_valid_username(username):
     r"""
+    Returns True if and only if ``username`` is valid, i.e., between 3
+    and 64 characters long. You may only use letters, numbers,
+    underscores, @, and dots.
+    Returns whether a candidate username is valid.  It must contain
+    between 3 and 65 of these characters: letters, numbers,
+    underscores, @, and/or dots ('.').
+    INPUT:
+    - ``username`` - a string; the candidate username
+    OUTPUT:
+    - a boolean
     EXAMPLES::
         sage: from sagenb.notebook.twist import is_valid_username
-    ``username`` must start with a letter
-    ::
         sage: is_valid_username('mark10')
         True
         sage: is_valid_username('10mark')
         False
+    ``username`` must be between 4 and 32 characters long
+    ::
+        sage: is_valid_username('bob')
+        sage: is_valid_username('me')
         False
         sage: is_valid_username('I_love_computer_science_and_maths') #33 characters long
+        sage: is_valid_username('abcde' * 13)
         False
-    ``username`` must not have more than one dot (.)
-    ::
-        sage: is_valid_username('david.andrews')
-        True
-        sage: is_valid_username('david.m.andrews')
-        False
-        sage: is_valid_username('math125.TA.5')
-        False
-    ``username`` must not have any spaces
-    ::
         sage: is_valid_username('David Andrews')
         False
         sage: is_valid_username('David M. Andrews')
         False
-    ::
         sage: is_valid_username('sarah_andrews')
         True
-    ::
         sage: is_valid_username('TA-1')
         False
         sage: is_valid_username('math125-TA')
         False
-    ::
         sage: is_valid_username('dandrews@sagemath.org')
         False
+        True
     """
     import string
-…
+ class LoginResourceClass(resource.Resour
         template_dict = {'accounts': notebook.get_accounts(),
                          'default_user': notebook.default_user(),
                          'recovery': notebook.conf()['email'],
                          'sage_version':SAGE_VERSION}
+                         'sage_version':SAGE_VERSION}
         return HTMLResponse(stream=template(os.path.join('html', 'login.html'), **template_dict))
     def childFactory(self, request, name):
-…
+ class FailedToplevel(Toplevel):
                              'default_user': self.username,
                              'password_error': True,
                              'recovery': notebook.conf()['email'],
                              'sage_version':SAGE_VERSION}
+                             'sage_version':SAGE_VERSION}
             return HTMLResponse(stream=template(os.path.join('html', 'login.html'), **template_dict))
         elif self.problem == 'suspended':
             return HTMLResponse(stream = message("Your account is currently suspended."))

sagenb/notebook/worksheet.py

diff --git a/sagenb/notebook/worksheet.py b/sagenb/notebook/worksheet.py

<

  AUTHORS:
 import base64, bz2, calendar, copy, os, re, shutil, string, time, traceback
 # General sage library code
 from sagenb.misc.misc import (cython, load, save,
+from sagenb.misc.misc import (cython, load, save,
                               alarm, cancel_alarm, verbose, DOT_SAGENB, walltime,
                               set_restrictive_permissions,
                               set_permissive_permissions)
-…
+ from sagenb.interfaces import (Worksheet
                                WorksheetProcess_ReferenceImplementation,
                                WorksheetProcess_RemoteExpectImplementation)
 import sagenb.misc.support  as support
 # Imports specifically relevant to the sage notebook
-…
+ SAGE_END   = SC + 'e'
 SAGE_ERROR = SC + 'r'
 # Integers that define which folder this worksheet is in
 # relative to a given user.
+# relative to a given user.
 ARCHIVED = 0
 ACTIVE   = 1
 TRASH    = 2
-…
+ all_worksheet_processes = []
 def update_worksheets():
     """
     Iterate through and "update" all the worksheets.  This is needed for things like
     wall timeouts.
+    Iterate through and "update" all the worksheets.  This is needed
+    for things like wall timeouts.
     """
     for S in all_worksheet_processes:
         S.update()
-…
+ def worksheet_filename(name, owner):
     """
     Return the relative directory name of this worksheet with given
     name and owner.
     INPUT:
     -  ``name`` - string, which may have spaces and funny
        characters, which are replaced by underscores.
     -  ``owner`` - string, with no spaces or funny
        characters
     OUTPUT: string
     EXAMPLES::
         sage: sagenb.notebook.worksheet.worksheet_filename('Example worksheet 3', 'sage10')
         'sage10/Example_worksheet_3'
         sage: sagenb.notebook.worksheet.worksheet_filename('Example#%&! work\\sheet 3', 'sage10')
-…
+ def Worksheet_from_basic(obj, notebook_w
            stores worksheets, i.e., nb.worksheet_directory().
     OUTPUT:
         - a worksheet
     EXAMPLES::
             sage: import sagenb.notebook.worksheet
             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
+            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
             sage: _=W.new_cell_after(0); B = W.basic()
             sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, '')
+            sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, tmp_dir())
             sage: W0.basic() == B
             True
     """
-…
+ class Worksheet(object):
                  auto_publish=False, create_directories=True):
         """
         Create and initialize a new worksheet.
         INPUT:
         -  ``name`` - string; the name of this worksheet
         - ``id_number`` - Integer; name of the directory in which the
            worksheet's data is stored
         -  ``notebook_worksheet_directory`` - string; the
            directory in which the notebook object that contains this worksheet
            stores worksheets, i.e., nb.worksheet_directory().
         -  ``system`` - string; 'sage', 'gp', 'singular', etc.
            - the math software system in which all code is evaluated by
            default
         -  ``owner`` - string; username of the owner of this
            worksheet
         -  ``docbrowser`` - bool (default: False); whether this
            is a docbrowser worksheet
         -  ``pretty_print`` - bool (default: False); whether
            all output is pretty printed by default.
-…
+ class Worksheet(object):
           creates various files and directories where data will be
           stored.  This option is here only for the
           migrate_old_notebook method in notebook.py
         EXAMPLES: We test the constructor via an indirect doctest::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Test', 'admin')
             sage: W
             admin/0: [Cell 0; in=, out=]
+            admin/0: [Cell 1; in=, out=]
         """
         if name is None:
             # A fresh worksheet
-…
+ class Worksheet(object):
         # state sequence number, used for sync
         self.__state_number = 0
         # Initialize the cell id counter.
         self.__next_id = 0
-…
+ class Worksheet(object):
         EXAMPLES::
             sage: from sagenb.notebook.worksheet import Worksheet
             sage: W = Worksheet('test', 2, '', owner='sageuser')
+            sage: W = Worksheet('test', 2, tmp_dir(), owner='sageuser')
             sage: W.id_number()
             sage: type(W.id_number())
-…
+ class Worksheet(object):
         configuration of this worksheet, except the actual cells and
         the data files in the DATA directory and images and other data
         in the individual cell directories.
         EXAMPLES::
             sage: import sagenb.notebook.worksheet
             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', owner='sage')
+            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), owner='sage')
             sage: sorted((W.basic().items()))
             [('auto_publish', False),
              ('collaborators', []),
              ('id_number', 0),
              ('last_change', ('sage', ...)),
              ('name', 'test'),
              ('owner', 'sage'),
              ('pretty_print', False),
              ('published_id_number', None),
              ('ratings', []),
              ('system', None),
              ('tags', {}),
              ('viewers', []),
              ('worksheet_that_was_published', None)]
+              ('collaborators', []),
+              ('id_number', 0),
+              ('last_change', ('sage', ...)),
+              ('name', 'test'),
+              ('owner', 'sage'),
+              ('pretty_print', False),
+              ('published_id_number', None),
+              ('ratings', []),
+              ('system', None),
+              ('tags', {'sage': [1]}),
+              ('viewers', []),
+              ('worksheet_that_was_published', ('sage', 0))]
         """
         try:
             published_id_number = int(os.path.split(self.__published_version)[1])
-…
+ class Worksheet(object):
             ws_pub = self.__worksheet_came_from
         except AttributeError:
             ws_pub = (self.owner(), self.id_number())
         d = {#############
              # basic identification
              'name':self.name(),
-…
+ class Worksheet(object):
              # worksheet.  Otherwise ws_pub is None.
              'worksheet_that_was_published':ws_pub,
              # Whether or not this worksheet should automatically be
              # republished when changed.
+             # republished when changed.
              'auto_publish':self.is_auto_publish(),
              # Appearance: e.g., whether to pretty print this
-…
+ class Worksheet(object):
               ``id_number`` is a key of obj; otherwise not.
         EXAMPLES::
             sage: import sagenb.notebook.worksheet
             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
+            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
             sage: W.new_cell_after(0)
             Cell 1; in=, out=
             sage: b = W.basic()
             sage: W0 = sagenb.notebook.worksheet.Worksheet()
             sage: W0.reconstruct_from_basic(b,'')
+            sage: W0.reconstruct_from_basic(b, tmp_dir())
             sage: W0.basic() == W.basic()
             True
         """
-…
+ class Worksheet(object):
     def __cmp__(self, other):
         """
         We compare two worksheets.
         INPUT:
         -  ``self, other`` - worksheets
         OUTPUT:
         -  ``-1,0,1`` - comparison is on the underlying
            file names.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W2 = nb.create_new_worksheet('test2', 'admin')
             sage: W1 = nb.create_new_worksheet('test1', 'admin')
             sage: cmp(W1, W2)
-…
+ class Worksheet(object):
         r"""
         Return string representation of this worksheet, which is simply the
         string representation of the underlying list of cells.
         OUTPUT: string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('test1', 'admin')
             sage: W.__repr__()
             'admin/0: [Cell 0; in=, out=]'
             sage: W.edit_save('Sage\n{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
+            'admin/0: [Cell 1; in=, out=]'
+            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
             sage: W.__repr__()
             'admin/0: [Cell 0; in=2+3, out=\n5, Cell 10; in=2+8, out=\n10]'
         """
-…
+ class Worksheet(object):
     def __len__(self):
         r"""
         Return the number of cells in this worksheet.
         OUTPUT: int
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('test1', 'admin')
             sage: len(W)
             sage: W.edit_save('Sage\n{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
+            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
             sage: len(W)
         """
-…
+ class Worksheet(object):
     def docbrowser(self):
         """
         Return True if this is a docbrowser worksheet.
         OUTPUT: bool
         EXAMPLES: We first create a standard worksheet for which docbrowser
         is of course False::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('test1', 'admin')
             sage: W.docbrowser()
             False
         We create a worksheet for which docbrowser is True::
             sage: W = nb.create_new_worksheet('docs', 'admin', docbrowser=True)
             sage: W.docbrowser()
             True
-…
+ class Worksheet(object):
         """
         Return a (reference to the) list of the collaborators who can also
         view and modify this worksheet.
         OUTPUT: list
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('test1', 'admin')
             sage: C = W.collaborators(); C
             []
-…
+ class Worksheet(object):
         except AttributeError:
             self.__collaborators = []
             return self.__collaborators
     def collaborator_names(self, max=None):
         """
         Returns a string of the non-owner collaborators on this worksheet.
         INPUT:
         -  ``max`` - an integer. If this is specified, then
            only max number of collaborators are shown.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('test1', 'admin')
             sage: C = W.collaborators(); C
             []
-…
+ class Worksheet(object):
         """
         Set the list of collaborators to those listed in the list v of
         strings.
         INPUT:
         -  ``v`` - a list of strings
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('test1', 'admin')
             sage: W.set_collaborators(['sage', 'admin', 'hilbert', 'sage'])
         Note that repeats are not added multiple times and admin - the
         owner - isn't added::
             sage: W.collaborators()
             ['hilbert', 'sage']
         """
-…
+ class Worksheet(object):
     def viewers(self):
         """
         Return list of viewers of this worksheet.
         OUTPUT:
         -  ``list`` - of string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('test1', 'admin')
-…
+ class Worksheet(object):
     def viewer_names(self, max=None):
         """
         Returns a string of the non-owner viewers on this worksheet.
         INPUT:
         -  ``max`` - an integer. If this is specified, then
            only max number of viewers are shown.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('test1', 'admin')
             sage: C = W.viewers(); C
             []
-…
+ class Worksheet(object):
         Delete data from this worksheet this is specific to a certain
         notebook. This means deleting the attached files, collaborators,
         and viewers.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('test1', 'admin')
             sage: W.add_viewer('hilbert')
-…
+ class Worksheet(object):
         self.__attached = {}
         self.__collaborators = [self.owner()]
         self.__viewers = []
     def name(self):
         """
         Return the name of this worksheet.
         OUTPUT: string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.name()
             'A Test Worksheet'
-…
+ class Worksheet(object):
     def set_name(self, name):
         """
         Set the name of this worksheet.
         INPUT:
         -  ``name`` - string
         EXAMPLES: We create a worksheet and change the name::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.set_name('A renamed worksheet')
             sage: W.name()
-…
+ class Worksheet(object):
         r"""
         Set this worksheet filename (actually directory) by getting the
         owner from the pre-stored owner via ``self.owner()``.
         INPUT:
         -  ``nm`` - string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.filename()
             'admin/0'
-…
+ class Worksheet(object):
     def set_filename(self, filename):
         """
         Set the worksheet filename (actually directory).
         INPUT:
         -  ``filename`` - string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.filename()
             'admin/0'
-…
+ class Worksheet(object):
         """
         old_filename = self.__filename
         self.__filename = filename
         self.__dir = os.path.join(self.notebook().worksheet_directory(), filename)
+        self.__dir = os.path.join(self.notebook()._dir, filename)
         self.notebook().change_worksheet_key(old_filename, filename)
     def filename(self):
         """
         Return the filename (really directory) where the files associated
         to this worksheet are stored.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.filename()
             'admin/0'
             sage: sorted(os.listdir(nb.directory() + '/worksheets/' + W.filename()))
             ['cells', 'snapshots']
+            sage: os.path.isdir(os.path.join(nb._dir, 'home', W.filename()))
+            True
         """
         return self.__filename
-…
+ class Worksheet(object):
         """
         Return the part of the worksheet filename after the last /, i.e.,
         without any information about the owner of this worksheet.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.filename_without_owner()
             '0'
-…
+ class Worksheet(object):
         """
         Return the full path to the directory where this worksheet is
         stored.
         OUTPUT: string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.directory()
             '.../worksheets/admin/0'
+            '.../home/admin/0'
         """
         return self.__dir
     def data_directory(self):
         """
         Return path to directory where worksheet data is stored.
         OUTPUT: string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.data_directory()
             '.../worksheets/admin/0/data'
+            '.../home/admin/0/data'
         """
         d = os.path.join(self.directory(), 'data')
         if not os.path.exists(d):
-…
+ class Worksheet(object):
         """
         Return a list of the file names of files in the worksheet data
         directory.
         OUTPUT: list of strings
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.attached_data_files()
             []
-…
+ class Worksheet(object):
         """
         Return the directory in which the cells of this worksheet are
         evaluated.
         OUTPUT: string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.cells_directory()
             '.../worksheets/admin/0/cells'
+            '.../home/admin/0/cells'
         """
         path = os.path.join(self.directory(), 'cells')
         if not os.path.exists(path):
-…
+ class Worksheet(object):
     def notebook(self):
         """
         Return the notebook that contains this worksheet.
         OUTPUT: a Notebook object.
         EXAMPLES: This really returns the Notebook object that is set as a
+        global variable of the twist module.
+        ::
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+        global variable of the twist module.::
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.notebook()
             <...sagenb.notebook.notebook.Notebook...>
-…
+ class Worksheet(object):
         """
         Return the math software system in which by default all input to
         the notebook is evaluated.
         OUTPUT: string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.system()
             'sage'
-…
+ class Worksheet(object):
         Sage installed to running a server from the same directory
         without Sage installed.   We might as well support this.
+        OUTPUT:
+            - integer
+        OUTPUT: integer
         """
         S = self.system()
         names = self.notebook().system_names()
-…
+ class Worksheet(object):
         """
         Set the math software system in which input is evaluated by
         default.
         INPUT:
         -  ``system`` - string (default: 'sage')
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.set_system('magma')
             sage: W.system()
-…
+ class Worksheet(object):
     def pretty_print(self):
         """
         Return True if output should be pretty printed by default.
         OUTPUT:
         -  ``bool`` - True of False
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.pretty_print()
             False
             sage: W.set_pretty_print('true')
             sage: W.pretty_print()
             True
+            sage: W.quit()
+            sage: nb.delete()
         """
         try:
             return self.__pretty_print
-…
+ class Worksheet(object):
     def set_pretty_print(self, check='false'):
         """
         Set whether or not output should be pretty printed by default.
         INPUT:
         -  ``check`` - string (default: 'false'); either 'true'
            or 'false'.
         .. note::
            The reason the input is a string and lower case instead of
-…
+ class Worksheet(object):
            JavaScript. (And, Jason Grout wrote this and didn't realize
            how unpythonic this design is - it should be redone to use
            True/False.)
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
             sage: W.set_pretty_print('false')
             sage: W.pretty_print()
-…
+ class Worksheet(object):
             sage: W.set_pretty_print('true')
             sage: W.pretty_print()
             True
+            sage: W.quit()
+            sage: nb.delete()
         """
         if check == 'false':
             check=False
-…
+ class Worksheet(object):
             check=True
         self.__pretty_print = check
         self.eval_asap_no_output("pretty_print_default(%r)"%(check))
     ##########################################################
     # Publication
     ##########################################################
     def is_auto_publish(self):
         """
         Returns True if this worksheet should be automatically published.
+        Returns True if this worksheet should be automatically published.
         """
         try:
+        try:
             return self.__autopublish
         except AttributeError:
             self.__autopublish = False
             return False
     def set_auto_publish(self, x):
         self.__autopublish = x
     def is_published(self):
         """
         Return True if this worksheet is a published worksheet.
         OUTPUT:
         -  ``bool`` - whether or not owner is 'pub'
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.is_published()
             False
-…
+ class Worksheet(object):
         Return owner and id_number of the worksheet that was published
         to get this worksheet, if this worksheet was
         published. Otherwise just return this worksheet.
         OUTPUT: Worksheet
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.worksheet_that_was_published() is W
             True
-        ::
             sage: S = nb.publish_worksheet(W, 'admin')
             sage: S.worksheet_that_was_published() is S
             False
-…
+ class Worksheet(object):
             return self.notebook().get_worksheet_with_filename('%s/%s'%self.__worksheet_came_from)
         except Exception:  # things can go wrong (especially with old migrated
                            # Sage notebook servers!), but we don't want such
                            # problems to crash the notebook server.
+                           # problems to crash the notebook server.
             return self
     def publisher(self):
         """
         Return username of user that published this worksheet.
         OUTPUT: string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: S = nb.publish_worksheet(W, 'admin')
             sage: S.publisher()
-…
+ class Worksheet(object):
         """
         Return True if username is the username of the publisher of this
         worksheet, assuming this worksheet was published.
         INPUT:
         -  ``username`` - string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: P = nb.publish_worksheet(W, 'admin')
             sage: P.is_publisher('hearst')
-…
+ class Worksheet(object):
     def has_published_version(self):
         """
         Return True if there is a published version of this worksheet.
         OUTPUT: bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: P = nb.publish_worksheet(W, 'admin')
             sage: P.has_published_version()
-…
+ class Worksheet(object):
         """
         Set the published version of this worksheet to be the worksheet
         with given filename.
         INPUT:
         -  ``filename`` - string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: P = nb.publish_worksheet(W, 'admin')  # indirect test
             sage: W._Worksheet__published_version
+            'pub/1'
+            sage: W.set_published_version('pub/0')
+            sage: W._Worksheet__published_version
             'pub/0'
-            sage: W.set_published_version('pub/0')
         """
         self.__published_version = filename
-…
+ class Worksheet(object):
         """
         If this worksheet was published, return the published version of
         this worksheet. Otherwise, raise a ValueError.
         OUTPUT: a worksheet (or raise a ValueError)
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: P = nb.publish_worksheet(W, 'admin')
             sage: W.published_version() is P
             True
         """
+        """
         try:
             filename =self.__published_version
             try:
-…
+ class Worksheet(object):
                 raise ValueError
         except AttributeError:
             raise ValueError, "no published version"
     def set_worksheet_that_was_published(self, W):
         """
         Set the owner and id_number of the worksheet that was
         published to get self.
         INPUT:
             - ``W`` -- worksheet or 2-tuple ('owner', id_number)
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: P = nb.publish_worksheet(W, 'admin')
             sage: P.worksheet_that_was_published() is W
             True
         We fake things and make it look like P published itself::
             sage: P.set_worksheet_that_was_published(P)
             sage: P.worksheet_that_was_published() is P
             True
-…
+ class Worksheet(object):
         """
         Set the rating on this worksheet by the given user to x and also
         set the given comment.
         INPUT:
         -  ``x`` - integer
         -  ``comment`` - string
         -  ``username`` - string
         EXAMPLES: We create a worksheet and rate it, then look at the
+        ratings.
+        ::
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+        ratings.::
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.rate(3, 'this is great', 'hilbert')
             sage: W.ratings()
             [('hilbert', 3, 'this is great')]
         Note that only the last rating by a user counts::
             sage: W.rate(1, 'this lacks content', 'riemann')
             sage: W.rate(0, 'this lacks content', 'riemann')
             sage: W.ratings()
-…
+ class Worksheet(object):
         """
         Return True is the user with given username has rated this
         worksheet.
         INPUT:
         -  ``username`` - string
         OUTPUT: bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.rate(0, 'this lacks content', 'riemann')
             sage: W.is_rater('admin')
-…
+ class Worksheet(object):
     def ratings(self):
         """
         Return all the ratings of this worksheet.
         OUTPUT:
         -  ``list`` - a reference to the list of ratings.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.ratings()
             []
-…
+ class Worksheet(object):
         r"""
         Return html that renders to give a summary of how this worksheet
         has been rated.
         OUTPUT:
+        -  ``string`` -- a string of HTML as a bunch of table
+           rows.
+        - ``string`` -- a string of HTML as a bunch of table rows.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.rate(0, 'this lacks content', 'riemann')
             sage: W.rate(3, 'this is great', 'hilbert')
-…
+ class Worksheet(object):
     def rating(self):
         """
         Return overall average rating of self.
         OUTPUT: float or the int -1 to mean "not rated"
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.rating()
             -1
-…
+ class Worksheet(object):
         else:
             rating = float(sum(r))/float(len(r))
         return rating
     ##########################################################
     # Active, trash can and archive
     ##########################################################
-…
+ class Worksheet(object):
         """
         Return True if all users have deleted this worksheet, so we know we
         can safely purge it from disk.
         OUTPUT: bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.everyone_has_deleted_this_worksheet()
             False
-…
+ class Worksheet(object):
             sage: W.everyone_has_deleted_this_worksheet()
             True
         """
         for user in self.__collaborators + [self.owner()]:
+        for user in self.collaborators() + [self.owner()]:
             # When the worksheet has been deleted by the owner,
             # self.owner() returns None, so we have to be careful
             # about that case.
             if user is not None and not self.is_trashed(user):
                 return False
         return True
     def user_view(self, user):
         """
         Return the view that the given user has of this worksheet. If the
         user currently doesn't have a view set it to ACTIVE and return
         ACTIVE.
         INPUT:
         -  ``user`` - a string
         OUTPUT:
         -  ``Python int`` - one of ACTIVE, ARCHIVED, TRASH,
            which are defined in worksheet.py
         EXAMPLES: We create a new worksheet and get the view, which is
         ACTIVE::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.user_view('admin')
             sage: sagenb.notebook.worksheet.ACTIVE
         Now for the admin user we move W to the archive::
             sage: W.move_to_archive('admin')
+        The view is now archive.
+        ::
+        The view is now archive.::
             sage: W.user_view('admin')
             sage: sagenb.notebook.worksheet.ARCHIVED
+        For any other random viewer the view is set by default to ACTIVE.
+        ::
+        For any other random viewer the view is set by default to ACTIVE.::
             sage: W.user_view('foo')
         """
-…
+ class Worksheet(object):
             self.user_view(self.owner())
             d = self.__user_view
         for user, val in d.iteritems():
+            d[user] = [val]
+            if not isinstance(val, list):
+                d[user] = [val]
         return d
     def set_tags(self, tags):
         """
+        Set the tags -- for now we ignore everything except ACTIVE, ARCHIVED, TRASH.
+        Set the tags -- for now we ignore everything except ACTIVE,
+        ARCHIVED, TRASH.
         INPUT:
-…
+ class Worksheet(object):
     def set_user_view(self, user, x):
         """
         Set the view on this worksheet for the given user.
         INPUT:
         -  ``user`` - a string
         -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
            TRASH in worksheet.py
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.set_user_view('admin', sagenb.notebook.worksheet.ARCHIVED)
             sage: W.user_view('admin') == sagenb.notebook.worksheet.ARCHIVED
-…
+ class Worksheet(object):
     def user_view_is(self, user, x):
         """
         Return True if the user view of user is x.
         INPUT:
         -  ``user`` - a string
         -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
            TRASH in worksheet.py
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Publish Test', 'admin')
             sage: W.user_view_is('admin', sagenb.notebook.worksheet.ARCHIVED)
             False
-…
+ class Worksheet(object):
             True
         """
         return self.user_view(user) == x
     def is_archived(self, user):
         """
         Return True if this worksheet is archived for the given user.
         INPUT:
         -  ``user`` - string
         OUTPUT: bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Archived Test', 'admin')
             sage: W.is_archived('admin')
             False
-…
+ class Worksheet(object):
     def is_active(self, user):
         """
         Return True if this worksheet is active for the given user.
         INPUT:
         -  ``user`` - string
         OUTPUT: bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Active Test', 'admin')
             sage: W.is_active('admin')
             True
-…
+ class Worksheet(object):
     def is_trashed(self, user):
         """
         Return True if this worksheet is in the trash for the given user.
         INPUT:
         -  ``user`` - string
         OUTPUT: bool
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Trash Test', 'admin')
             sage: W.is_trashed('admin')
             False
-…
+ class Worksheet(object):
     def move_to_archive(self, user):
         """
         Move this worksheet to be archived for the given user.
         INPUT:
         -  ``user`` - string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Archive Test', 'admin')
             sage: W.move_to_archive('admin')
             sage: W.is_archived('admin')
-…
+ class Worksheet(object):
     def set_active(self, user):
         """
         Set his worksheet to be active for the given user.
         INPUT:
         -  ``user`` - string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Active Test', 'admin')
             sage: W.move_to_archive('admin')
             sage: W.is_active('admin')
-…
+ class Worksheet(object):
     def move_to_trash(self, user):
         """
         Move this worksheet to the trash for the given user.
         INPUT:
         -  ``user`` - string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Trash Test', 'admin')
             sage: W.move_to_trash('admin')
             sage: W.is_trashed('admin')
-…
+ class Worksheet(object):
     def move_out_of_trash(self, user):
         """
         Exactly the same as set_active(user).
         INPUT:
         -  ``user`` - string
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: W = nb.create_new_worksheet('Active Test', 'admin')
             sage: W.move_to_trash('admin')
             sage: W.is_active('admin')
-…
+ class Worksheet(object):
             True
         """
         self.set_active(user)
     #############
     def delete_cells_directory(self):
         r"""
         Delete the directory in which all the cell computations occur.
         EXAMPLES::
             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
+            sage: W.edit_save('Sage\n{{{\n3^20\n}}}')
+            sage: W.edit_save('{{{\n3^20\n}}}')
+            sage: W.cell_list()[0].evaluate()
+            sage: W.check_comp()    # random output -- depends on computer speed
             sage: sorted(os.listdir(W.directory()))
             ['cells', 'snapshots']
             sage: W.cell_list()[0].evaluate()
+            ['cells', 'data']
+            sage: W.save_snapshot('admin')
             sage: sorted(os.listdir(W.directory()))
             ['cells', 'data', 'snapshots']
+            ['cells', 'data', 'snapshots', 'worksheet.html']
             sage: W.delete_cells_directory()
             sage: sorted(os.listdir(W.directory()))
+            ['data', 'snapshots']
+            ['data', 'snapshots', 'worksheet.html']
+            sage: W.quit()
+            sage: nb.delete()
         """
         dir = self.cells_directory()
         if os.path.exists(dir):
-…
+ class Worksheet(object):
     def set_owner(self, owner):
         self.__owner = owner
         if not owner in self.__collaborators:
+        if not owner in self.collaborators():
             self.__collaborators.append(owner)
     def user_is_only_viewer(self, user):
-…
+ class Worksheet(object):
             return True
     def user_is_collaborator(self, user):
+        try:
+            return user in self.__collaborators
+        except AttributeError:
+            return True
+        return user in self.collaborators()
     def user_can_edit(self, user):
         """
         Return True if the user with given name is allowed to edit this
         worksheet.
         INPUT:
         -  ``user`` - string
         OUTPUT: bool
+        EXAMPLES: We create a notebook with one worksheet and two users.
+        ::
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
+        EXAMPLES: We create a notebook with one worksheet and two users.::
+            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
             sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
             sage: nb.add_user('william', 'william', 'wstein@sagemath.org', force=True)
             sage: W = nb.create_new_worksheet('Test', 'sage')
             sage: W.user_can_edit('sage')
             True
         At first the user 'william' can't edit this worksheet::
             sage: W.user_can_edit('william')
             False
         After adding 'william' as a collaborator he can edit the
+        worksheet.
+        ::
+        worksheet.::
             sage: W.add_collaborator('william')
             sage: W.user_can_edit('william')
             True
         Clean up::
             sage: nb.delete()
         """
         return self.user_is_collaborator(user) or self.is_owner(user)
     def delete_user(self, user):
         """
         Delete a user from having any view or ownership of this worksheet.
         INPUT:
         -  ``user`` - string; the name of a user
         EXAMPLES: We create a notebook with 2 users and 1 worksheet that
+        both view.

Context Navigation

Ticket #7650: trac_7650-sagenb_doctesting_v2.patch

sagenb/notebook/all.py

sagenb/notebook/avatars.py

sagenb/notebook/cell.py

sagenb/notebook/interact.py

sagenb/notebook/notebook.py

sagenb/notebook/notebook_object.py

sagenb/notebook/twist.py

sagenb/notebook/worksheet.py