Ticket #7650: trac_7650-sagenb_doctesting_v4.patch

File trac_7650-sagenb_doctesting_v4.patch, 222.3 KB (added by mpatel, 13 years ago)

Rebased vs. 4.3.1.alpha0 + #7269. Replaces previous sagenb patch.

  • sagenb/misc/ipaddr.py

    # HG changeset patch
    # User Mitesh Patel <qed777@gmail.com>
    # Date 1260713762 28800
    # Node ID e7e71ce025de4090c78e7d2b8b4c75fda45e8803
    # Parent  426bff1a6a250d2f2d4df77abc7bc6064698945c
    #7650/sagenb: Fix doctesting under sagenb/
    
    diff --git a/sagenb/misc/ipaddr.py b/sagenb/misc/ipaddr.py
    a b  
     1"""nodoctests"""
    12#!/usr/bin/python
    23#
    34# Copyright 2007 Google Inc.
  • sagenb/notebook/all.py

    diff --git a/sagenb/notebook/all.py b/sagenb/notebook/all.py
    a b from sage_email import email 
    1515from notebook_object import notebook, inotebook
    1616
    1717from interact import interact, input_box, slider, range_slider, selector, checkbox, input_grid, text_control, color_selector
     18
     19# For doctesting.
     20import sagenb
  • sagenb/notebook/avatars.py

    diff --git a/sagenb/notebook/avatars.py b/sagenb/notebook/avatars.py
    a b def user_type(avatarId): 
    4444        Traceback (most recent call last):
    4545        ...
    4646        AttributeError: 'NoneType' object has no attribute 'user_is_admin'
    47         sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     47        sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    4848        sage: nb.create_default_users('password')
    4949        Creating default users.
    5050        sage: sagenb.notebook.twist.notebook = nb
  • sagenb/notebook/cell.py

    diff --git a/sagenb/notebook/cell.py b/sagenb/notebook/cell.py
    a b class Cell_generic: 
    5353        """
    5454        Returns True if this cell contains the use of interact either as a
    5555        function call or a decorator.
    56        
     56
    5757        EXAMPLES::
    58        
     58
    5959            sage: from sagenb.notebook.cell import Cell_generic
    6060            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    6161            sage: Cell_generic.is_interactive_cell(C)
    class Cell_generic: 
    6767        """
    6868        Delete all output in this cell. This is not executed - it is an
    6969        abstract function that must be overwritten in a derived class.
    70        
     70
    7171        EXAMPLES: This function just raises a NotImplementedError, since it
    72         most be defined in derived class.
    73        
    74         ::
    75        
     72        most be defined in derived class.::
     73
    7674            sage: C = sagenb.notebook.cell.Cell_generic()
    7775            sage: C.delete_output()
    7876            Traceback (most recent call last):
    class Cell_generic: 
    8482    def html_new_cell_before(self):
    8583        """
    8684        Returns the HTML code for inserting a new cell before self.
    87        
     85
    8886        EXAMPLES::
    89        
     87
    9088            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    9189            sage: print C.html_new_cell_before()
    9290            <div class="insert_new_cell" id="insert_new_cell_before0">...
    class Cell_generic: 
    10199    def html_new_cell_after(self):
    102100        """
    103101        Returns the HTML code for inserting a new cell after self.
    104        
     102
    105103        EXAMPLES::
    106        
     104
    107105            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    108106            sage: print C.html_new_cell_after()
    109107            <div class="insert_new_cell" id="insert_new_cell_after0">...
    class TextCell(Cell_generic): 
    120118    def __init__(self, id, text, worksheet):
    121119        """
    122120        EXAMPLES::
    123        
     121
    124122            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    125123            sage: C == loads(dumps(C))
    126124            True
    class TextCell(Cell_generic): 
    132130    def __repr__(self):
    133131        """
    134132        String representation of this text cell.
    135        
     133
    136134        EXAMPLES::
    137        
     135
    138136            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    139137            sage: C.__repr__()
    140138            'TextCell 0: 2+3'
    class TextCell(Cell_generic): 
    145143        """
    146144        Delete all output in this cell. This does nothing since text cells
    147145        have no output.
    148        
     146
    149147        EXAMPLES::
    150        
     148
    151149            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    152150            sage: C
    153151            TextCell 0: 2+3
    class TextCell(Cell_generic): 
    160158    def set_input_text(self, input_text):
    161159        """
    162160        Sets the input text of self to be input_text.
    163        
     161
    164162        EXAMPLES::
    165        
     163
    166164            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    167165            sage: C
    168166            TextCell 0: 2+3
    class TextCell(Cell_generic): 
    171169            TextCell 0: 3+2
    172170        """
    173171        self.__text = input_text
    174        
     172
    175173    def set_worksheet(self, worksheet, id=None):
    176174        """
    177175        Sets the worksheet object of self to be worksheet and optionally
    178176        changes the id of self.
    179        
     177
    180178        EXAMPLES::
    181        
     179
    182180            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    183181            sage: W = "worksheet object"
    184182            sage: C.set_worksheet(W)
    class TextCell(Cell_generic): 
    195193    def worksheet(self):
    196194        """
    197195        Returns the worksheet object associated to self.
    198        
     196
    199197        EXAMPLES::
    200        
     198
    201199            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', 'worksheet object')
    202200            sage: C.worksheet()
    203201            'worksheet object'
    class TextCell(Cell_generic): 
    209207        Returns an HTML version of self as a string.
    210208
    211209        INPUT:
    212            
     210
    213211        - ``do_math_parse`` - bool (default: True)
    214212          If True, call math_parse (defined in cell.py)
    215           on the html. 
     213          on the html.
    216214
    217215        EXAMPLES::
    218        
     216
    219217            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    220218            sage: C.html()
    221             '<div class="text_cell" id="cell_text_0">2+3...'
     219            '...<div class="text_cell" id="cell_text_0">2+3...'
    222220            sage: C.set_input_text("$2+3$")
    223221            sage: C.html(do_math_parse=True)
    224             '<div class="text_cell" id="cell_text_0"><span class="math">2+3</span>...'
     222            '...<div class="text_cell" id="cell_text_0"><span class="math">2+3</span>...'
    225223        """
    226224        s = '<span id="cell_outer_%s">'%self.__id
    227225
    class TextCell(Cell_generic): 
    229227            s += self.html_new_cell_before()
    230228
    231229        s += """<div class="text_cell" id="cell_text_%s">%s</div>"""%(
    232             self.__id, 
     230            self.__id,
    233231            self.html_inner(ncols=ncols, do_print=do_print, do_math_parse=do_math_parse, editing=editing))
    234232
    235233        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): 
    240238                print msg
    241239                # better to get the worksheet at all than to get a blank screen and nothing.
    242240                z = self.__text
    243            
     241
    244242            s += """<script>$("#cell_text_%s").unbind('dblclick').editable(function(value,settings) {
    245243evaluate_text_cell_input(%s,value,settings);
    246244return(value);
    247 }, { 
     245}, {
    248246      tooltip   : "",
    249247      placeholder : "",
    250248//      type   : 'textarea',
    return(value); 
    271269        Returns an HTML version of the content of self as a string.
    272270
    273271        INPUT:
    274        
     272
    275273        - ``do_math_parse`` - bool (default: True)
    276274          If True, call math_parse (defined in cell.py)
    277           on the html. 
     275          on the html.
    278276
    279277        EXAMPLES::
    280        
     278
    281279            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    282280            sage: C.html_inner()
    283281            '2+3...'
    return(value); 
    297295                pass
    298296        s = """%s"""%t
    299297        return s
    300        
     298
    301299
    302300    def plain_text(self, prompts=False):
    303301        """
    304302        Returns a plain text version of self.
    305        
     303
    306304        EXAMPLES::
    307        
     305
    308306            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    309307            sage: C.plain_text()
    310308            '2+3'
    return(value); 
    314312    def edit_text(self):
    315313        """
    316314        Returns the text to be displayed in the Edit window.
    317        
     315
    318316        EXAMPLES::
    319        
     317
    320318            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    321319            sage: C.edit_text()
    322320            '2+3'
    return(value); 
    330328        OUTPUT:
    331329
    332330        - int -- self's ID.
    333        
     331
    334332        EXAMPLES::
    335        
     333
    336334            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    337335            sage: C.id()
    338336            0
    return(value); 
    342340    def is_auto_cell(self):
    343341        """
    344342        Returns True if self is automatically evaluated.
    345        
     343
    346344        EXAMPLES::
    347        
     345
    348346            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    349347            sage: C.is_auto_cell()
    350348            False
    return(value); 
    354352    def __cmp__(self, right):
    355353        """
    356354        Compares cells by ID.
    357        
     355
    358356        EXAMPLES::
    359        
     357
    360358            sage: C1 = sagenb.notebook.cell.TextCell(0, '2+3', None)
    361359            sage: C2 = sagenb.notebook.cell.TextCell(0, '3+2', None)
    362360            sage: C3 = sagenb.notebook.cell.TextCell(1, '2+3', None)
    return(value); 
    372370    def set_cell_output_type(self, typ='wrap'):
    373371        """
    374372        This does nothing for TextCells.
    375        
     373
    376374        EXAMPLES::
    377        
     375
    378376            sage: C = sagenb.notebook.cell.TextCell(0, '2+3', None)
    379377            sage: C.set_cell_output_type("wrap")
    380378        """
    381379        pass # ignored
    382                    
     380
    383381
    384382class Cell(Cell_generic):
    385383    def __init__(self, id, input, out, worksheet):
    386384        """
    387385        EXAMPLES::
    388        
     386
    389387            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    390388            sage: C == loads(dumps(C))
    391389            True
    class Cell(Cell_generic): 
    400398        self.__asap = False
    401399        self.__version = -1
    402400        self.set_input_text(str(input).replace('\r',''))
    403        
     401
    404402    def set_asap(self, asap):
    405403        """
    406404        Set whether this cell is evaluated as soon as possible.
    407        
     405
    408406        EXAMPLES::
    409        
     407
    410408            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    411409            sage: C.is_asap()
    412410            False
    class Cell(Cell_generic): 
    420418        """
    421419        Return True if this is an asap cell, i.e., evaluation of it is done
    422420        as soon as possible.
    423        
     421
    424422        EXAMPLES::
    425        
     423
    426424            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    427425            sage: C.is_asap()
    428426            False
    class Cell(Cell_generic): 
    439437    def delete_output(self):
    440438        """
    441439        Delete all output in this cell.
    442        
     440
    443441        EXAMPLES::
    444        
     442
    445443            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None); C
    446444            Cell 0; in=2+3, out=5
    447445            sage: C.delete_output()
    class Cell(Cell_generic): 
    456454        r"""
    457455        Return True if this cell has been successfully evaluated in a
    458456        currently running session.
    459        
     457
    460458        This is not about whether the output of the cell is valid given the
    461459        input.
    462        
     460
    463461        OUTPUT:
    464        
    465        
     462
    466463        -  ``bool`` - whether or not this cell has been
    467464           evaluated in this session
    468        
    469        
     465
    470466        EXAMPLES: We create a worksheet with a cell that has wrong output::
    471        
    472             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     467
     468            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    473469            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    474470            sage: W = nb.create_new_worksheet('Test', 'sage')
    475             sage: W.edit_save('Sage\n{{{\n2+3\n///\n20\n}}}')
     471            sage: W.edit_save('{{{\n2+3\n///\n20\n}}}')
    476472            sage: C = W.cell_list()[0]
    477473            sage: C
    478474            Cell 0; in=2+3, out=
    479475            20
    480        
     476
    481477        We re-evaluate that input cell::
    482        
     478
    483479            sage: C.evaluate()
    484             sage: W.check_comp(wait=9999)
    485             ('d', Cell 0; in=2+3, out=
    486             5
    487             )
    488        
     480            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
     481            ('w', Cell 0; in=2+3, out=)
     482
    489483        Now the output is right::
    490        
    491             sage: C
     484
     485            sage: C     # random output -- depends on computer speed
    492486            Cell 0; in=2+3, out=
    493             5
    494        
    495         And the cell is considered to have been evaluated.
    496        
     487
     488        And the cell is considered to have been evaluated.::
     489
     490            sage: C.evaluated()     # random output -- depends on computer speed
     491            True
     492
    497493        ::
    498        
    499             sage: C.evaluated()
    500             True
    501        
    502         ::
    503        
    504             sage: import shutil; shutil.rmtree(nb.directory())
     494
     495            sage: W.quit()
     496            sage: nb.delete()
    505497        """
    506498        # Cells are never considered evaluated in a new session.
    507499        if not self.worksheet().compute_process_has_been_started():
    class Cell(Cell_generic): 
    519511                return False
    520512            return self.__evaluated
    521513        except AttributeError:
    522             # Default assumption is that cell has not been evaluated. 
     514            # Default assumption is that cell has not been evaluated.
    523515            self.__evaluated = False
    524516            return False
    525517
    class Cell(Cell_generic): 
    527519        """
    528520        Sets whether or not this is an no_output cell, i.e., a cell for
    529521        which we don't care at all about the output.
    530        
     522
    531523        EXAMPLES::
    532        
     524
    533525            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    534526            sage: C.is_no_output()
    535527            False
    class Cell(Cell_generic): 
    543535        """
    544536        Return True if this is an no_output cell, i.e., a cell for which
    545537        we don't care at all about the output.
    546        
     538
    547539        EXAMPLES::
    548        
     540
    549541            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    550542            sage: C.is_no_output()
    551543            False
    class Cell(Cell_generic): 
    562554    def set_cell_output_type(self, typ='wrap'):
    563555        """
    564556        Sets the cell output type.
    565        
     557
    566558        EXAMPLES::
    567        
     559
    568560            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    569561            sage: C.cell_output_type()
    570562            'wrap'
    class Cell(Cell_generic): 
    577569    def cell_output_type(self):
    578570        """
    579571        Returns the cell output type.
    580        
     572
    581573        EXAMPLES::
    582        
     574
    583575            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    584576            sage: C.cell_output_type()
    585577            'wrap'
    class Cell(Cell_generic): 
    597589        """
    598590        Sets the worksheet object of self to be worksheet and optionally
    599591        changes the id of self.
    600        
     592
    601593        EXAMPLES::
    602        
     594
    603595            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    604596            sage: W = "worksheet object"
    605597            sage: C.set_worksheet(W)
    class Cell(Cell_generic): 
    616608    def worksheet(self):
    617609        """
    618610        Returns the worksheet object associated to self.
    619        
     611
    620612        EXAMPLES::
    621        
     613
    622614            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', 'worksheet object')
    623615            sage: C.worksheet()
    624616            'worksheet object'
    class Cell(Cell_generic): 
    629621        """
    630622        Update the list of files with html-style links or embeddings for
    631623        this cell.
    632        
     624
    633625        For interactive cells the html output section is always empty,
    634626        mainly because there is no good way to distinguish content (e.g.,
    635627        images in the current directory) that goes into the interactive
    class Cell(Cell_generic): 
    637629
    638630        EXAMPLES::
    639631
    640             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     632            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    641633            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    642634            sage: W = nb.create_new_worksheet('Test', 'sage')
    643635            sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
    644636            sage: C.evaluate()
    645             sage: W.check_comp(wait=9999)
     637            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    646638            ('d', Cell 0; in=plot(sin(x),0,5), out=
    647639            <html><font color='black'><img src='cell://sage0.png'></font></html>
    648640            <BLANKLINE>
    649641            )
    650642            sage: C.update_html_output()
    651             sage: C.output_html()
     643            sage: C.output_html()     # random output -- depends on computer speed
    652644            '<img src="/home/sage/0/cells/0/sage0.png?...">'
     645            sage: W.quit()
     646            sage: nb.delete()
    653647        """
    654648        if self.is_interactive_cell():
    655649            self.__out_html = ""
    class Cell(Cell_generic): 
    659653    def id(self):
    660654        """
    661655        Returns the id of self.
    662        
     656
    663657        EXAMPLES::
    664        
     658
    665659            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    666660            sage: C.id()
    667661            0
    class Cell(Cell_generic): 
    671665    def set_id(self, id):
    672666        """
    673667        Sets the id of self to id.
    674        
     668
    675669        EXAMPLES::
    676        
     670
    677671            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    678672            sage: C.set_id(2)
    679673            sage: C.id()
    class Cell(Cell_generic): 
    684678    def worksheet(self):
    685679        """
    686680        Returns the workseet associated to self.
    687        
     681
    688682        EXAMPLES::
    689        
    690             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     683
     684            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    691685            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    692686            sage: W = nb.create_new_worksheet('Test', 'sage')
    693687            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    694688            sage: C.worksheet() is W
    695689            True
    696        
    697         ::
    698        
    699             sage: import shutil; shutil.rmtree(nb.directory())
     690            sage: nb.delete()
    700691        """
    701692        return self.__worksheet
    702693
    703694    def worksheet_filename(self):
    704695        """
    705696        Returns the filename of the worksheet associated to self.
    706        
     697
    707698        EXAMPLES::
    708        
    709             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     699
     700            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    710701            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    711702            sage: W = nb.create_new_worksheet('Test', 'sage')
    712703            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    713704            sage: C.worksheet_filename()
    714705            'sage/0'
    715        
    716         ::
    717        
    718             sage: import shutil; shutil.rmtree(nb.directory())
     706            sage: nb.delete()
    719707        """
    720708        return self.__worksheet.filename()
    721709
    class Cell(Cell_generic): 
    723711    def notebook(self):
    724712        """
    725713        Returns the notebook object associated to self.
    726        
     714
    727715        EXAMPLES::
    728        
    729             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     716
     717            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    730718            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    731719            sage: W = nb.create_new_worksheet('Test', 'sage')
    732720            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    733721            sage: C.notebook() is nb
    734722            True
    735        
    736         ::
    737        
    738             sage: import shutil; shutil.rmtree(nb.directory())
     723            sage: nb.delete()
    739724        """
    740725        return self.__worksheet.notebook()
    741726
    class Cell(Cell_generic): 
    743728        """
    744729        Returns the directory associated to self. If the directory doesn't
    745730        already exist, then this method creates it.
    746        
     731
    747732        EXAMPLES::
    748        
    749             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     733
     734            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    750735            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    751736            sage: W = nb.create_new_worksheet('Test', 'sage')
    752737            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    753738            sage: C.directory()
    754             '.../worksheets/sage/0/cells/0'
    755        
    756         ::
    757        
    758             sage: import shutil; shutil.rmtree(nb.directory())
     739            '.../home/sage/0/cells/0'
     740            sage: nb.delete()
    759741        """
    760742        dir = self._directory_name()
    761743        if not os.path.exists(dir):
    class Cell(Cell_generic): 
    766748    def _directory_name(self):
    767749        """
    768750        Returns a string of the directory associated to self.
    769        
     751
    770752        EXAMPLES::
    771        
    772             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     753
     754            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    773755            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    774756            sage: W = nb.create_new_worksheet('Test', 'sage')
    775757            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    776758            sage: C._directory_name()
    777             '.../worksheets/sage/0/cells/0'
    778        
    779         ::
    780        
    781             sage: import shutil; shutil.rmtree(nb.directory())
     759            '.../home/sage/0/cells/0'
     760            sage: nb.delete()
    782761        """
    783762        return os.path.join(self.__worksheet.directory(), 'cells', str(self.id()))
    784763
    class Cell(Cell_generic): 
    786765    def __cmp__(self, right):
    787766        """
    788767        Compares cells by their IDs.
    789        
     768
    790769        EXAMPLES::
    791        
     770
    792771            sage: C1 = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    793772            sage: C2 = sagenb.notebook.cell.Cell(0, '3+2', '5', None)
    794773            sage: C3 = sagenb.notebook.cell.Cell(1, '2+3', '5', None)
    class Cell(Cell_generic): 
    804783    def __repr__(self):
    805784        """
    806785        Returns a string representation of self.
    807        
     786
    808787        EXAMPLES::
    809        
     788
    810789            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None); C
    811790            Cell 0; in=2+3, out=5
    812791        """
    class Cell(Cell_generic): 
    816795        """
    817796        Returns the number of columns for word wrapping. This defaults to
    818797        70, but the default setting for a notebook is 72.
    819        
     798
    820799        EXAMPLES::
    821        
     800
    822801            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    823802            sage: C.word_wrap_cols()
    824803            70
    825        
    826         ::
    827        
    828             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     804            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    829805            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    830806            sage: W = nb.create_new_worksheet('Test', 'sage')
    831807            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    832808            sage: C.word_wrap_cols()
    833809            72
    834        
    835         ::
    836        
    837             sage: import shutil; shutil.rmtree(nb.directory())
     810            sage: nb.delete()
    838811        """
    839812        try:
    840813            return self.notebook().conf()['word_wrap_cols']
    841814        except AttributeError:
    842815            return 70
    843        
     816
    844817    def plain_text(self, ncols=0, prompts=True, max_out=None):
    845818        r"""
    846819        Returns the plain text version of self.
    class Cell(Cell_generic): 
    857830
    858831        input_lines = self.__in
    859832        pr = 'sage: '
    860            
     833
    861834        if prompts:
    862835            input_lines = input_lines.splitlines()
    863836            has_prompt = False
    class Cell(Cell_generic): 
    911884        if not max_out is None and len(out) > max_out:
    912885            out = out[:max_out] + '...'
    913886
    914         # Get rid of spurious carriage returns 
     887        # Get rid of spurious carriage returns
    915888        s = s.strip('\n')
    916889        out = out.strip('\n').strip('\r').strip('\r\n')
    917890        s = s + '\n' + out
    class Cell(Cell_generic): 
    919892        if not prompts:
    920893            s = s.rstrip('\n')
    921894        return s
    922    
     895
    923896    def edit_text(self, ncols=0, prompts=False, max_out=None):
    924897        r"""
    925898        Returns the text displayed in the Edit window.
    926        
     899
    927900        EXAMPLES::
    928        
     901
    929902            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    930903            sage: C.edit_text()
    931904            '{{{id=0|\n2+3\n///\n5\n}}}'
    class Cell(Cell_generic): 
    936909    def is_last(self):
    937910        """
    938911        Returns True if self is the last cell in the worksheet.
    939        
     912
    940913        EXAMPLES::
    941        
    942             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     914
     915            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    943916            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    944917            sage: W = nb.create_new_worksheet('Test', 'sage')
    945918            sage: C = W.new_cell_after(0, "2^2"); C
    946             Cell 1; in=2^2, out=
     919            Cell 2; in=2^2, out=
    947920            sage: C.is_last()
    948921            True
    949922            sage: C = W.get_cell_with_id(0)
    950923            sage: C.is_last()
    951924            False
    952        
    953         ::
    954        
    955             sage: import shutil; shutil.rmtree(nb.directory())
     925            sage: nb.delete()
    956926        """
    957927        return self.__worksheet.cell_list()[-1] == self
    958928
    class Cell(Cell_generic): 
    961931        Returns the id of the next cell in the worksheet associated to
    962932        self. If self is not in the worksheet or self is the last cell in
    963933        the cell_list, then the id of the first cell is returned.
    964        
     934
    965935        EXAMPLES::
    966        
    967             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     936
     937            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    968938            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    969939            sage: W = nb.create_new_worksheet('Test', 'sage')
    970             sage: C = W.new_cell_after(0, "2^2")
    971             sage: C = W.get_cell_with_id(0)
     940            sage: C = W.new_cell_after(1, "2^2")
     941            sage: C = W.get_cell_with_id(1)
     942            sage: C.next_id()
     943            2
     944            sage: C = W.get_cell_with_id(2)
    972945            sage: C.next_id()
    973946            1
    974             sage: C = W.get_cell_with_id(1)
    975             sage: C.next_id()
    976             0
    977        
    978         ::
    979        
    980             sage: import shutil; shutil.rmtree(nb.directory())
     947            sage: nb.delete()
    981948        """
    982949        L = self.__worksheet.cell_list()
    983950        try:
    class Cell(Cell_generic): 
    993960    def interrupt(self):
    994961        """
    995962        Record that the calculation running in this cell was interrupted.
    996        
     963
    997964        EXAMPLES::
    998        
    999             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     965
     966            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    1000967            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    1001968            sage: W = nb.create_new_worksheet('Test', 'sage')
    1002969            sage: C = W.new_cell_after(0, "2^2")
    class Cell(Cell_generic): 
    1005972            True
    1006973            sage: C.evaluated()
    1007974            False
    1008        
    1009         ::
    1010        
    1011             sage: import shutil; shutil.rmtree(nb.directory())
     975            sage: nb.delete()
    1012976        """
    1013977        self.__interrupted = True
    1014978        self.__evaluated = False
    class Cell(Cell_generic): 
    1016980    def interrupted(self):
    1017981        """
    1018982        Returns True if the evaluation of this cell has been interrupted.
    1019        
     983
    1020984        EXAMPLES::
    1021        
    1022             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     985
     986            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    1023987            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    1024988            sage: W = nb.create_new_worksheet('Test', 'sage')
    1025989            sage: C = W.new_cell_after(0, "2^2")
    1026990            sage: C.interrupt()
    1027991            sage: C.interrupted()
    1028992            True
    1029        
    1030         ::
    1031        
    1032             sage: import shutil; shutil.rmtree(nb.directory())
     993            sage: nb.delete()
    1033994        """
    1034995        return self.__interrupted
    1035996
    1036997    def computing(self):
    1037998        """
    1038999        Returns True if self is in its worksheet's queue.
    1039        
     1000
    10401001        EXAMPLES::
    1041        
    1042             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1002
     1003            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10431004            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    10441005            sage: W = nb.create_new_worksheet('Test', 'sage')
    10451006            sage: C = W.new_cell_after(0, "2^2")
    10461007            sage: C.computing()
    10471008            False
    1048        
    1049         ::
    1050        
    1051             sage: import shutil; shutil.rmtree(nb.directory())
     1009            sage: nb.delete()
    10521010        """
    10531011        return self in self.__worksheet.queue()
    10541012
    class Cell(Cell_generic): 
    10561014        r"""
    10571015        Return True if this cell contains the use of interact either as a
    10581016        function call or a decorator.
    1059        
     1017
    10601018        EXAMPLES::
    1061        
    1062             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1019
     1020            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10631021            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    10641022            sage: W = nb.create_new_worksheet('Test', 'sage')
    10651023            sage: C = W.new_cell_after(0, "@interact\ndef f(a=slider(0,10,1,5):\n    print a^2")
    class Cell(Cell_generic): 
    10681026            sage: C = W.new_cell_after(C.id(), "2+2")
    10691027            sage: C.is_interactive_cell()
    10701028            False
    1071        
    1072         ::
    1073        
    1074             sage: import shutil; shutil.rmtree(nb.directory())
     1029            sage: nb.delete()
    10751030        """
    10761031        # Do *not* cache
    10771032        s = strip_string_literals(self.input_text())
    class Cell(Cell_generic): 
    10821037    def is_interacting(self):
    10831038        r"""
    10841039        Returns True if this cell is currently interacting with the user.
    1085        
     1040
    10861041        EXAMPLES::
    1087        
    1088             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1042
     1043            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10891044            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    10901045            sage: W = nb.create_new_worksheet('Test', 'sage')
    10911046            sage: C = W.new_cell_after(0, "@interact\ndef f(a=slider(0,10,1,5):\n    print a^2")
    class Cell(Cell_generic): 
    10981053        """
    10991054        Stops interaction with user.
    11001055
    1101         TODO: Add doctests for :meth:`stop_interacting`.           
     1056        TODO: Add doctests for :meth:`stop_interacting`.
    11021057        """
    11031058        if self.is_interacting():
    11041059            del self.interact
    class Cell(Cell_generic): 
    11061061    def set_input_text(self, input):
    11071062        """
    11081063        Sets the input text of self to be the string input.
    1109        
     1064
    11101065        TODO: Add doctests for the code dealing with interact.
    1111        
     1066
    11121067        EXAMPLES::
    1113        
    1114             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1068
     1069            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11151070            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    11161071            sage: W = nb.create_new_worksheet('Test', 'sage')
    11171072            sage: C = W.new_cell_after(0, "2^2")
    11181073            sage: C.evaluate()
    1119             sage: W.check_comp(wait=9999)
     1074            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    11201075            ('d', Cell 1; in=2^2, out=
    11211076            4
    11221077            )
    11231078            sage: C.version()
    11241079            0
    1125        
    1126         ::
    1127        
    11281080            sage: C.set_input_text('3+3')
    11291081            sage: C.input_text()
    11301082            '3+3'
    class Cell(Cell_generic): 
    11321084            False
    11331085            sage: C.version()
    11341086            1
    1135        
    1136         ::
    1137        
    1138             sage: import shutil; shutil.rmtree(nb.directory())
     1087            sage: W.quit()
     1088            sage: nb.delete()
    11391089        """
    11401090        # Stuff to deal with interact
    11411091        if input.startswith('%__sage_interact__'):
    class Cell(Cell_generic): 
    11491099            except AttributeError:
    11501100                pass
    11511101
    1152         # We have updated the input text so the cell can't have 
    1153         # been evaluated. 
     1102        # We have updated the input text so the cell can't have
     1103        # been evaluated.
    11541104        self.__evaluated = False
    11551105        self.__version = self.version() + 1
    11561106        self.__in = input
    class Cell(Cell_generic): 
    11601110        #Run get the input text with all of the percent
    11611111        #directives parsed
    11621112        self._cleaned_input = self.parse_percent_directives()
    1163        
     1113
    11641114    def input_text(self):
    11651115        """
    11661116        Returns self's input text.
    1167        
     1117
    11681118        EXAMPLES::
    1169        
     1119
    11701120            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    11711121            sage: C.input_text()
    11721122            '2+3'
    class Cell(Cell_generic): 
    11801130        text is returned.
    11811131
    11821132        EXAMPLES::
    1183        
     1133
    11841134            sage: C = sagenb.notebook.cell.Cell(0, '%hide\n%maxima\n2+3', '5', None)
    11851135            sage: C.cleaned_input_text()
    11861136            '2+3'
    1187 
    11881137        """
    11891138        if self.is_interacting():
    11901139            return self.interact
    class Cell(Cell_generic): 
    11971146        with the percent directives at the top removed.  As it's doing
    11981147        this, it computes a list of all the directives and which
    11991148        system (if any) the cell should be run under.
    1200        
     1149
    12011150        EXAMPLES::
    1202        
     1151
    12031152            sage: C = sagenb.notebook.cell.Cell(0, '%hide\n%maxima\n2+3', '5', None)
    12041153            sage: C.parse_percent_directives()
    12051154            '2+3'
    12061155            sage: C.percent_directives()
    12071156            ['hide', 'maxima']
    1208        
    12091157        """
    12101158        self._system = None
    12111159        text = self.input_text().splitlines()
    class Cell(Cell_generic): 
    12251173                pass
    12261174            else:
    12271175                self._system = line[1:]
    1228                
     1176
    12291177            directives.append(line[1:])
    1230            
     1178
    12311179        self._percent_directives = directives
    12321180        return "\n".join(text[i:]).strip()
    1233            
     1181
    12341182    def percent_directives(self):
    12351183        r"""
    12361184        Returns a list of all the percent directives that appear
    12371185        in this cell.
    12381186
    12391187        EXAMPLES::
    1240        
     1188
    12411189            sage: C = sagenb.notebook.cell.Cell(0, '%hide\n%maxima\n2+3', '5', None)
    12421190            sage: C.percent_directives()
    12431191            ['hide', 'maxima']
    1244        
    12451192        """
    12461193        return self._percent_directives
    12471194
    class Cell(Cell_generic): 
    12561203        worksheet's default system.
    12571204
    12581205        EXAMPLES::
    1259        
     1206
    12601207            sage: C = sagenb.notebook.cell.Cell(0, '%maxima\n2+3', '5', None)
    12611208            sage: C.system()
    12621209            'maxima'
    class Cell(Cell_generic): 
    12711218    def is_auto_cell(self):
    12721219        r"""
    12731220        Returns True if self is an auto cell.
    1274        
     1221
    12751222        An auto cell is a cell that is automatically evaluated when the
    12761223        worksheet starts up.
    1277        
     1224
    12781225        EXAMPLES::
    1279        
     1226
    12801227            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    12811228            sage: C.is_auto_cell()
    12821229            False
    class Cell(Cell_generic): 
    12911238        Returns the changed input text for the cell. If there was any
    12921239        changed input text, then it is reset to " before this method
    12931240        returns.
    1294        
     1241
    12951242        EXAMPLES::
    1296        
     1243
    12971244            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    12981245            sage: C.changed_input_text()
    12991246            ''
    class Cell(Cell_generic): 
    13181265        """
    13191266        Note that this does not update the version of the cell. This is
    13201267        typically used for things like tab completion.
    1321        
     1268
    13221269        EXAMPLES::
    1323        
     1270
    13241271            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    13251272            sage: C.set_changed_input_text('3+3')
    13261273            sage: C.input_text()
    class Cell(Cell_generic): 
    13361283        Sets the output text for self.
    13371284
    13381285        EXAMPLES::
    1339        
     1286
    13401287            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    13411288            sage: len(C.plain_text())
    13421289            11
    class Cell(Cell_generic): 
    13491296            output = ''
    13501297
    13511298        # In interacting mode, we just save the computed output
    1352         # (do not overwrite). 
     1299        # (do not overwrite).
    13531300        if self.is_interacting():
    13541301            self._interact_output = (output, html)
    13551302            return
    1356        
     1303
    13571304        if hasattr(self, '_html_cache'):
    13581305            del self._html_cache
    13591306
    class Cell(Cell_generic): 
    13861333    def sage(self):
    13871334        """
    13881335        TODO: Figure out what exactly this does.
    1389        
     1336
    13901337        EXAMPLES::
    1391        
     1338
    13921339            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    13931340            sage: C.sage() is None
    13941341            True
    class Cell(Cell_generic): 
    14031350        Returns the HTML for self's output.
    14041351
    14051352        EXAMPLES::
    1406        
     1353
    14071354            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    14081355            sage: C.output_html()
    14091356            ''
    class Cell(Cell_generic): 
    14161363        except AttributeError:
    14171364            self.__out_html = ''
    14181365            return ''
    1419    
     1366
    14201367    def process_cell_urls(self, urls):
    14211368        """
    14221369        Processes URLs of the form ``'cell://.*?'`` by replacing the
    class Cell(Cell_generic): 
    14281375        - ``urls`` - a string
    14291376
    14301377        EXAMPLES::
    1431        
    1432             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1378
     1379            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14331380            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    14341381            sage: W = nb.create_new_worksheet('Test', 'sage')
    14351382            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    14491396        INPUT:
    14501397
    14511398        - ``ncols`` -- maximum number of columns
    1452            
     1399
    14531400        - ``html`` -- boolean stating whether to output HTML
    1454            
     1401
    14551402        - ``raw`` -- boolean stating whether to output raw text
    14561403          (takes precedence over HTML)
    14571404
    class Cell(Cell_generic): 
    14591406
    14601407        EXAMPLES::
    14611408
    1462             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1409            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14631410            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    14641411            sage: W = nb.create_new_worksheet('Test', 'sage')
    14651412            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    15011448                return '<h2>Click to the left again to hide and once more to show the dynamic interactive window</h2>'
    15021449        else:
    15031450            s = self.__out
    1504        
     1451
    15051452        if raw:
    15061453            return s
    15071454
    class Cell(Cell_generic): 
    15101457
    15111458        if not is_interact and not self.is_html() and len(s.strip()) > 0:
    15121459            s = '<pre class="shrunk">' + s.strip('\n') + '</pre>'
    1513            
     1460
    15141461        return s.strip('\n')
    15151462
    15161463    def parse_html(self, s, ncols):
    class Cell(Cell_generic): 
    15181465        Parse HTML for output.
    15191466
    15201467        INPUT:
    1521        
     1468
    15221469        - ``s`` -- the input string containing HTML
    1523            
     1470
    15241471        - ``ncols`` -- maximum number of columns
    1525            
     1472
    15261473        EXAMPLES::
    1527        
    1528             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1474
     1475            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15291476            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    15301477            sage: W = nb.create_new_worksheet('Test', 'sage')
    15311478            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    15691516                j = t[i:].lower().find('</script>')
    15701517                if j == -1: break
    15711518                t = t[:i] + t[i+j+len('</script>'):]
    1572                
     1519
    15731520        return t
    1574        
     1521
    15751522
    15761523    def has_output(self):
    15771524        """
    15781525        Returns True if there is output for this cell.
    1579        
     1526
    15801527        EXAMPLES::
    1581        
     1528
    15821529            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    15831530            sage: C.has_output()
    15841531            True
    class Cell(Cell_generic): 
    15921539        r"""
    15931540        Returns True if this is an HTML cell. An HTML cell whose system is
    15941541        'html' and is typically specified by ``%html``.
    1595        
     1542
    15961543        EXAMPLES::
    1597        
     1544
    15981545            sage: C = sagenb.notebook.cell.Cell(0, "%html\nTest HTML", None, None)
    15991546            sage: C.system()
    16001547            'html'
    class Cell(Cell_generic): 
    16031550            sage: C = sagenb.notebook.cell.Cell(0, "Test HTML", None, None)
    16041551            sage: C.is_html()
    16051552            False
    1606 
    16071553        """
    16081554        try:
    16091555            return self.__is_html
    class Cell(Cell_generic): 
    16131559    def set_is_html(self, v):
    16141560        """
    16151561        Sets whether or not this cell is an HTML cell.
    1616        
     1562
    16171563        This is called by check_for_system_switching in worksheet.py.
    1618        
     1564
    16191565        EXAMPLES::
    1620        
     1566
    16211567            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    16221568            sage: C.is_html()
    16231569            False
    class Cell(Cell_generic): 
    16301576    #################
    16311577    # Introspection #
    16321578    #################
    1633     def set_introspect_html(self, html, completing=False, verbose=False, raw=False):
     1579    def set_introspect_html(self, html, completing=False, raw=False):
    16341580        """
    1635         If ``verbose`` is True, print verbose output about notebook
    1636         introspection to the command-line.  However, the argument
    1637         ``verbose`` is not easily accessible now -- if you need to
    1638         debug, you have to edit this file, changing its value to True,
    1639         and run 'sage -b'.
    1640 
    16411581        EXAMPLES::
    16421582
    1643             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1583            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16441584            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    16451585            sage: W = nb.create_new_worksheet('Test', 'sage')
    16461586            sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
    16471587            sage: C.introspect()
    16481588            False
    16491589            sage: C.evaluate(username='sage')
    1650             sage: W.check_comp(9999)
     1590            sage: W.check_comp(9999)     # random output -- depends on computer speed
    16511591            ('d', Cell 0; in=sage?, out=)
    16521592            sage: C.set_introspect_html('foobar')
    16531593            sage: C.introspect_html()
    1654             '<div class="docstring"><pre>foobar</pre></div>'
     1594            'foobar'
    16551595            sage: C.set_introspect_html('`foobar`')
    16561596            sage: C.introspect_html()
    1657             '<div class="docstring">...<span class="math">foobar</span>...</div>'
     1597            '`foobar`'
     1598            sage: W.quit()
     1599            sage: nb.delete()
    16581600        """
    16591601        self.__introspect_html = html
    16601602        self.introspection_status = 'done'
    1661        
     1603
    16621604    def get_introspection_status(self):
    16631605        try:
    16641606            return self.__introspection_status
    class Cell(Cell_generic): 
    16691611        self.__introspection_status = value
    16701612
    16711613    introspection_status = property(get_introspection_status, set_introspection_status)
    1672        
    1673        
     1614
     1615
    16741616    def introspect_html(self):
    16751617        """
    16761618        Returns HTML for introspection.
    16771619
    16781620        EXAMPLES::
    1679        
    1680             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1621
     1622            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16811623            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    16821624            sage: W = nb.create_new_worksheet('Test', 'sage')
    16831625            sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
    16841626            sage: C.introspect()
    16851627            False
    16861628            sage: C.evaluate(username='sage')
    1687             sage: W.check_comp(9999)
     1629            sage: W.check_comp(9999)     # random output -- depends on computer speed
    16881630            ('d', Cell 0; in=sage?, out=)
    1689             sage: C.introspect_html()
    1690             u'<div class="docstring">...</pre></div>'
     1631            sage: C.introspect_html()     # random output -- depends on computer speed
     1632            u'...<div class="docstring">...sage...</pre></div>...'
     1633            sage: W.quit()
     1634            sage: nb.delete()
    16911635        """
    16921636        if not self.introspect():
    16931637            return ''
    class Cell(Cell_generic): 
    17001644    def introspect(self):
    17011645        """
    17021646        Returns self's introspection text.
    1703        
     1647
    17041648        EXAMPLES::
    17051649
    1706             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1650            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17071651            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17081652            sage: W = nb.create_new_worksheet('Test', 'sage')
    17091653            sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
    17101654            sage: C.introspect()
    17111655            False
    17121656            sage: C.evaluate(username='sage')
    1713             sage: W.check_comp(9999)
     1657            sage: W.check_comp(9999)     # random output -- depends on computer speed
    17141658            ('d', Cell 0; in=sage?, out=)
    17151659            sage: C.introspect()
    17161660            ['sage?', '']
     1661            sage: W.quit()
     1662            sage: nb.delete()
    17171663        """
    17181664        try:
    17191665            return self.__introspect
    class Cell(Cell_generic): 
    17231669    def unset_introspect(self):
    17241670        """
    17251671        Unsets self's introspection text.
    1726        
     1672
    17271673        EXAMPLES::
    17281674
    1729             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1675            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17301676            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17311677            sage: W = nb.create_new_worksheet('Test', 'sage')
    17321678            sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
    17331679            sage: C.introspect()
    17341680            False
    17351681            sage: C.evaluate(username='sage')
    1736             sage: W.check_comp(9999)
     1682            sage: W.check_comp(9999)     # random output -- depends on computer speed
    17371683            ('d', Cell 0; in=sage?, out=)
    17381684            sage: C.introspect()
    17391685            ['sage?', '']
    17401686            sage: C.unset_introspect()
    17411687            sage: C.introspect()
    17421688            False
     1689            sage: W.quit()
     1690            sage: nb.delete()
    17431691        """
    17441692        self.__introspect = False
    17451693
    17461694    def set_introspect(self, before_prompt, after_prompt):
    17471695        """
    17481696        Set self's introspection text.
    1749        
     1697
    17501698        EXAMPLES::
    1751        
     1699
    17521700            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    17531701            sage: C.set_introspect("a", "b")
    17541702            sage: C.introspect()
    class Cell(Cell_generic): 
    17591707    def evaluate(self, introspect=False, time=None, username=None):
    17601708        r"""
    17611709        INPUT:
    1762        
    1763        
     1710
    17641711        -  ``username`` - name of user doing the evaluation
    1765        
     1712
    17661713        -  ``time`` - if True return time computation takes
    1767        
     1714
    17681715        -  ``introspect`` - either False or a pair
    17691716           [before_cursor, after_cursor] of strings.
    1770        
    1771        
     1717
    17721718        EXAMPLES:
    17731719
    17741720        We create a notebook, worksheet, and cell and evaluate it
    17751721        in order to compute `3^5`::
    1776        
    1777             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1722
     1723            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17781724            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17791725            sage: W = nb.create_new_worksheet('Test', 'sage')
    1780             sage: W.edit_save('Sage\n{{{\n3^5\n}}}')
     1726            sage: W.edit_save('{{{\n3^5\n}}}')
    17811727            sage: C = W.cell_list()[0]; C
    17821728            Cell 0; in=3^5, out=
    17831729            sage: C.evaluate(username='sage')
    1784             sage: W.check_comp(wait=9999)
     1730            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    17851731            ('d', Cell 0; in=3^5, out=
    17861732            243
    17871733            )
    1788             sage: C
     1734            sage: C     # random output -- depends on computer speed
    17891735            Cell 0; in=3^5, out=
    1790             243       
    1791        
    1792         ::
    1793        
    1794             sage: import shutil; shutil.rmtree(nb.directory())
     1736            243
     1737            sage: W.quit()
     1738            sage: nb.delete()
    17951739        """
    17961740        self.__interrupted = False
    17971741        self.__evaluated = True
    class Cell(Cell_generic): 
    18101754                    shutil.rmtree(F)
    18111755                except:
    18121756                    pass
    1813                
     1757
    18141758    def version(self):
    18151759        """
    18161760        Returns the version number of this cell.
    1817        
     1761
    18181762        EXAMPLES::
    1819        
     1763
    18201764            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    18211765            sage: C.version()
    18221766            0
    class Cell(Cell_generic): 
    18341778        r"""
    18351779        Returns True if the time it takes to evaluate this cell should be
    18361780        printed.
    1837        
     1781
    18381782        EXAMPLES::
    1839        
     1783
    18401784            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    18411785            sage: C.time()
    18421786            False
    class Cell(Cell_generic): 
    18741818        if div_wrap:
    18751819            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>'
    18761820        return s
    1877    
     1821
    18781822    def html(self, wrap=None, div_wrap=True, do_print=False):
    18791823        r"""
    18801824        Returns the HTML for self.
    class Cell(Cell_generic): 
    18911835
    18921836        EXAMPLES::
    18931837
    1894             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1838            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    18951839            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    18961840            sage: W = nb.create_new_worksheet('Test', 'sage')
    18971841            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    19221866
    19231867        if div_wrap:
    19241868            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>'
    1925            
     1869
    19261870        #self._html_cache[key] = s
    19271871        return s
    19281872
    19291873    def html_in(self, do_print=False, ncols=80):
    19301874        """
    19311875        Returns the HTML code for the input of this cell.
    1932        
     1876
    19331877        EXAMPLES::
    1934        
     1878
    19351879            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    19361880            sage: print C.html_in()
    1937             <div class="insert_new_cell" id="insert_new_cell_0"...</a>
     1881            <div class="insert_new_cell" id="insert_new_cell_before0"...</a>
    19381882        """
    19391883        s = ''
    19401884        id = self.__id
    19411885        t = self.__in.rstrip()
    19421886
    19431887        cls = "cell_input_hide" if 'hide' in self.percent_directives() else "cell_input"
    1944    
     1888
    19451889        if not do_print:
    19461890            s += self.html_new_cell_before()
    19471891
    class Cell(Cell_generic): 
    19691913           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)
    19701914
    19711915        t = escape(t)+" "
    1972        
     1916
    19731917        return s
    19741918
    19751919
    class Cell(Cell_generic): 
    19781922        Returns a notebook URL for this cell.
    19791923
    19801924        EXAMPLES::
    1981        
    1982             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1925
     1926            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    19831927            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    19841928            sage: W = nb.create_new_worksheet('Test', 'sage')
    19851929            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    19861930            sage: C.url_to_self()
    19871931            '/home/sage/0/cells/0'
    1988        
    19891932        """
    19901933        try:
    19911934            return self.__url_to_self
    class Cell(Cell_generic): 
    19961939    def files(self):
    19971940        """
    19981941        Returns a list of all the files in self's directory.
    1999        
     1942
    20001943        EXAMPLES::
    2001        
    2002             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1944
     1945            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    20031946            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    20041947            sage: W = nb.create_new_worksheet('Test', 'sage')
    20051948            sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
    20061949            sage: C.evaluate()
    2007             sage: W.check_comp(wait=9999)
     1950            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    20081951            ('d', Cell 0; in=plot(sin(x),0,5), out=
    20091952            <html><font color='black'><img src='cell://sage0.png'></font></html>
    20101953            <BLANKLINE>
    20111954            )
    2012             sage: C.files()
     1955            sage: C.files()     # random output -- depends on computer speed
    20131956            ['sage0.png']
    2014        
    2015         ::
    2016        
    2017             sage: import shutil; shutil.rmtree(nb.directory())
     1957            sage: W.quit()
     1958            sage: nb.delete()
    20181959        """
    20191960        dir = self.directory()
    20201961        D = os.listdir(dir)
    class Cell(Cell_generic): 
    20231964    def delete_files(self):
    20241965        """
    20251966        Deletes all of the files associated with this cell.
    2026        
     1967
    20271968        EXAMPLES::
    2028        
    2029             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1969
     1970            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    20301971            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    20311972            sage: W = nb.create_new_worksheet('Test', 'sage')
    20321973            sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
    20331974            sage: C.evaluate()
    2034             sage: W.check_comp(wait=9999)
     1975            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    20351976            ('d', Cell 0; in=plot(sin(x),0,5), out=
    20361977            <html><font color='black'><img src='cell://sage0.png'></font></html>
    20371978            <BLANKLINE>
    20381979            )
    2039             sage: C.files()
     1980            sage: C.files()     # random output -- depends on computer speed
    20401981            ['sage0.png']
    20411982            sage: C.delete_files()
    20421983            sage: C.files()
    20431984            []
     1985            sage: W.quit()
     1986            sage: nb.delete()
    20441987        """
    20451988        try:
    20461989            dir = self._directory_name()
    class Cell(Cell_generic): 
    20622005
    20632006        EXAMPLES::
    20642007
    2065             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     2008            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    20662009            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    20672010            sage: W = nb.create_new_worksheet('Test', 'sage')
    20682011            sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
    20692012            sage: C.evaluate()
    2070             sage: W.check_comp(wait=9999)
     2013            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    20712014            ('d', Cell 0; in=plot(sin(x),0,5), out=
    20722015            <html><font color='black'><img src='cell://sage0.png'></font></html>
    20732016            <BLANKLINE>
    20742017            )
    2075             sage: C.files_html('')
     2018            sage: C.files_html('')     # random output -- depends on computer speed
    20762019            '<img src="/home/sage/0/cells/0/sage0.png?...">'
     2020            sage: W.quit()
     2021            sage: nb.delete()
    20772022        """
    20782023        import time
    20792024        D = self.files()
    class Cell(Cell_generic): 
    21132058                    jmol_file = open(jmol_name, 'r')
    21142059                    jmol_script = jmol_file.read()
    21152060                    jmol_file.close()
    2116                    
     2061
    21172062                    jmol_script = jmol_script.replace('defaultdirectory "', 'defaultdirectory "' + self.url_to_self() + '/')
    21182063
    21192064                    jmol_file = open(jmol_name, 'w')
    21202065                    jmol_file.write(jmol_script)
    21212066                    jmol_file.close()
    2122                    
     2067
    21232068                script = '<div><script>jmol_applet(%s, "%s?%d");</script></div>' % (size, url, time.time())
    21242069                images.append(script)
    21252070            elif F.endswith('.jmol.zip'):
    class Cell(Cell_generic): 
    21472092        Returns the HTML for self's output.
    21482093
    21492094        INPUT:
    2150        
     2095
    21512096        - ``do_print`` -- a boolean stating whether to output HTML
    21522097          for print
    21532098
    class Cell(Cell_generic): 
    21552100
    21562101        EXAMPLES::
    21572102
    2158             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     2103            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    21592104            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    21602105            sage: W = nb.create_new_worksheet('Test', 'sage')
    21612106            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    21642109        """
    21652110        if do_print and self.cell_output_type() == 'hidden':
    21662111            return '<pre>\n</pre>'
    2167        
     2112
    21682113        out_nowrap = self.output_text(0, html=True)
    21692114
    21702115        out_html = self.output_html()
    class Cell(Cell_generic): 
    21722117            out_wrap = out_nowrap
    21732118        else:
    21742119            out_wrap = self.output_text(ncols, html=True)
    2175            
     2120
    21762121        typ = self.cell_output_type()
    2177        
     2122
    21782123        if self.computing():
    21792124            cls = "cell_div_output_running"
    21802125        else:
    class Cell(Cell_generic): 
    22002145            out = out_wrap + out_html
    22012146        else:
    22022147            out = out_wrap + out_nowrap + out_html
    2203            
     2148
    22042149        s = top + out + '</div>'
    22052150
    22062151        r = ''
    class Cell(Cell_generic): 
    22172162                   r, s)
    22182163
    22192164        return tbl
    2220    
     2165
    22212166
    22222167
    22232168########
    class Cell(Cell_generic): 
    22252170def format_exception(s0, ncols):
    22262171    r"""
    22272172    Make it so exceptions don't appear expanded by default.
    2228    
     2173
    22292174    INPUT:
    2230    
    2231    
    2232     -  ``s0`` - string
    2233    
    2234     -  ``ncols`` - integer
    2235    
    2236    
    2237     OUTPUT: string
    2238    
    2239     If s0 contains "notracebacks" then this function always returns s0
    2240    
     2175
     2176    - ``s0`` - string
     2177
     2178    - ``ncols`` - integer
     2179
     2180    OUTPUT:
     2181
     2182    - a string
     2183
     2184    If s0 contains "notracebacks" then this function always returns
     2185    s0.
     2186
    22412187    EXAMPLES::
    2242    
     2188
    22432189        sage: sagenb.notebook.cell.format_exception(sagenb.notebook.cell.TRACEBACK,80)
    22442190        '\nTraceback (click to the left of this block for traceback)\n...\nTraceback (most recent call last):'
    22452191        sage: sagenb.notebook.cell.format_exception(sagenb.notebook.cell.TRACEBACK + "notracebacks",80)
    22462192        'Traceback (most recent call last):notracebacks'
    22472193    """
    22482194    s = s0.lstrip()
    2249     # Add a notracebacks option -- if it is in the string then tracebacks aren't shrunk.
    2250     # This is currently used by the sage.server.support.help command.
     2195    # Add a notracebacks option -- if it is in the string then
     2196    # tracebacks aren't shrunk.  This is currently used by the
     2197    # sage.server.support.help command.
    22512198    if TRACEBACK not in s or 'notracebacks' in s:
    22522199        return s0
    22532200    if ncols > 0:
    def format_exception(s0, ncols): 
    22612208        s = s.replace("exec compile(ur'","")
    22622209        s = s.replace("' + '\\n', '', 'single')", "")
    22632210    return s
    2264    
     2211
    22652212ComputeCell=Cell
    22662213
    2267    
     2214
    22682215def number_of_rows(txt, ncols):
    22692216    r"""
    22702217    Returns the number of rows needed to display the string in txt if
    22712218    there are a maximum of ncols columns per row.
    2272    
     2219
    22732220    EXAMPLES::
    2274    
     2221
    22752222        sage: from sagenb.notebook.cell import number_of_rows
    22762223        sage: s = "asdfasdf\nasdfasdf\n"
    22772224        sage: number_of_rows(s, 8)
  • sagenb/notebook/interact.py

    diff --git a/sagenb/notebook/interact.py b/sagenb/notebook/interact.py
    a b class ColorInput(InputBox): 
    10441044        EXAMPLES::
    10451045
    10461046            sage: sagenb.notebook.interact.ColorInput('c', Color('red')).render()
    1047             '<table>...'
     1047            '...<table>...'
    10481048            """
    10491049        return html_color_selector('color-selector-%s-%s'%(self.var(),
    10501050                                                           self.cell_id()),
    def interact(f): 
    24212421
    24222422        sage: v = []
    24232423        sage: html('<h2>Quadratic Root Etch-a-sketch</h2>')
    2424         <html><h2>Quadratic Root Etch-a-sketch</h2></html>
     2424        <html>...<h2>Quadratic Root Etch-a-sketch</h2>...</html>
    24252425        sage: @interact
    24262426        ... def _(a=[-10..10], b=[-10..10], c=[-10..10]):
    24272427        ...       f = a*x^2 + b*x + c == 0; show(f)
    def list_of_first_n(v,n): 
    35883588
    35893589    EXAMPLES::
    35903590
    3591         sage: sagenb.notebook.interact.list_of_first_n(Primes(), 10)
     3591        sage: from itertools import takewhile
     3592        sage: p100 = takewhile(lambda x: x < 100, Primes())
     3593        sage: sagenb.notebook.interact.list_of_first_n(p100, 10)
    35923594        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
    35933595        sage: sagenb.notebook.interact.list_of_first_n((1..5), 10)
    35943596        [1, 2, 3, 4, 5]
  • sagenb/notebook/notebook.py

    diff --git a/sagenb/notebook/notebook.py b/sagenb/notebook/notebook.py
    a b USE_REFERENCE_WORKSHEET_PROCESSES = Fals 
    2121# System libraries
    2222import os
    2323import random
    24 import re 
     24import re
    2525import shutil
    2626import socket
    2727import time
    class Notebook(object): 
    9999        for username in self.__users.keys():
    100100            for w in S.worksheets(username):
    101101                W['%s/%s'%(username, w.id_number())] = w
    102                
     102
    103103        self.__worksheets = W
    104        
     104
    105105    def delete(self):
    106106        """
    107107        Delete all files related to this notebook.
    108        
     108
    109109        This is used for doctesting mainly. This command is obviously
    110110        *VERY* dangerous to use on a notebook you actually care about.
    111111        You could easily lose all data.
    112        
     112
    113113        EXAMPLES::
    114        
    115             sage: tmp = tmp_dir()
    116             sage: nb = sagenb.notebook.notebook.Notebook(tmp) 
    117             sage: sorted(os.listdir(tmp)) 
    118             ['backups', 'nb2.sobj', 'objects', 'worksheets']
     114
     115            sage: tmp = tmp_dir() + '.sagenb'
     116            sage: nb = sagenb.notebook.notebook.Notebook(tmp)
     117            sage: sorted(os.listdir(tmp))
     118            ['home']
    119119            sage: nb.delete()
    120        
    121         Now the directory is gone.
    122        
    123         ::
    124        
     120
     121        Now the directory is gone.::
     122
    125123            sage: os.listdir(tmp)
    126124            Traceback (most recent call last):
    127125            ...
    class Notebook(object): 
    134132
    135133    def system_names(self):
    136134        return SYSTEM_NAMES
    137    
     135
    138136    ##########################################################
    139137    # Users
    140138    ##########################################################
    141139    def create_default_users(self, passwd):
    142140        """
    143141        Create the default users for a notebook.
    144        
     142
    145143        INPUT:
    146144
    147145        -  ``passwd`` - a string
    148        
     146
    149147        EXAMPLES::
    150        
    151             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     148
     149            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    152150            sage: nb.create_default_users('password')
    153151            Creating default users.
    154152            sage: list(sorted(nb.users().iteritems()))
    class Notebook(object): 
    173171    def user_exists(self, username):
    174172        """
    175173        Return whether a user with the given ``username`` exists.
    176        
     174
    177175        INPUT:
    178176
    179177        - ``username`` - a string
    class Notebook(object): 
    183181        - a bool
    184182
    185183        EXAMPLES::
    186        
    187             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     184
     185            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    188186            sage: nb.create_default_users('password')
    189187            Creating default users.
    190188            sage: nb.user_exists('admin')
    class Notebook(object): 
    197195            True
    198196        """
    199197        return username in self.users()
    200            
     198
    201199    def users(self):
    202200        """
    203201        Return a dictionary of users in a notebook.
    204        
     202
    205203        OUTPUT:
    206204
    207205        - a string:User instance dictionary
    208206
    209207        EXAMPLES::
    210        
    211             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     208
     209            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    212210            sage: nb.create_default_users('password')
    213211            Creating default users.
    214212            sage: list(sorted(nb.users().iteritems()))
    class Notebook(object): 
    224222        """
    225223        Return an instance of the User class given the ``username`` of a user
    226224        in a notebook.
    227        
     225
    228226        INPUT:
    229227
    230228        - ``username`` - a string
    class Notebook(object): 
    234232        - an instance of User
    235233
    236234        EXAMPLES::
    237        
    238             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     235
     236            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    239237            sage: nb.create_default_users('password')
    240238            Creating default users.
    241239            sage: nb.user('admin')
    242240            admin
    243             sage: nb.user('admin')._User__email
     241            sage: nb.user('admin').get_email()
    244242            ''
    245             sage: nb.user('admin')._User__password
     243            sage: nb.user('admin').password()
    246244            'aajfMKNH1hTm2'
    247245        """
    248246        if not isinstance(username, str) or '/' in username:
    class Notebook(object): 
    264262    def create_user_with_same_password(self, user, other_user):
    265263        r"""
    266264        Change the password of ``user`` to that of ``other_user``.
    267        
     265
    268266        INPUT:
    269        
     267
    270268        -  ``user`` - a string
    271        
     269
    272270        -  ``other_user`` - a string
    273        
     271
    274272        EXAMPLES::
    275        
    276             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     273
     274            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    277275            sage: nb.add_user('bob', 'an**d', 'bob@gmail.com', force=True)
    278276            sage: nb.user('bob').password()
    279277            'aa4Q6Jbx/MiUs'
    class Notebook(object): 
    296294        INPUT:
    297295
    298296        - ``user`` - an instance of User
    299        
     297
    300298        OUTPUT:
    301        
     299
    302300        - a bool
    303301
    304302        EXAMPLES::
    305        
    306             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     303
     304            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    307305            sage: nb.add_user('Administrator', 'password', '', 'admin', True)
    308306            sage: nb.add_user('RegularUser', 'password', '', 'user', True)
    309307            sage: nb.user_is_admin('Administrator')
    class Notebook(object): 
    320318        INPUT:
    321319
    322320        - ``username`` - a string
    323        
     321
    324322        OUTPUT:
    325323
    326324        - a bool
    327325
    328326        EXAMPLES::
    329        
    330             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     327
     328            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    331329            sage: nb.create_default_users('password')
    332330            Creating default users.
    333331            sage: nb.user_is_guest('guest')
    class Notebook(object): 
    339337            return self.user(username).is_guest()
    340338        except KeyError:
    341339            return False
    342    
     340
    343341    def user_list(self):
    344342        """
    345343        Return a list of user objects.
    346        
     344
    347345        OUTPUT:
    348346
    349347        - a list of User instances
    350348
    351349        EXAMPLES::
    352        
    353             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     350
     351            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    354352            sage: nb.create_default_users('password')
    355353            Creating default users.
    356354            sage: sorted(nb.user_list(), key=lambda k: k.username())
    class Notebook(object): 
    361359    def usernames(self):
    362360        """
    363361        Return a list of usernames.
    364        
     362
    365363        OUTPUT:
    366364
    367365        - a list of strings
    368366
    369367        EXAMPLES::
    370        
    371             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     368
     369            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    372370            sage: nb.create_default_users('password')
    373371            Creating default users.
    374372            sage: sorted(nb.usernames())
    class Notebook(object): 
    380378    def valid_login_names(self):
    381379        """
    382380        Return a list of users that can log in.
    383        
     381
    384382        OUTPUT:
    385383
    386384        - a list of strings
    387385
    388386        EXAMPLES::
    389        
    390             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     387
     388            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    391389            sage: nb.create_default_users('password')
    392390            Creating default users.
    393391            sage: nb.valid_login_names()
    class Notebook(object): 
    406404        confronted with the Sage notebook login page.  Currently, this
    407405        returns 'admin' if that is the *only* user.  Otherwise it
    408406        returns an empty string ('').
    409        
     407
    410408        OUTPUT:
    411409
    412         - a string - the default username. 
    413        
     410        - a string - the default username.
     411
    414412        EXAMPLES::
    415        
    416             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     413
     414            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    417415            sage: nb.create_default_users('password')
    418416            Creating default users.
    419417            sage: nb.default_user()
    class Notebook(object): 
    432430        Set the accounts attribute of the server configuration to
    433431        ``value``.  This property determines whether users can create
    434432        new accounts.
    435        
     433
    436434        INPUT:
    437        
     435
    438436        - ``value`` - a bool
    439437
    440438        EXAMPLES::
    441        
    442             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     439
     440            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    443441            sage: nb.get_accounts()
    444442            False
    445443            sage: nb.set_accounts(True)
    class Notebook(object): 
    453451
    454452    def get_accounts(self):
    455453        r"""
    456         Return whether or not users can create new accounts. 
    457        
     454        Return whether or not users can create new accounts.
     455
    458456        OUTPUT:
    459457
    460458        - a bool
    461459
    462460        EXAMPLES::
    463        
    464             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     461
     462            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    465463            sage: nb.get_accounts()
    466464            False
    467465            sage: nb.set_accounts(True)
    class Notebook(object): 
    475473        Add a user with the given credentials.
    476474
    477475        INPUT:
    478        
     476
    479477        -  ``username`` - the username
    480        
     478
    481479        -  ``password`` - the password
    482        
     480
    483481        -  ``email`` - the email address
    484        
     482
    485483        -  ``account_type`` - one of 'user', 'admin', or 'guest'
    486        
     484
    487485        -  ``force`` - a bool (default: False)
    488        
     486
    489487        If the method :meth:`get_accounts` returns False then user can
    490488        only be added if ``force`` is True.
    491489
    492490        EXAMPLES::
    493        
    494             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     491
     492            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    495493            sage: nb.add_user('Mark', 'password', '', force=True)
    496494            sage: nb.user('Mark')
    497495            Mark
    class Notebook(object): 
    505503        """
    506504        if not self.get_accounts() and not force:
    507505            raise ValueError, "creating new accounts disabled."
    508                                  
     506
    509507        us = self.users()
    510508        if us.has_key(username):
    511509            print "WARNING: User '%s' already exists -- and is now being replaced."%username
    class Notebook(object): 
    514512
    515513        # Save the user database
    516514        self.__storage.save_users(self.users())
    517        
     515
    518516
    519517    def change_password(self, username, password):
    520518        """
    521519        Change a user's password.
    522520
    523521        INPUT:
    524        
     522
    525523        - ``username`` - a string, the username
    526        
     524
    527525        - ``password`` - a string, the user's new password
    528        
     526
    529527        EXAMPLES::
    530        
    531             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     528
     529            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    532530            sage: nb.add_user('Mark', 'password', '', force=True)
    533531            sage: nb.user('Mark').password()
    534532            'aajfMKNH1hTm2'
    class Notebook(object): 
    541539    def del_user(self, username):
    542540        """
    543541        Delete the given user.
    544        
     542
    545543        INPUT:
    546544
    547545        - ``username`` - a string
    548546
    549547        EXAMPLES::
    550        
    551             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     548
     549            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    552550            sage: nb.add_user('Mark', 'password', '', force=True)
    553551            sage: nb.user('Mark')
    554552            Mark
    class Notebook(object): 
    564562    def passwords(self):
    565563        """
    566564        Return a username:password dictionary.
    567        
     565
    568566        OUTPUT:
    569567
    570568        - a string:string dictionary
    571569
    572570        EXAMPLES::
    573        
    574             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     571
     572            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    575573            sage: nb.create_default_users('password')
    576574            Creating default users.
    577575            sage: nb.add_user('Mark', 'password', '', force=True)
    class Notebook(object): 
    583581    def user_conf(self, username):
    584582        """
    585583        Return a user's configuration object.
    586        
     584
    587585        OUTPUT:
    588586
    589587        - an instance of Configuration.
    590588
    591589        EXAMPLES::
    592        
    593             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     590
     591            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    594592            sage: nb.create_default_users('password')
    595593            Creating default users.
    596594            sage: config = nb.user_conf('admin')
    597595            sage: config['max_history_length']
    598596            1000
    599             sage: config['system']
     597            sage: config['default_system']
    600598            'sage'
    601599            sage: config['autosave_interval']
    602600            3600
    603601            sage: config['default_pretty_print']
    604602            False
    605         """       
     603        """
    606604        return self.users()[username].conf()
    607605
    608606    ##########################################################
    class Notebook(object): 
    638636        r"""
    639637        Publish a user's worksheet.  This creates a new worksheet in
    640638        the 'pub' directory with the same contents as ``worksheet``.
    641        
     639
    642640        INPUT:
    643641
    644642        - ``worksheet`` - an instance of Worksheet
    class Notebook(object): 
    650648        - a new or existing published instance of Worksheet
    651649
    652650        EXAMPLES::
    653        
    654             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     651
     652            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    655653            sage: nb.add_user('Mark','password','',force=True)
    656654            sage: W = nb.new_worksheet_with_title_from_text('First steps', owner='Mark')
    657655            sage: nb.worksheet_names()
    658656            ['Mark/0']
    659657            sage: nb.publish_worksheet(nb.get_worksheet_with_filename('Mark/0'), 'Mark')
    660             <BLANKLINE>
    661             [Cell 0; in=, out=]
     658            pub/1: [Cell 1; in=, out=]
    662659            sage: sorted(nb.worksheet_names())
    663             ['Mark/0', 'pub/0']
     660            ['Mark/0', 'pub/1']
    664661        """
    665662        for X in self.__worksheets.itervalues():
    666663            if X.is_published() and X.worksheet_that_was_published() == worksheet:
    class Notebook(object): 
    752749    def empty_trash(self, username):
    753750        """
    754751        Empty the trash for the given user.
    755        
     752
    756753        INPUT:
    757        
     754
    758755        -  ``username`` - a string
    759        
     756
    760757        This empties the trash for the given user and cleans up all files
    761758        associated with the worksheets that are in the trash.
    762        
     759
    763760        EXAMPLES::
    764        
    765             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     761
     762            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    766763            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    767764            sage: W = nb.new_worksheet_with_title_from_text('Sage', owner='sage')
    768765            sage: W.move_to_trash('sage')
    class Notebook(object): 
    782779    def worksheet_names(self):
    783780        """
    784781        Return a list of all the names of worksheets in this notebook.
    785        
     782
    786783        OUTPUT:
    787784
    788785        - a list of strings.
    789        
    790         EXAMPLES: 
     786
     787        EXAMPLES:
    791788
    792789        We make a new notebook with two users and two worksheets,
    793790        then list their names::
    794        
    795             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     791
     792            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    796793            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    797794            sage: W = nb.new_worksheet_with_title_from_text('Sage', owner='sage')
    798795            sage: nb.add_user('wstein','sage','wstein@sagemath.org',force=True)
    799796            sage: W2 = nb.new_worksheet_with_title_from_text('Elliptic Curves', owner='wstein')
    800797            sage: nb.worksheet_names()
    801             ['sage/0', 'wstein/0']
     798            ['sage/0', 'wstein/1']
    802799        """
    803800        W = self.__worksheets.keys()
    804801        W.sort()
    class Notebook(object): 
    807804
    808805    ##########################################################
    809806    # Information about the pool of worksheet compute servers
    810     ##########################################################   
     807    ##########################################################
    811808
    812809    def server_pool(self):
    813810        return self.conf()['server_pool']
    class Notebook(object): 
    852849        ulimit = self.get_ulimit()
    853850        from sagenb.interfaces import ProcessLimits
    854851        # We have to parse the ulimit format to our ProcessLimits.
    855         # The typical format is. 
     852        # The typical format is.
    856853        # '-u 400 -v 1000000 -t 3600'
    857854        # Despite -t being cputime for ulimit, we map it to walltime,
    858855        # since that is the only thing that really makes sense for a
    class Notebook(object): 
    868865                if x.startswith(k): tbl[k] = int(x.split()[1].strip())
    869866        if tbl['v'] is not None:
    870867            tbl['v'] = tbl['v']/1000.0
    871            
    872                
     868
     869
    873870        process_limits = ProcessLimits(max_vmem=tbl['v'], max_walltime=tbl['t'],
    874871                                       max_processes=tbl['u'])
    875        
     872
    876873        server_pool = self.server_pool()
    877874        if not server_pool or len(server_pool) == 0:
    878875            return WorksheetProcess_ExpectImplementation(process_limits=process_limits)
    class Notebook(object): 
    883880            return WorksheetProcess_RemoteExpectImplementation(user_at_host=user_at_host,
    884881                             process_limits=process_limits,
    885882                             remote_python=python_command)
    886        
    887    
     883
     884
    888885    def _python_command(self):
    889886        """
    890887        """
    891888        try: return self.__python_command
    892889        except AttributeError: pass
    893        
    894            
    895        
     890
     891
     892
    896893    ##########################################################
    897894    # The default math software system for new worksheets for
    898895    # a given user or the whole notebook (if username is None).
    899896    ##########################################################
    900    
     897
    901898    def system(self, username=None):
    902899        return self.user(username).conf()['default_system']
    903900
    class Notebook(object): 
    905902    # The default typeset setting for new worksheets for
    906903    # a given user or the whole notebook (if username is None).
    907904    ##########################################################
    908    
     905
    909906    # TODO -- only implemented for the notebook right now
    910907    def pretty_print(self, username=None):
    911908        return self.user(username).conf()['default_pretty_print']
    class Notebook(object): 
    946943        W = self.create_new_worksheet(name, username)
    947944        W.edit_save('Log Worksheet\n' + self.user_history_text(username, maxlen=None))
    948945        return W
    949        
     946
    950947    def user_history_text(self, username, maxlen=None):
    951948        history = self.user_history(username)
    952949        if maxlen:
    class Notebook(object): 
    967964    def export_worksheet(self, worksheet_filename, output_filename, title=None):
    968965        """
    969966        Export a worksheet, creating a sws file on the file system.
    970        
     967
    971968        INPUT:
    972        
     969
    973970            -  ``worksheet_filename`` - a string e.g., 'username/id_number'
    974        
     971
    975972            -  ``output_filename`` - a string, e.g., 'worksheet.sws'
    976973
    977974            - ``title`` - title to use for the exported worksheet (if
    class Notebook(object): 
    997994            - ``id_number`` - nonnegative integer or None (default)
    998995        """
    999996        S = self.__storage
    1000         if id_number is None:       
     997        if id_number is None:
    1001998            id_number = self.new_id_number(username)
    1002999        return S.load_worksheet(username, id_number)
    1003        
     1000
    10041001    def new_id_number(self, username):
    10051002        """
    10061003        Find the next worksheet id for the given user.
    class Notebook(object): 
    10281025        Import a worksheet with the given ``filename`` and set its
    10291026        ``owner``.  If the file extension is not txt or sws, raise a
    10301027        ValueError.
    1031        
     1028
    10321029        INPUT:
    1033        
     1030
    10341031        -  ``filename`` - a string
    1035        
     1032
    10361033        -  ``owner`` - a string
    1037        
     1034
    10381035        OUTPUT:
    1039        
     1036
    10401037        -  ``worksheet`` - a newly created Worksheet instance
    1041        
    1042         EXAMPLES: 
     1038
     1039        EXAMPLES:
    10431040
    10441041        We create a notebook and import a plain text worksheet
    10451042        into it.
    1046        
     1043
    10471044        ::
    1048        
    1049             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
    1050             sage: name = tmp_filename() + '.txt' 
     1045
     1046            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
     1047            sage: name = tmp_filename() + '.txt'
    10511048            sage: open(name,'w').write('foo\n{{{\n2+3\n}}}')
    10521049            sage: W = nb.import_worksheet(name, 'admin')
    1053        
     1050
    10541051        W is our newly-created worksheet, with the 2+3 cell in it::
    1055        
     1052
    10561053            sage: W.name()
    10571054            'foo'
    10581055            sage: W.cell_list()
    1059             [Cell 0; in=2+3, out=]
     1056            [TextCell 0: foo, Cell 1; in=2+3, out=]
    10601057        """
    10611058        if not os.path.exists(filename):
    10621059            raise ValueError, "no file %s"%filename
    class Notebook(object): 
    10741071            raise ValueError, "unknown extension '%s'"%ext
    10751072        self.__worksheets[W.filename()] = W
    10761073        return W
    1077            
     1074
    10781075    def _import_worksheet_txt(self, filename, owner):
    10791076        r"""
    10801077        Import a plain text file as a new worksheet.
    1081        
     1078
    10821079        INPUT:
    1083        
     1080
    10841081        -  ``filename`` - a string; a filename that ends in .txt
    1085        
     1082
    10861083        -  ``owner`` - a string; the imported worksheet's owner
    1087        
     1084
    10881085        OUTPUT:
    10891086
    10901087        -  a new instance of Worksheet
    1091        
    1092         EXAMPLES: 
     1088
     1089        EXAMPLES:
    10931090
    10941091        We write a plain text worksheet to a file and import it
    1095         using this function.
    1096        
    1097         ::
    1098        
    1099             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
    1100             sage: name = tmp_filename() + '.txt' 
     1092        using this function.::
     1093
     1094            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
     1095            sage: name = tmp_filename() + '.txt'
    11011096            sage: open(name,'w').write('foo\n{{{\na = 10\n}}}')
    11021097            sage: W = nb._import_worksheet_txt(name, 'admin'); W
    1103             [Cell 0; in=a = 10, out=]
     1098            admin/0: [TextCell 0: foo, Cell 1; in=a = 10, out=]
    11041099        """
    11051100        # Open the worksheet txt file and load it in.
    11061101        worksheet_txt = open(filename).read()
    class Notebook(object): 
    11091104        # Set the new worksheet to have the contents specified by that file.
    11101105        worksheet.edit_save(worksheet_txt)
    11111106        return worksheet
    1112    
    1113     def _import_worksheet_sws(self, filename, username, verbose=True):
     1107
     1108    def _import_worksheet_sws(self, filename, username):
    11141109        r"""
    11151110        Import an sws format worksheet into this notebook as a new
    1116         worksheet.  If the worksheet cannot be read, raise a
    1117         ValueError.
    1118        
     1111        worksheet.
     1112
    11191113        INPUT:
    1120        
     1114
    11211115        - ``filename`` - a string; a filename that ends in .sws;
    11221116           internally it must be a tar'd bz2'd file.
    1123        
     1117
    11241118        - ``username`` - a string
    1125        
    1126         - ``verbose`` - a bool (default: True) if True print some the
    1127            tar command used to extract the sws file.
    1128        
     1119
    11291120        OUTPUT:
    11301121
    11311122        - a new Worksheet instance
    1132        
    1133         EXAMPLES: We create a notebook, then make a worksheet from a plain
    1134         text file first.
    1135        
    1136         ::
    1137        
    1138             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
    1139             sage: name = tmp_filename() + '.txt' 
    1140             sage: open(name,'w').write('foo\n{{{\n2+3\n}}}')
     1123
     1124        EXAMPLES:
     1125
     1126        We create a notebook, then make a worksheet from a plain text
     1127        file first.::
     1128
     1129            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
     1130            sage: name = tmp_filename() + '.txt'
     1131            sage: open(name,'w').write('{{{id=0\n2+3\n}}}')
    11411132            sage: W = nb.import_worksheet(name, 'admin')
    11421133            sage: W.filename()
    11431134            'admin/0'
    1144        
    1145         We then export the worksheet to an sws file.
    1146        
    1147         ::
    1148        
    1149             sage: nb.export_worksheet(W.filename(),  'tmp.sws', verbose=False)
    1150        
    1151         Now we import the sws.
    1152        
    1153         ::
    1154        
    1155             sage: nb._import_worksheet_sws('tmp.sws', 'admin', verbose=False)
    1156             [Cell 0; in=2+3, out=]
    1157        
     1135
     1136        We then export the worksheet to an sws file.::
     1137
     1138            sage: sws = os.path.join(tmp_dir(), 'tmp.sws')
     1139            sage: nb.export_worksheet(W.filename(), sws)
     1140
     1141        Now we import the sws.::
     1142
     1143            sage: W = nb._import_worksheet_sws(sws, 'admin')
     1144            sage: nb._Notebook__worksheets[W.filename()] = W
     1145
    11581146        Yes, it's there now (as admin/2)::
    1159        
     1147
    11601148            sage: nb.worksheet_names()
    1161             ['admin/0', 'admin/2']
     1149            ['admin/0', 'admin/1']
    11621150        """
    11631151        id_number = self.new_id_number(username)
    11641152        worksheet = self.__storage.import_worksheet(username, id_number, filename)
    class Notebook(object): 
    11671155        # support multiple worksheets with the same title very well
    11681156        # already.  So it's commented out.
    11691157        # self.change_worksheet_name_to_avoid_collision(worksheet)
    1170        
     1158
    11711159        return worksheet
    11721160
    11731161    def change_worksheet_name_to_avoid_collision(self, worksheet):
    class Notebook(object): 
    11861174                i += 1
    11871175            name = name + " (%s)"%i
    11881176            worksheet.set_name(name)
    1189            
     1177
    11901178
    11911179    ##########################################################
    11921180    # Importing and exporting worksheets to a plain text format
    class Notebook(object): 
    11971185        Return HTML containing the plain text version of a worksheet.
    11981186
    11991187        INPUT:
    1200        
     1188
    12011189        - ``filename`` - a string; filename of a worksheet
    1202        
     1190
    12031191        - ``prompts`` - a bool (default: True); whether to format the
    12041192          text for inclusion in docstrings
    12051193
    12061194        OUTPUT:
    1207        
     1195
    12081196        - a string - the worksheet's HTML representation
    12091197        """
    12101198        worksheet = self.get_worksheet_with_filename(filename)
    class Notebook(object): 
    12481236            for W in self.__worksheets.itervalues():
    12491237                if W.docbrowser() and W.compute_process_has_been_started():
    12501238                    W.quit_if_idle(DOC_TIMEOUT)
    1251             return 
     1239            return
    12521240
    12531241        for W in self.__worksheets.itervalues():
    12541242            if W.compute_process_has_been_started():
    12551243                W.quit_if_idle(timeout)
    1256            
     1244
    12571245
    12581246    ##########################################################
    12591247    # Worksheet HTML generation
    class Notebook(object): 
    12631251        Return the HTML for a given worksheet.
    12641252
    12651253        INPUT:
    1266        
     1254
    12671255        - ``filename`` - a string; the worksheet's filename
    12681256
    12691257        - ``do_print`` - a bool (default: False); whether this is a
    12701258          printed worksheet
    12711259
    12721260        OUTPUT:
    1273        
     1261
    12741262        - a string - the worksheet rendered as HTML
    12751263
    12761264        EXAMPLES::
    1277        
    1278             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1265
     1266            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12791267            sage: W = nb.create_new_worksheet('Test', 'admin')
    12801268            sage: nb.worksheet_html(W.filename())
    12811269            '...<!D...Test...cell_id_list=[1]...</body>...</html>'
    class Notebook(object): 
    12861274                 worksheet_html = worksheet.html(include_title=False, do_print=do_print),
    12871275                        do_print = do_print)
    12881276
    1289    
     1277
    12901278
    12911279    def worksheet_list_for_public(self, username, sort='last_edited', reverse=False, search=None):
    12921280        W = [x for x in self.__worksheets.itervalues() if x.is_published() and not x.is_trashed(user)]
    class Notebook(object): 
    13181306        Return HTML for the revision list of a worksheet.
    13191307
    13201308        INPUT:
    1321        
     1309
    13221310        - ``username`` - a string
    1323        
     1311
    13241312        - ``worksheet`` - an instance of Worksheet
    13251313
    13261314        OUTPUT:
    class Notebook(object): 
    13281316        - a string - the HTML for the revision list
    13291317
    13301318        EXAMPLES::
    1331        
    1332             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1319
     1320            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13331321            sage: W = nb.create_new_worksheet('Test', 'admin')
     1322            sage: W.body()
     1323            '\n\n{{{id=1|\n\n///\n}}}'
     1324            sage: W.save_snapshot('admin')
    13341325            sage: nb.html_worksheet_revision_list('admin', W)
    13351326            '...Revision...Last Edited...seconds...ago...'
    13361327        """
    class Notebook(object): 
    13481339        Return the HTML for a specific revision of a worksheet.
    13491340
    13501341        INPUT:
    1351        
     1342
    13521343        - ``username`` - a string
    1353        
     1344
    13541345        - ``ws`` - an instance of Worksheet
    1355        
     1346
    13561347        - ``rev`` - a string containing the key of the revision
    13571348
    13581349        OUTPUT:
    1359        
     1350
    13601351        - a string - the revision rendered as HTML
    13611352        """
    13621353        t = time.time() - float(rev[:-4])
    13631354        time_ago = worksheet.convert_seconds_to_meaningful_time_span(t)
    1364        
     1355
    13651356        filename = ws.get_snapshot_text_filename(rev)
    13661357        txt = bz2.decompress(open(filename).read())
    13671358        W = self.scratch_worksheet()
    class Notebook(object): 
    13791370                if i < len(data)-1:
    13801371                    next_rev = data[i+1][1]
    13811372                break
    1382            
     1373
    13831374        return template(os.path.join("html", "notebook", "specific_revision.html"),
    13841375                        worksheet = ws, worksheet_filename = ws.filename(),
    13851376                        username = username, rev = rev, prev_rev = prev_rev,
    class Notebook(object): 
    13921383        Return the HTML for the "share" page of a worksheet.
    13931384
    13941385        INPUT:
    1395        
     1386
    13961387        - ``username`` - a string
    1397        
     1388
    13981389        - ``worksheet`` - an instance of Worksheet
    13991390
    14001391        OUTPUT:
    14011392
    14021393        - string - the share page's HTML representation
    1403        
     1394
    14041395        EXAMPLES::
    1405        
    1406             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1396
     1397            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14071398            sage: W = nb.create_new_worksheet('Test', 'admin')
    14081399            sage: nb.html_share(W, 'admin')
    14091400            '...currently shared...add or remove collaborators...'
    class Notebook(object): 
    14241415        Return the HTML for the download or delete datafile page.
    14251416
    14261417        INPUT:
    1427        
     1418
    14281419        - ``username`` - a string
    1429        
     1420
    14301421        - ``ws`` - an instance of Worksheet
    1431        
     1422
    14321423        - ``filename`` - a string; the name of the file
    14331424
    14341425        OUTPUT:
    1435        
     1426
    14361427        - a string - the page rendered as HTML
    14371428
    14381429        EXAMPLES::
    1439        
    1440             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1430
     1431            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14411432            sage: W = nb.create_new_worksheet('Test', 'admin')
    14421433            sage: nb.html_download_or_delete_datafile(W, 'admin', 'bar')
    14431434            '...Data file: bar...DATA is a special variable...uploaded...'
    class Notebook(object): 
    14471438        worksheets = self.get_worksheets_with_viewer(username)
    14481439        active_worksheets = [worksheet for worksheet in worksheets if worksheet.is_active(username)]
    14491440        sort_worksheet_list(active_worksheets, 'name', False)
    1450        
     1441
    14511442        ext = os.path.splitext(filename)[1].lower()
    14521443        file_is_image, file_is_text = False, False
    14531444        text_file_content = ""
    1454        
     1445
    14551446        if ext in ['.png', '.jpg', '.gif']:
    14561447            file_is_image = True
    14571448        if ext in ['.txt', '.tex', '.sage', '.spyx', '.py', '.f', '.f90', '.c']:
    class Notebook(object): 
    14701461
    14711462
    14721463    ##########################################################
    1473     # Accessing all worksheets with certain properties. 
     1464    # Accessing all worksheets with certain properties.
    14741465    ##########################################################
    14751466    def get_all_worksheets(self):
    14761467        return [x for x in self.__worksheets.itervalues() if not x.owner() in ['_sage_', 'pub']]
    1477    
     1468
    14781469    def get_worksheets_with_collaborator(self, user):
    1479         if self.user_is_admin(user): return self.get_all_worksheets()       
     1470        if self.user_is_admin(user): return self.get_all_worksheets()
    14801471        return [w for w in self.__worksheets.itervalues() if w.is_collaborator(user)]
    14811472
    14821473    def get_worksheet_names_with_collaborator(self, user):
    class Notebook(object): 
    14941485        return [w for w in self.get_worksheets_with_owner(owner) if w.is_viewer(user)]
    14951486
    14961487    def get_worksheet_names_with_viewer(self, user):
    1497         if self.user_is_admin(user): return [W.name() for W in self.get_all_worksheets()]       
     1488        if self.user_is_admin(user): return [W.name() for W in self.get_all_worksheets()]
    14981489        return [W.name() for W in self.get_worksheets_with_viewer(user) if not W.docbrowser()]
    14991490
    15001491    def get_worksheet_with_name(self, name):
    class Notebook(object): 
    15071498        """
    15081499        Get the worksheet with the given filename.  If there is no
    15091500        such worksheet, raise a ``KeyError``.
    1510        
     1501
    15111502        INPUT:
    15121503
    15131504        - ``filename`` - a string
    class Notebook(object): 
    15561547        Return the HTML for the debug window.
    15571548
    15581549        OUTPUT:
    1559        
     1550
    15601551        - a string - the debug window rendered as HTML
    1561    
     1552
    15621553        EXAMPLES::
    15631554
    1564             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1555            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15651556            sage: nb.html_debug_window()
    15661557            "\n<div class='debug_window'>...</div>"
    15671558        """
    15681559        return template(os.path.join("html", "notebook", "debug_window.html"))
    15691560
    1570    
     1561
    15711562    def html_plain_text_window(self, worksheet, username):
    15721563        r"""
    15731564        Return HTML for the window that displays a plain text version
    class Notebook(object): 
    15841575        - a string - the plain text window rendered as HTML
    15851576
    15861577        EXAMPLES::
    1587        
    1588             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1578
     1579            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15891580            sage: W = nb.create_new_worksheet('Test', 'admin')
    15901581            sage: nb.html_plain_text_window(W, 'admin')
    15911582            '...pre class="plaintext"...cell_intext...textfield...'
    15921583        """
    15931584        plain_text = worksheet.plain_text(prompts=True, banner=False)
    15941585        plain_text = escape(plain_text).strip()
    1595          
     1586
    15961587        return template(os.path.join("html", "notebook", "plain_text_window.html"),
    15971588                        worksheet = worksheet,
    15981589                        worksheet_filename = worksheet.filename(),
    15991590                        username = username, plain_text = plain_text,
    16001591                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1601                        
     1592
    16021593    def html_edit_window(self, worksheet, username):
    16031594        r"""
    16041595        Return HTML for a window for editing ``worksheet``.
    1605        
     1596
    16061597        INPUT:
    1607        
     1598
    16081599        - ``username`` - a string containing the username
    1609        
     1600
    16101601        - ``worksheet`` - a Worksheet instance
    16111602
    16121603        OUTPUT:
    1613        
     1604
    16141605        - a string - the editing window's HTML representation
    16151606
    16161607        EXAMPLES::
    1617        
    1618             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1608
     1609            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16191610            sage: W = nb.create_new_worksheet('Test', 'admin')
    16201611            sage: nb.html_edit_window(W, 'admin')
    16211612            '...textarea class="plaintextedit"...{{{id=1|...//...}}}...'
    class Notebook(object): 
    16231614        text = worksheet.edit_text()
    16241615        text = escape(text)
    16251616        n_lines = text.count("\n")+1
    1626          
     1617
    16271618        return template(os.path.join("html", "notebook", "edit_window.html"),
    16281619                        worksheet = worksheet,
    16291620                        worksheet_filename = worksheet.filename(),
    16301621                        username = username, text = text, n_lines = n_lines,
    16311622                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1632    
     1623
    16331624    def html_beforepublish_window(self, worksheet, username):
    16341625        r"""
    16351626        Return HTML for the warning and decision page displayed prior
    16361627        to publishing the given worksheet.
    1637        
     1628
    16381629        INPUT:
    1639        
     1630
    16401631        - ``worksheet`` - an instance of Worksheet
    1641        
     1632
    16421633        - ``username`` - a string
    16431634
    16441635        OUTPUT:
    class Notebook(object): 
    16461637        - a string - the pre-publication page rendered as HTML
    16471638
    16481639        EXAMPLES::
    1649        
    1650             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1640
     1641            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16511642            sage: W = nb.create_new_worksheet('Test', 'admin')
    16521643            sage: nb.html_beforepublish_window(W, 'admin')
    16531644            '...want to publish this worksheet?...re-publish when changes...'
    class Notebook(object): 
    16671658                        worksheet_filename = worksheet.filename(),
    16681659                        username = username,
    16691660                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1670        
     1661
    16711662    def html_afterpublish_window(self, worksheet, username, url, dtime):
    16721663        r"""
    16731664        Return HTML for a given worksheet's post-publication page.
    1674        
     1665
    16751666        INPUT:
    1676        
     1667
    16771668        - ``worksheet`` - an instance of Worksheet
    1678        
     1669
    16791670        - ``username`` - a string
    1680        
     1671
    16811672        - ``url`` - a string representing the URL of the published
    16821673          worksheet
    1683        
     1674
    16841675        - ``dtime`` - an instance of time.struct_time representing the
    16851676          publishing time
    16861677
    16871678        OUTPUT:
    16881679
    16891680        - a string - the post-publication page rendered as HTML
    1690 
    16911681        """
    16921682        from time import strftime
    16931683        time = strftime("%B %d, %Y %I:%M %p", dtime)
    1694        
     1684
    16951685        return template(os.path.join("html", "notebook", "afterpublish_window.html"),
    16961686                        worksheet = worksheet,
    16971687                        worksheet_filename = worksheet.filename(),
    class Notebook(object): 
    17031693        Return HTML for the "Upload Data" window.
    17041694
    17051695        INPUT:
    1706        
     1696
    17071697        - ``worksheet`` - an instance of Worksheet
    1708        
     1698
    17091699        - ``username`` - a string
    17101700
    17111701        OUTPUT:
    class Notebook(object): 
    17131703        - a string - the HTML representation of the data upload window
    17141704
    17151705        EXAMPLES::
    1716        
    1717             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1706
     1707            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17181708            sage: W = nb.create_new_worksheet('Test', 'admin')
    17191709            sage: nb.html_upload_data_window(W, 'admin')
    17201710            '...Upload or Create Data File...Browse...url...name of a new...'
    class Notebook(object): 
    17291719        Return the HTML for a worksheet's index page.
    17301720
    17311721        INPUT:
    1732        
     1722
    17331723        - ``worksheet_filename`` - a string (default: None)
    1734        
     1724
    17351725        - ``username`` - a string (default: 'guest')
    17361726
    17371727        - ``show_debug`` - a bool (default: False)
    1738        
     1728
    17391729        - ``admin`` - a bool (default: False)
    17401730
    17411731        OUTPUT:
    class Notebook(object): 
    17431733        - a string - the worksheet rendered as HTML
    17441734
    17451735        EXAMPLES::
    1746        
    1747             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1736
     1737            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17481738            sage: W = nb.create_new_worksheet('Test', 'admin')
    17491739            sage: nb.html(W.filename(), 'admin')
    17501740            '...Test...cell_input...plainclick...state_number...worksheet_locked=false...'
    class Notebook(object): 
    17611751        template_page = os.path.join("html", "notebook", "index.html")
    17621752        if W.docbrowser():
    17631753            template_page = os.path.join("html", "notebook", "doc_page.html")
    1764            
     1754
    17651755        return template(template_page, worksheet = W,
    17661756                        worksheet_filename = W.filename(),
    17671757                        worksheet_html = W.html(), notebook = self,
    def load_notebook(dir, interface=None, p 
    17741764    """
    17751765    Load and return a notebook from a given directory.  Create a new
    17761766    one in that directory, if one isn't already there.
    1777    
     1767
    17781768    INPUT:
    1779    
     1769
    17801770    -  ``dir`` - a string that defines a directory name
    1781    
     1771
    17821772    -  ``interface`` - the address of the interface the server listens at
    1783    
     1773
    17841774    -  ``port`` - the port the server listens on
    1785    
     1775
    17861776    -  ``secure`` - whether the notebook is secure
    17871777
    17881778    OUTPUT:
    def load_notebook(dir, interface=None, p 
    17971787                raise KeyboardInterrupt, "Interrupted notebook migration.  Delete the directory '%s' and try again."%(os.path.abspath(dir+'.sagenb'))
    17981788            return nb
    17991789        dir += '.sagenb'
    1800        
     1790
    18011791    dir = make_path_relative(dir)
    18021792    nb = Notebook(dir)
    18031793    nb.interface = interface
    def migrate_old_notebook_v1(dir): 
    18191809    """
    18201810    nb_sobj = os.path.join(dir, 'nb.sobj')
    18211811    old_nb = cPickle.loads(open(nb_sobj).read())
    1822    
     1812
    18231813    ######################################################################
    18241814    # Tell user what is going on and make a backup
    18251815    ######################################################################
    18261816
    18271817    print ""
    18281818    print "*"*80
    1829     print "*"   
     1819    print "*"
    18301820    print "* The Sage notebook at"
    1831     print "*"   
     1821    print "*"
    18321822    print "*      '%s'"%os.path.abspath(dir)
    1833     print "*"   
     1823    print "*"
    18341824    print "* will be upgraded to a new format and stored in"
    18351825    print "*"
    18361826    print "*      '%s.sagenb'."%os.path.abspath(dir)
    def migrate_old_notebook_v1(dir): 
    18461836    # Create new notebook
    18471837    new_nb = Notebook(dir+'.sagenb')
    18481838
    1849     # Define a function for transfering the attributes of one object to another. 
     1839    # Define a function for transfering the attributes of one object to another.
    18501840    def transfer_attributes(old, new, attributes):
    18511841        for attr_old, attr_new in attributes:
    18521842            if hasattr(old, attr_old):
    18531843                setattr(new, attr_new,  getattr(old, attr_old))
    1854                
     1844
    18551845    # Transfer all the notebook attributes to our new notebook object
    1856    
     1846
    18571847    new_nb.conf().confs = old_nb.conf().confs
    18581848    for t in ['pretty_print', 'server_pool', 'ulimit', 'system']:
    18591849        if hasattr(old_nb, '_Notebook__' + t):
    18601850            new_nb.conf().confs[t] = getattr(old_nb, '_Notebook__' + t)
    1861    
     1851
    18621852    # Now update the user data from the old notebook to the new one:
    18631853    print "Migrating %s user accounts..."%len(old_nb.users())
    18641854    users = new_nb.users()
    def migrate_old_notebook_v1(dir): 
    18731863        # Fix the __conf field, which is also an instance of a class
    18741864        new_user.conf().confs = old_user.conf().confs
    18751865        users[new_user.username()] = new_user
    1876        
     1866
    18771867    ######################################################################
    18781868    # Set the worksheets of the new notebook equal to the ones from
    18791869    # the old one.
    18801870    ######################################################################
    1881    
     1871
    18821872    ######################################################################
    1883    
     1873
    18841874    def migrate_old_worksheet(old_worksheet):
    18851875        """
    1886         Migrates an old worksheet to the new format. 
     1876        Migrates an old worksheet to the new format.
    18871877        """
    18881878        old_ws_dirname = old_ws._Worksheet__filename.partition(os.path.sep)[-1]
    18891879        new_ws = new_nb.worksheet(old_ws.owner(), old_ws_dirname)
    def migrate_old_notebook_v1(dir): 
    18951885                if isinstance(user,str):
    18961886                    # There was a bug in the old notebook where sometimes the
    18971887                    # user was the *module* "user", so we don't include that
    1898                     # invalid data. 
     1888                    # invalid data.
    18991889                    tags[user] = [val]
    19001890        except AttributeError:
    19011891            pass
    def migrate_old_notebook_v1(dir): 
    19081898
    19091899        ws_pub = old_ws.worksheet_that_was_published().filename().split('/')
    19101900        ws_pub = (ws_pub[0],int(ws_pub[1]))
    1911            
     1901
    19121902        obj = {'name':old_ws.name(), 'system':old_ws.system(),
    19131903               'viewers':old_ws.viewers(), 'collaborators':old_ws.collaborators(),
    19141904               'pretty_print':old_ws.pretty_print(), 'ratings':old_ws.ratings(),
    def migrate_old_notebook_v1(dir): 
    19191909               }
    19201910
    19211911        new_ws.reconstruct_from_basic(obj)
    1922        
     1912
    19231913        base = os.path.join(dir, 'worksheets', old_ws.filename())
    19241914        worksheet_file = os.path.join(base, 'worksheet.txt')
    19251915        if os.path.exists(worksheet_file):
    def migrate_old_notebook_v1(dir): 
    19451935                shutil.copytree(old_ws.cells_directory(), dest)
    19461936        except Exception, msg:
    19471937            print msg
    1948                
     1938
    19491939
    19501940        return new_ws
    1951    
     1941
    19521942    worksheets = {}
    19531943    num_worksheets = len(old_nb._Notebook__worksheets)
    19541944    print "Migrating (at most) %s worksheets..."%num_worksheets
    def make_path_relative(dir): 
    19881978
    19891979    INPUT:
    19901980
    1991     - ``dir`` - a string containing, e.g., a directory name 
     1981    - ``dir`` - a string containing, e.g., a directory name
    19921982
    19931983    OUTPUT:
    19941984
    def make_path_relative(dir): 
    20011991
    20021992##########################################################
    20031993# Misc
    2004 ##########################################################   
     1994##########################################################
    20051995
    20061996def clean_name(name):
    20071997    return ''.join([x if (x.isalnum() or x == '_') else '_' for x in name])
    def sort_worksheet_list(v, sort, reverse 
    20112001    Sort a given list on a given key, in a given order.
    20122002
    20132003    INPUT:
    2014    
     2004
    20152005    - ``sort`` - a string; 'last_edited', 'owner', 'rating', or 'name'
    2016    
     2006
    20172007    - ``reverse`` - a bool; if True, reverse the order of the sort.
    20182008
    20192009    OUTPUT:
  • sagenb/notebook/notebook_object.py

    diff --git a/sagenb/notebook/notebook_object.py b/sagenb/notebook/notebook_object.py
    a b def test_notebook(admin_passwd, secure=F 
    207207        sage: passwd = str(randint(1,1<<128))
    208208        sage: nb = test_notebook(passwd, address='localhost', port=8060)
    209209        sage: import urllib
    210         sage: h = urllib.urlopen('https://localhost:8060')
     210        sage: h = urllib.urlopen('http://localhost:8060')
    211211        sage: homepage = h.read()
    212212        sage: h.close()
    213213        sage: 'html' in homepage
    def test_notebook(admin_passwd, secure=F 
    238238        except pexpect.EOF:
    239239            pass
    240240        p.close(force=True)
    241         shutil.rmtree(nb.directory())
     241        shutil.rmtree(nb._dir)
    242242    p.dispose = dispose
    243243    if verbose:
    244244        print "Notebook started."
  • sagenb/notebook/twist.py

    diff --git a/sagenb/notebook/twist.py b/sagenb/notebook/twist.py
    a b TESTS: 
    66It is important that this file never be imported by default on
    77startup by Sage, since it is very expensive, since importing Twisted
    88is expensive. This doctest verifies that twist.py isn't imported on
    9 startup.
    10 
    11 ::
     9startup.::
    1210
    1311    sage: os.system("sage -startuptime | grep twisted\.web2 1>/dev/null") != 0  # !=0 means not found
    1412    True
    class Worksheet_do_upload_data(Worksheet 
    594592            if not os.path.isfile(dest):
    595593                return HTMLResponse(stream=message('Suspicious filename "%s" encountered uploading file.%s' % (name, backlinks), worksheet_url))
    596594            os.unlink(dest)
    597            
     595
    598596        response = http.RedirectResponse(worksheet_url + '/datafile?name=%s' % name)
    599597
    600598        if url != '':
    class SettingsPage(resource.PostableReso 
    956954        autosave = int(request.args.get('autosave', [0])[0]) * 60
    957955        if autosave:
    958956            nu['autosave_interval'] = autosave
    959             redirect_to_home = True           
     957            redirect_to_home = True
    960958
    961959        old = request.args.get('old-pass', [None])[0]
    962960        new = request.args.get('new-pass', [None])[0]
    def render_worksheet_list(args, pub, use 
    15261524    -  ``username`` - the user whose worksheets we are
    15271525       listing
    15281526
    1529     OUTPUT: 
     1527    OUTPUT:
    15301528
    15311529    a string
    15321530    """
    class EmptyTrash(resource.Resource): 
    16021600        This twisted resource empties the trash of the current user when it
    16031601        is rendered.
    16041602
    1605         EXAMPLES:
    1606 
    1607         We create an instance of this resource.
    1608 
    1609         ::
     1603        EXAMPLES:
     1604
     1605        We create an instance of this resource.::
    16101606
    16111607            sage: import sagenb.notebook.twist
    16121608            sage: E = sagenb.notebook.twist.EmptyTrash('sage'); E
    class EmptyTrash(resource.Resource): 
    16191615        Rendering this resource (1) empties the trash, and (2) returns a
    16201616        message.
    16211617
    1622         EXAMPLES: 
     1618        EXAMPLES:
    16231619
    16241620        We create a notebook with a worksheet, put it in the
    16251621        trash, then empty the trash by creating and rendering this
    1626         worksheet.
    1627 
    1628         ::
    1629 
    1630             sage: n = sagenb.notebook.notebook.Notebook('notebook-test')
     1622        worksheet.::
     1623
     1624            sage: n = sagenb.notebook.notebook.load_notebook('notebook-test.sagenb')
    16311625            sage: n.add_user('sage','sage','sage@sagemath.org',force=True)
    16321626            sage: W = n.new_worksheet_with_title_from_text('Sage', owner='sage')
    16331627            sage: W.move_to_trash('sage')
    class EmptyTrash(resource.Resource): 
    16361630            sage: sagenb.notebook.twist.notebook = n
    16371631            sage: E = sagenb.notebook.twist.EmptyTrash('sage'); E
    16381632            <sagenb.notebook.twist.EmptyTrash object at ...>
    1639             sage: E.render(None)
    1640             <twisted.web2.http.Response code=200, streamlen=...>
     1633            sage: from sagenb.notebook.twist import HTMLResponse
     1634            sage: ctx = HTMLResponse(stream = 'foo')
     1635            sage: ctx.headers.addRawHeader('referer', 'over there')
     1636            sage: E.render(ctx)
     1637            <RedirectResponse 301 Document moved to over there.>
    16411638
    16421639        Finally we verify that the trashed worksheet is gone::
    16431640
    class JSMath_js(resource.Resource): 
    18381835        s = template(os.path.join('js', 'jsmath.js'),
    18391836                     jsmath_macros = jsmath_macros,
    18401837                     jsmath_image_fonts = jsmath_image_fonts)
    1841        
     1838
    18421839        return http.Response(stream=s)
    18431840
    18441841class Main_js(resource.Resource):
    import re 
    19571954re_valid_username = re.compile('[a-z|A-Z|0-9|_|.|@]*')
    19581955def is_valid_username(username):
    19591956    r"""
    1960     Returns True if and only if ``username`` is valid, i.e., between 3
    1961     and 64 characters long. You may only use letters, numbers,
    1962     underscores, @, and dots.
     1957    Returns whether a candidate username is valid.  It must contain
     1958    between 3 and 65 of these characters: letters, numbers,
     1959    underscores, @, and/or dots ('.').
     1960
     1961    INPUT:
     1962
     1963    - ``username`` - a string; the candidate username
     1964
     1965    OUTPUT:
     1966
     1967    - a boolean
    19631968
    19641969    EXAMPLES::
    19651970
    19661971        sage: from sagenb.notebook.twist import is_valid_username
    1967 
    1968     ``username`` must start with a letter
    1969 
    1970     ::
    1971 
    19721972        sage: is_valid_username('mark10')
    19731973        True
    19741974        sage: is_valid_username('10mark')
    19751975        False
    1976 
    1977     ``username`` must be between 4 and 32 characters long
    1978 
    1979     ::
    1980 
    1981         sage: is_valid_username('bob')
     1976        sage: is_valid_username('me')
    19821977        False
    1983         sage: is_valid_username('I_love_computer_science_and_maths') #33 characters long
     1978        sage: is_valid_username('abcde' * 13)
    19841979        False
    1985 
    1986     ``username`` must not have more than one dot (.)
    1987 
    1988     ::
    1989 
    1990         sage: is_valid_username('david.andrews')
    1991         True
    1992         sage: is_valid_username('david.m.andrews')
    1993         False
    1994         sage: is_valid_username('math125.TA.5')
    1995         False
    1996 
    1997     ``username`` must not have any spaces
    1998 
    1999     ::
    2000 
    20011980        sage: is_valid_username('David Andrews')
    20021981        False
    20031982        sage: is_valid_username('David M. Andrews')
    20041983        False
    2005 
    2006     ::
    2007 
    20081984        sage: is_valid_username('sarah_andrews')
    20091985        True
    2010 
    2011     ::
    2012 
    20131986        sage: is_valid_username('TA-1')
    20141987        False
    20151988        sage: is_valid_username('math125-TA')
    20161989        False
    2017 
    2018     ::
    2019 
    20201990        sage: is_valid_username('dandrews@sagemath.org')
    2021         False
     1991        True
    20221992    """
    20231993    import string
    20241994
    class LoginResourceClass(resource.Resour 
    24072377        template_dict = {'accounts': notebook.get_accounts(),
    24082378                         'default_user': notebook.default_user(),
    24092379                         'recovery': notebook.conf()['email'],
    2410                          'sage_version':SAGE_VERSION}                         
     2380                         'sage_version':SAGE_VERSION}
    24112381        return HTMLResponse(stream=template(os.path.join('html', 'login.html'), **template_dict))
    24122382
    24132383    def childFactory(self, request, name):
    class FailedToplevel(Toplevel): 
    24722442                             'default_user': self.username,
    24732443                             'password_error': True,
    24742444                             'recovery': notebook.conf()['email'],
    2475                              'sage_version':SAGE_VERSION}                             
     2445                             'sage_version':SAGE_VERSION}
    24762446            return HTMLResponse(stream=template(os.path.join('html', 'login.html'), **template_dict))
    24772447        elif self.problem == 'suspended':
    24782448            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
    a b AUTHORS: 
    2727import base64, bz2, calendar, copy, os, re, shutil, string, time, traceback
    2828
    2929# General sage library code
    30 from sagenb.misc.misc import (cython, load, save, 
     30from sagenb.misc.misc import (cython, load, save,
    3131                              alarm, cancel_alarm, verbose, DOT_SAGENB, walltime,
    3232                              set_restrictive_permissions,
    3333                              set_permissive_permissions)
    from sagenb.interfaces import (Worksheet 
    3838                               WorksheetProcess_ReferenceImplementation,
    3939                               WorksheetProcess_RemoteExpectImplementation)
    4040
    41                          
     41
    4242import sagenb.misc.support  as support
    4343
    4444# Imports specifically relevant to the sage notebook
    SAGE_END = SC + 'e' 
    7171SAGE_ERROR = SC + 'r'
    7272
    7373# Integers that define which folder this worksheet is in
    74 # relative to a given user. 
     74# relative to a given user.
    7575ARCHIVED = 0
    7676ACTIVE   = 1
    7777TRASH    = 2
    all_worksheet_processes = [] 
    8080
    8181def update_worksheets():
    8282    """
    83     Iterate through and "update" all the worksheets.  This is needed for things like
    84     wall timeouts.
     83    Iterate through and "update" all the worksheets.  This is needed
     84    for things like wall timeouts.
    8585    """
    8686    for S in all_worksheet_processes:
    8787        S.update()
    def worksheet_filename(name, owner): 
    9292    """
    9393    Return the relative directory name of this worksheet with given
    9494    name and owner.
    95    
     95
    9696    INPUT:
    97    
    98    
     97
    9998    -  ``name`` - string, which may have spaces and funny
    10099       characters, which are replaced by underscores.
    101    
     100
    102101    -  ``owner`` - string, with no spaces or funny
    103102       characters
    104    
    105    
     103
    106104    OUTPUT: string
    107    
     105
    108106    EXAMPLES::
    109    
     107
    110108        sage: sagenb.notebook.worksheet.worksheet_filename('Example worksheet 3', 'sage10')
    111109        'sage10/Example_worksheet_3'
    112110        sage: sagenb.notebook.worksheet.worksheet_filename('Example#%&! work\\sheet 3', 'sage10')
    def Worksheet_from_basic(obj, notebook_w 
    126124           stores worksheets, i.e., nb.worksheet_directory().
    127125
    128126    OUTPUT:
    129    
     127
    130128        - a worksheet
    131129
    132130    EXAMPLES::
     131
    133132            sage: import sagenb.notebook.worksheet
    134             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
     133            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
    135134            sage: _=W.new_cell_after(0); B = W.basic()
    136             sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, '')
     135            sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, tmp_dir())
    137136            sage: W0.basic() == B
    138137            True
    139138    """
    class Worksheet(object): 
    149148                 auto_publish=False, create_directories=True):
    150149        """
    151150        Create and initialize a new worksheet.
    152        
     151
    153152        INPUT:
    154        
    155        
     153
    156154        -  ``name`` - string; the name of this worksheet
    157        
     155
    158156        - ``id_number`` - Integer; name of the directory in which the
    159157           worksheet's data is stored
    160        
     158
    161159        -  ``notebook_worksheet_directory`` - string; the
    162160           directory in which the notebook object that contains this worksheet
    163161           stores worksheets, i.e., nb.worksheet_directory().
    164        
     162
    165163        -  ``system`` - string; 'sage', 'gp', 'singular', etc.
    166164           - the math software system in which all code is evaluated by
    167165           default
    168        
     166
    169167        -  ``owner`` - string; username of the owner of this
    170168           worksheet
    171        
     169
    172170        -  ``docbrowser`` - bool (default: False); whether this
    173171           is a docbrowser worksheet
    174        
     172
    175173        -  ``pretty_print`` - bool (default: False); whether
    176174           all output is pretty printed by default.
    177175
    class Worksheet(object): 
    179177          creates various files and directories where data will be
    180178          stored.  This option is here only for the
    181179          migrate_old_notebook method in notebook.py
    182        
    183        
     180
    184181        EXAMPLES: We test the constructor via an indirect doctest::
    185        
    186             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     182
     183            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    187184            sage: W = nb.create_new_worksheet('Test', 'admin')
    188185            sage: W
    189             admin/0: [Cell 0; in=, out=]
     186            admin/0: [Cell 1; in=, out=]
    190187        """
    191188        if name is None:
    192189            # A fresh worksheet
    class Worksheet(object): 
    204201
    205202        # state sequence number, used for sync
    206203        self.__state_number = 0
    207        
     204
    208205        # Initialize the cell id counter.
    209206        self.__next_id = 0
    210207
    class Worksheet(object): 
    249246        EXAMPLES::
    250247
    251248            sage: from sagenb.notebook.worksheet import Worksheet
    252             sage: W = Worksheet('test', 2, '', owner='sageuser')
     249            sage: W = Worksheet('test', 2, tmp_dir(), owner='sageuser')
    253250            sage: W.id_number()
    254251            2
    255252            sage: type(W.id_number())
    class Worksheet(object): 
    267264        configuration of this worksheet, except the actual cells and
    268265        the data files in the DATA directory and images and other data
    269266        in the individual cell directories.
    270        
     267
    271268        EXAMPLES::
    272269
    273270            sage: import sagenb.notebook.worksheet
    274             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', owner='sage')
     271            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), owner='sage')
    275272            sage: sorted((W.basic().items()))
    276273            [('auto_publish', False),
    277              ('collaborators', []),
    278              ('id_number', 0),
    279              ('last_change', ('sage', ...)),
    280              ('name', 'test'),
    281              ('owner', 'sage'),
    282              ('pretty_print', False),
    283              ('published_id_number', None),
    284              ('ratings', []),
    285              ('system', None),
    286              ('tags', {}),
    287              ('viewers', []),
    288              ('worksheet_that_was_published', None)]
     274              ('collaborators', []),
     275              ('id_number', 0),
     276              ('last_change', ('sage', ...)),
     277              ('name', 'test'),
     278              ('owner', 'sage'),
     279              ('pretty_print', False),
     280              ('published_id_number', None),
     281              ('ratings', []),
     282              ('system', None),
     283              ('tags', {'sage': [1]}),
     284              ('viewers', []),
     285              ('worksheet_that_was_published', ('sage', 0))]
    289286        """
    290287        try:
    291288            published_id_number = int(os.path.split(self.__published_version)[1])
    class Worksheet(object): 
    296293            ws_pub = self.__worksheet_came_from
    297294        except AttributeError:
    298295            ws_pub = (self.owner(), self.id_number())
    299            
     296
    300297        d = {#############
    301298             # basic identification
    302299             'name':self.name(),
    class Worksheet(object): 
    323320             # worksheet.  Otherwise ws_pub is None.
    324321             'worksheet_that_was_published':ws_pub,
    325322             # Whether or not this worksheet should automatically be
    326              # republished when changed. 
     323             # republished when changed.
    327324             'auto_publish':self.is_auto_publish(),
    328325
    329326             # Appearance: e.g., whether to pretty print this
    class Worksheet(object): 
    364361              ``id_number`` is a key of obj; otherwise not.
    365362
    366363        EXAMPLES::
     364
    367365            sage: import sagenb.notebook.worksheet
    368             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
     366            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
    369367            sage: W.new_cell_after(0)
    370368            Cell 1; in=, out=
    371369            sage: b = W.basic()
    372370            sage: W0 = sagenb.notebook.worksheet.Worksheet()
    373             sage: W0.reconstruct_from_basic(b,'')
     371            sage: W0.reconstruct_from_basic(b, tmp_dir())
    374372            sage: W0.basic() == W.basic()
    375373            True
    376374        """
    class Worksheet(object): 
    406404    def __cmp__(self, other):
    407405        """
    408406        We compare two worksheets.
    409        
     407
    410408        INPUT:
    411        
    412        
     409
    413410        -  ``self, other`` - worksheets
    414        
    415        
     411
    416412        OUTPUT:
    417        
    418        
     413
    419414        -  ``-1,0,1`` - comparison is on the underlying
    420415           file names.
    421        
    422        
     416
    423417        EXAMPLES::
    424        
    425             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     418
     419            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    426420            sage: W2 = nb.create_new_worksheet('test2', 'admin')
    427421            sage: W1 = nb.create_new_worksheet('test1', 'admin')
    428422            sage: cmp(W1, W2)
    class Worksheet(object): 
    439433        r"""
    440434        Return string representation of this worksheet, which is simply the
    441435        string representation of the underlying list of cells.
    442        
     436
    443437        OUTPUT: string
    444        
     438
    445439        EXAMPLES::
    446        
    447             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     440
     441            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    448442            sage: W = nb.create_new_worksheet('test1', 'admin')
    449443            sage: W.__repr__()
    450             'admin/0: [Cell 0; in=, out=]'
    451             sage: W.edit_save('Sage\n{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
     444            'admin/0: [Cell 1; in=, out=]'
     445            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
    452446            sage: W.__repr__()
    453447            'admin/0: [Cell 0; in=2+3, out=\n5, Cell 10; in=2+8, out=\n10]'
    454448        """
    class Worksheet(object): 
    456450    def __len__(self):
    457451        r"""
    458452        Return the number of cells in this worksheet.
    459        
     453
    460454        OUTPUT: int
    461        
     455
    462456        EXAMPLES::
    463        
    464             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     457
     458            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    465459            sage: W = nb.create_new_worksheet('test1', 'admin')
    466460            sage: len(W)
    467461            1
    468             sage: W.edit_save('Sage\n{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
     462            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
    469463            sage: len(W)
    470464            2
    471465        """
    class Worksheet(object): 
    487481    def docbrowser(self):
    488482        """
    489483        Return True if this is a docbrowser worksheet.
    490        
     484
    491485        OUTPUT: bool
    492        
     486
    493487        EXAMPLES: We first create a standard worksheet for which docbrowser
    494488        is of course False::
    495        
    496             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     489
     490            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    497491            sage: W = nb.create_new_worksheet('test1', 'admin')
    498492            sage: W.docbrowser()
    499493            False
    500        
     494
    501495        We create a worksheet for which docbrowser is True::
    502        
     496
    503497            sage: W = nb.create_new_worksheet('docs', 'admin', docbrowser=True)
    504498            sage: W.docbrowser()
    505499            True
    class Worksheet(object): 
    519513        """
    520514        Return a (reference to the) list of the collaborators who can also
    521515        view and modify this worksheet.
    522        
     516
    523517        OUTPUT: list
    524        
     518
    525519        EXAMPLES::
    526        
    527             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     520
     521            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    528522            sage: W = nb.create_new_worksheet('test1', 'admin')
    529523            sage: C = W.collaborators(); C
    530524            []
    class Worksheet(object): 
    537531        except AttributeError:
    538532            self.__collaborators = []
    539533            return self.__collaborators
    540        
     534
    541535    def collaborator_names(self, max=None):
    542536        """
    543537        Returns a string of the non-owner collaborators on this worksheet.
    544        
     538
    545539        INPUT:
    546        
    547        
     540
    548541        -  ``max`` - an integer. If this is specified, then
    549542           only max number of collaborators are shown.
    550        
    551        
     543
    552544        EXAMPLES::
    553        
    554             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     545
     546            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    555547            sage: W = nb.create_new_worksheet('test1', 'admin')
    556548            sage: C = W.collaborators(); C
    557549            []
    class Worksheet(object): 
    571563        """
    572564        Set the list of collaborators to those listed in the list v of
    573565        strings.
    574        
     566
    575567        INPUT:
    576        
    577        
     568
    578569        -  ``v`` - a list of strings
    579        
    580        
     570
    581571        EXAMPLES::
    582        
    583             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     572
     573            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    584574            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    585575            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    586576            sage: W = nb.create_new_worksheet('test1', 'admin')
    587577            sage: W.set_collaborators(['sage', 'admin', 'hilbert', 'sage'])
    588        
     578
    589579        Note that repeats are not added multiple times and admin - the
    590580        owner - isn't added::
    591        
     581
    592582            sage: W.collaborators()
    593583            ['hilbert', 'sage']
    594584        """
    class Worksheet(object): 
    611601    def viewers(self):
    612602        """
    613603        Return list of viewers of this worksheet.
    614        
     604
    615605        OUTPUT:
    616        
    617        
     606
    618607        -  ``list`` - of string
    619        
    620        
     608
    621609        EXAMPLES::
    622        
    623             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     610
     611            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    624612            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    625613            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    626614            sage: W = nb.create_new_worksheet('test1', 'admin')
    class Worksheet(object): 
    640628    def viewer_names(self, max=None):
    641629        """
    642630        Returns a string of the non-owner viewers on this worksheet.
    643        
     631
    644632        INPUT:
    645        
    646        
     633
    647634        -  ``max`` - an integer. If this is specified, then
    648635           only max number of viewers are shown.
    649        
    650        
     636
    651637        EXAMPLES::
    652        
    653             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     638
     639            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    654640            sage: W = nb.create_new_worksheet('test1', 'admin')
    655641            sage: C = W.viewers(); C
    656642            []
    class Worksheet(object): 
    671657        Delete data from this worksheet this is specific to a certain
    672658        notebook. This means deleting the attached files, collaborators,
    673659        and viewers.
    674        
     660
    675661        EXAMPLES::
    676        
    677             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     662
     663            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    678664            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    679665            sage: W = nb.create_new_worksheet('test1', 'admin')
    680666            sage: W.add_viewer('hilbert')
    class Worksheet(object): 
    691677        self.__attached = {}
    692678        self.__collaborators = [self.owner()]
    693679        self.__viewers = []
    694    
     680
    695681    def name(self):
    696682        """
    697683        Return the name of this worksheet.
    698        
     684
    699685        OUTPUT: string
    700        
     686
    701687        EXAMPLES::
    702        
    703             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     688
     689            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    704690            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    705691            sage: W.name()
    706692            'A Test Worksheet'
    class Worksheet(object): 
    714700    def set_name(self, name):
    715701        """
    716702        Set the name of this worksheet.
    717        
     703
    718704        INPUT:
    719        
    720        
     705
    721706        -  ``name`` - string
    722        
    723        
     707
    724708        EXAMPLES: We create a worksheet and change the name::
    725        
    726             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     709
     710            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    727711            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    728712            sage: W.set_name('A renamed worksheet')
    729713            sage: W.name()
    class Worksheet(object): 
    737721        r"""
    738722        Set this worksheet filename (actually directory) by getting the
    739723        owner from the pre-stored owner via ``self.owner()``.
    740        
     724
    741725        INPUT:
    742        
    743        
     726
    744727        -  ``nm`` - string
    745        
    746        
     728
    747729        EXAMPLES::
    748        
    749             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     730
     731            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    750732            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    751733            sage: W.filename()
    752734            'admin/0'
    class Worksheet(object): 
    760742    def set_filename(self, filename):
    761743        """
    762744        Set the worksheet filename (actually directory).
    763        
     745
    764746        INPUT:
    765        
    766        
     747
    767748        -  ``filename`` - string
    768        
    769        
     749
    770750        EXAMPLES::
    771        
    772             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     751
     752            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    773753            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    774754            sage: W.filename()
    775755            'admin/0'
    class Worksheet(object): 
    779759        """
    780760        old_filename = self.__filename
    781761        self.__filename = filename
    782         self.__dir = os.path.join(self.notebook().worksheet_directory(), filename)
     762        self.__dir = os.path.join(self.notebook()._dir, filename)
    783763        self.notebook().change_worksheet_key(old_filename, filename)
    784764
    785765    def filename(self):
    786766        """
    787767        Return the filename (really directory) where the files associated
    788768        to this worksheet are stored.
    789        
     769
    790770        EXAMPLES::
    791        
    792             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     771
     772            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    793773            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    794774            sage: W.filename()
    795775            'admin/0'
    796             sage: sorted(os.listdir(nb.directory() + '/worksheets/' + W.filename()))
    797             ['cells', 'snapshots']
     776            sage: os.path.isdir(os.path.join(nb._dir, 'home', W.filename()))
     777            True
    798778        """
    799779        return self.__filename
    800780
    class Worksheet(object): 
    802782        """
    803783        Return the part of the worksheet filename after the last /, i.e.,
    804784        without any information about the owner of this worksheet.
    805        
     785
    806786        EXAMPLES::
    807        
    808             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     787
     788            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    809789            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    810790            sage: W.filename_without_owner()
    811791            '0'
    class Worksheet(object): 
    818798        """
    819799        Return the full path to the directory where this worksheet is
    820800        stored.
    821        
     801
    822802        OUTPUT: string
    823        
     803
    824804        EXAMPLES::
    825        
    826             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     805
     806            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    827807            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    828808            sage: W.directory()
    829             '.../worksheets/admin/0'
     809            '.../home/admin/0'
    830810        """
    831811        return self.__dir
    832812
    833813    def data_directory(self):
    834814        """
    835815        Return path to directory where worksheet data is stored.
    836        
     816
    837817        OUTPUT: string
    838        
     818
    839819        EXAMPLES::
    840        
    841             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     820
     821            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    842822            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    843823            sage: W.data_directory()
    844             '.../worksheets/admin/0/data'
     824            '.../home/admin/0/data'
    845825        """
    846826        d = os.path.join(self.directory(), 'data')
    847827        if not os.path.exists(d):
    class Worksheet(object): 
    852832        """
    853833        Return a list of the file names of files in the worksheet data
    854834        directory.
    855        
     835
    856836        OUTPUT: list of strings
    857        
     837
    858838        EXAMPLES::
    859        
    860             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     839
     840            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    861841            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    862842            sage: W.attached_data_files()
    863843            []
    class Worksheet(object): 
    874854        """
    875855        Return the directory in which the cells of this worksheet are
    876856        evaluated.
    877        
     857
    878858        OUTPUT: string
    879        
     859
    880860        EXAMPLES::
    881        
    882             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     861
     862            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    883863            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    884864            sage: W.cells_directory()
    885             '.../worksheets/admin/0/cells'
     865            '.../home/admin/0/cells'
    886866        """
    887867        path = os.path.join(self.directory(), 'cells')
    888868        if not os.path.exists(path):
    class Worksheet(object): 
    892872    def notebook(self):
    893873        """
    894874        Return the notebook that contains this worksheet.
    895        
     875
    896876        OUTPUT: a Notebook object.
    897        
     877
    898878        EXAMPLES: This really returns the Notebook object that is set as a
    899         global variable of the twist module.
    900        
    901         ::
    902        
    903             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     879        global variable of the twist module.::
     880
     881            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    904882            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    905883            sage: W.notebook()
    906884            <...sagenb.notebook.notebook.Notebook...>
    class Worksheet(object): 
    917895        """
    918896        Return the math software system in which by default all input to
    919897        the notebook is evaluated.
    920        
     898
    921899        OUTPUT: string
    922        
     900
    923901        EXAMPLES::
    924        
    925             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     902
     903            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    926904            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    927905            sage: W.system()
    928906            'sage'
    class Worksheet(object): 
    945923        Sage installed to running a server from the same directory
    946924        without Sage installed.   We might as well support this.
    947925
    948         OUTPUT:
    949 
    950             - integer
     926        OUTPUT: integer
    951927        """
    952928        S = self.system()
    953929        names = self.notebook().system_names()
    class Worksheet(object): 
    962938        """
    963939        Set the math software system in which input is evaluated by
    964940        default.
    965        
     941
    966942        INPUT:
    967        
    968        
     943
    969944        -  ``system`` - string (default: 'sage')
    970        
    971        
     945
    972946        EXAMPLES::
    973        
    974             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     947
     948            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    975949            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    976950            sage: W.set_system('magma')
    977951            sage: W.system()
    class Worksheet(object): 
    982956    def pretty_print(self):
    983957        """
    984958        Return True if output should be pretty printed by default.
    985        
     959
    986960        OUTPUT:
    987        
    988        
     961
    989962        -  ``bool`` - True of False
    990        
    991        
     963
    992964        EXAMPLES::
    993        
    994             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     965
     966            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    995967            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    996968            sage: W.pretty_print()
    997969            False
    998970            sage: W.set_pretty_print('true')
    999971            sage: W.pretty_print()
    1000972            True
     973            sage: W.quit()
     974            sage: nb.delete()
    1001975        """
    1002976        try:
    1003977            return self.__pretty_print
    class Worksheet(object): 
    1008982    def set_pretty_print(self, check='false'):
    1009983        """
    1010984        Set whether or not output should be pretty printed by default.
    1011        
     985
    1012986        INPUT:
    1013        
    1014        
     987
    1015988        -  ``check`` - string (default: 'false'); either 'true'
    1016989           or 'false'.
    1017        
    1018        
     990
    1019991        .. note::
    1020992
    1021993           The reason the input is a string and lower case instead of
    class Worksheet(object): 
    1023995           JavaScript. (And, Jason Grout wrote this and didn't realize
    1024996           how unpythonic this design is - it should be redone to use
    1025997           True/False.)
    1026        
     998
    1027999        EXAMPLES::
    1028        
    1029             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1000
     1001            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10301002            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    10311003            sage: W.set_pretty_print('false')
    10321004            sage: W.pretty_print()
    class Worksheet(object): 
    10341006            sage: W.set_pretty_print('true')
    10351007            sage: W.pretty_print()
    10361008            True
     1009            sage: W.quit()
     1010            sage: nb.delete()
    10371011        """
    10381012        if check == 'false':
    10391013            check=False
    class Worksheet(object): 
    10411015            check=True
    10421016        self.__pretty_print = check
    10431017        self.eval_asap_no_output("pretty_print_default(%r)"%(check))
    1044        
     1018
    10451019    ##########################################################
    10461020    # Publication
    10471021    ##########################################################
    10481022    def is_auto_publish(self):
    10491023        """
    1050         Returns True if this worksheet should be automatically published. 
     1024        Returns True if this worksheet should be automatically published.
    10511025        """
    1052         try: 
     1026        try:
    10531027            return self.__autopublish
    10541028        except AttributeError:
    10551029            self.__autopublish = False
    10561030            return False
    1057    
     1031
    10581032    def set_auto_publish(self, x):
    10591033        self.__autopublish = x
    1060    
     1034
    10611035    def is_published(self):
    10621036        """
    10631037        Return True if this worksheet is a published worksheet.
    1064        
     1038
    10651039        OUTPUT:
    1066        
    1067        
     1040
    10681041        -  ``bool`` - whether or not owner is 'pub'
    1069        
    1070        
     1042
    10711043        EXAMPLES::
    1072        
    1073             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1044
     1045            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10741046            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    10751047            sage: W.is_published()
    10761048            False
    class Worksheet(object): 
    10851057        Return owner and id_number of the worksheet that was published
    10861058        to get this worksheet, if this worksheet was
    10871059        published. Otherwise just return this worksheet.
    1088        
     1060
    10891061        OUTPUT: Worksheet
    1090        
     1062
    10911063        EXAMPLES::
    1092        
    1093             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1064
     1065            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    10941066            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    10951067            sage: W.worksheet_that_was_published() is W
    10961068            True
    1097        
    1098         ::
    1099        
    11001069            sage: S = nb.publish_worksheet(W, 'admin')
    11011070            sage: S.worksheet_that_was_published() is S
    11021071            False
    class Worksheet(object): 
    11071076            return self.notebook().get_worksheet_with_filename('%s/%s'%self.__worksheet_came_from)
    11081077        except Exception:  # things can go wrong (especially with old migrated
    11091078                           # Sage notebook servers!), but we don't want such
    1110                            # problems to crash the notebook server. 
     1079                           # problems to crash the notebook server.
    11111080            return self
    11121081
    11131082    def publisher(self):
    11141083        """
    11151084        Return username of user that published this worksheet.
    1116        
     1085
    11171086        OUTPUT: string
    1118        
     1087
    11191088        EXAMPLES::
    1120        
    1121             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1089
     1090            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11221091            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11231092            sage: S = nb.publish_worksheet(W, 'admin')
    11241093            sage: S.publisher()
    class Worksheet(object): 
    11301099        """
    11311100        Return True if username is the username of the publisher of this
    11321101        worksheet, assuming this worksheet was published.
    1133        
     1102
    11341103        INPUT:
    1135        
    1136        
     1104
    11371105        -  ``username`` - string
    1138        
    1139        
     1106
    11401107        EXAMPLES::
    1141        
    1142             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1108
     1109            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    11431110            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11441111            sage: P = nb.publish_worksheet(W, 'admin')
    11451112            sage: P.is_publisher('hearst')
    class Worksheet(object): 
    11521119    def has_published_version(self):
    11531120        """
    11541121        Return True if there is a published version of this worksheet.
    1155        
     1122
    11561123        OUTPUT: bool
    1157        
     1124
    11581125        EXAMPLES::
    1159        
    1160             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1126
     1127            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11611128            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11621129            sage: P = nb.publish_worksheet(W, 'admin')
    11631130            sage: P.has_published_version()
    class Worksheet(object): 
    11751142        """
    11761143        Set the published version of this worksheet to be the worksheet
    11771144        with given filename.
    1178        
     1145
    11791146        INPUT:
    1180        
    1181        
     1147
    11821148        -  ``filename`` - string
    1183        
    1184        
     1149
    11851150        EXAMPLES::
    1186        
    1187             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1151
     1152            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11881153            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11891154            sage: P = nb.publish_worksheet(W, 'admin')  # indirect test
    11901155            sage: W._Worksheet__published_version
     1156            'pub/1'
     1157            sage: W.set_published_version('pub/0')
     1158            sage: W._Worksheet__published_version
    11911159            'pub/0'
    1192             sage: W.set_published_version('pub/0')
    11931160        """
    11941161        self.__published_version = filename
    11951162
    class Worksheet(object): 
    11971164        """
    11981165        If this worksheet was published, return the published version of
    11991166        this worksheet. Otherwise, raise a ValueError.
    1200        
     1167
    12011168        OUTPUT: a worksheet (or raise a ValueError)
    1202        
     1169
    12031170        EXAMPLES::
    1204        
    1205             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1171
     1172            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12061173            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12071174            sage: P = nb.publish_worksheet(W, 'admin')
    12081175            sage: W.published_version() is P
    12091176            True
    1210         """       
     1177        """
    12111178        try:
    12121179            filename =self.__published_version
    12131180            try:
    class Worksheet(object): 
    12181185                raise ValueError
    12191186        except AttributeError:
    12201187            raise ValueError, "no published version"
    1221                              
     1188
    12221189    def set_worksheet_that_was_published(self, W):
    12231190        """
    12241191        Set the owner and id_number of the worksheet that was
    12251192        published to get self.
    1226        
     1193
    12271194        INPUT:
    12281195
    12291196            - ``W`` -- worksheet or 2-tuple ('owner', id_number)
    12301197
    1231        
    12321198        EXAMPLES::
    1233        
    1234             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1199
     1200            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12351201            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12361202            sage: P = nb.publish_worksheet(W, 'admin')
    12371203            sage: P.worksheet_that_was_published() is W
    12381204            True
    1239        
     1205
    12401206        We fake things and make it look like P published itself::
    1241        
     1207
    12421208            sage: P.set_worksheet_that_was_published(P)
    12431209            sage: P.worksheet_that_was_published() is P
    12441210            True
    class Worksheet(object): 
    12521218        """
    12531219        Set the rating on this worksheet by the given user to x and also
    12541220        set the given comment.
    1255        
     1221
    12561222        INPUT:
    1257        
    1258        
     1223
    12591224        -  ``x`` - integer
    1260        
     1225
    12611226        -  ``comment`` - string
    1262        
     1227
    12631228        -  ``username`` - string
    1264        
    1265        
     1229
    12661230        EXAMPLES: We create a worksheet and rate it, then look at the
    1267         ratings.
    1268        
    1269         ::
    1270        
    1271             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1231        ratings.::
     1232
     1233            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    12721234            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12731235            sage: W.rate(3, 'this is great', 'hilbert')
    12741236            sage: W.ratings()
    12751237            [('hilbert', 3, 'this is great')]
    1276        
     1238
    12771239        Note that only the last rating by a user counts::
    1278        
     1240
    12791241            sage: W.rate(1, 'this lacks content', 'riemann')
    12801242            sage: W.rate(0, 'this lacks content', 'riemann')
    12811243            sage: W.ratings()
    class Worksheet(object): 
    12931255        """
    12941256        Return True is the user with given username has rated this
    12951257        worksheet.
    1296        
     1258
    12971259        INPUT:
    1298        
    1299        
     1260
    13001261        -  ``username`` - string
    1301        
    1302        
     1262
    13031263        OUTPUT: bool
    1304        
     1264
    13051265        EXAMPLES::
    1306        
    1307             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1266
     1267            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13081268            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13091269            sage: W.rate(0, 'this lacks content', 'riemann')
    13101270            sage: W.is_rater('admin')
    class Worksheet(object): 
    13201280    def ratings(self):
    13211281        """
    13221282        Return all the ratings of this worksheet.
    1323        
     1283
    13241284        OUTPUT:
    1325        
    1326        
     1285
    13271286        -  ``list`` - a reference to the list of ratings.
    1328        
    1329        
     1287
    13301288        EXAMPLES::
    1331        
    1332             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1289
     1290            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13331291            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13341292            sage: W.ratings()
    13351293            []
    class Worksheet(object): 
    13491307        r"""
    13501308        Return html that renders to give a summary of how this worksheet
    13511309        has been rated.
    1352        
     1310
    13531311        OUTPUT:
    1354        
    1355        
    1356         -  ``string`` -- a string of HTML as a bunch of table
    1357            rows.
    1358        
    1359        
     1312
     1313        - ``string`` -- a string of HTML as a bunch of table rows.
     1314
    13601315        EXAMPLES::
    1361        
    1362             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1316
     1317            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13631318            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13641319            sage: W.rate(0, 'this lacks content', 'riemann')
    13651320            sage: W.rate(3, 'this is great', 'hilbert')
    class Worksheet(object): 
    13811336    def rating(self):
    13821337        """
    13831338        Return overall average rating of self.
    1384        
     1339
    13851340        OUTPUT: float or the int -1 to mean "not rated"
    1386        
     1341
    13871342        EXAMPLES::
    1388        
    1389             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1343
     1344            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13901345            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13911346            sage: W.rating()
    13921347            -1
    class Worksheet(object): 
    14011356        else:
    14021357            rating = float(sum(r))/float(len(r))
    14031358        return rating
    1404        
     1359
    14051360    ##########################################################
    14061361    # Active, trash can and archive
    14071362    ##########################################################
    class Worksheet(object): 
    14091364        """
    14101365        Return True if all users have deleted this worksheet, so we know we
    14111366        can safely purge it from disk.
    1412        
     1367
    14131368        OUTPUT: bool
    1414        
     1369
    14151370        EXAMPLES::
    1416        
    1417             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1371
     1372            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14181373            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    14191374            sage: W.everyone_has_deleted_this_worksheet()
    14201375            False
    class Worksheet(object): 
    14221377            sage: W.everyone_has_deleted_this_worksheet()
    14231378            True
    14241379        """
    1425         for user in self.__collaborators + [self.owner()]:
     1380        for user in self.collaborators() + [self.owner()]:
    14261381            # When the worksheet has been deleted by the owner,
    14271382            # self.owner() returns None, so we have to be careful
    14281383            # about that case.
    14291384            if user is not None and not self.is_trashed(user):
    14301385                return False
    14311386        return True
    1432        
     1387
    14331388    def user_view(self, user):
    14341389        """
    14351390        Return the view that the given user has of this worksheet. If the
    14361391        user currently doesn't have a view set it to ACTIVE and return
    14371392        ACTIVE.
    1438        
     1393
    14391394        INPUT:
    1440        
    1441        
     1395
    14421396        -  ``user`` - a string
    1443        
    1444        
     1397
    14451398        OUTPUT:
    1446        
    1447        
     1399
    14481400        -  ``Python int`` - one of ACTIVE, ARCHIVED, TRASH,
    14491401           which are defined in worksheet.py
    1450        
    1451        
     1402
    14521403        EXAMPLES: We create a new worksheet and get the view, which is
    14531404        ACTIVE::
    1454        
    1455             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1405
     1406            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14561407            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    14571408            sage: W.user_view('admin')
    14581409            1
    14591410            sage: sagenb.notebook.worksheet.ACTIVE
    14601411            1
    1461        
     1412
    14621413        Now for the admin user we move W to the archive::
    1463        
     1414
    14641415            sage: W.move_to_archive('admin')
    1465        
    1466         The view is now archive.
    1467        
    1468         ::
    1469        
     1416
     1417        The view is now archive.::
     1418
    14701419            sage: W.user_view('admin')
    14711420            0
    14721421            sage: sagenb.notebook.worksheet.ARCHIVED
    14731422            0
    1474        
    1475         For any other random viewer the view is set by default to ACTIVE.
    1476        
    1477         ::
    1478        
     1423
     1424        For any other random viewer the view is set by default to ACTIVE.::
     1425
    14791426            sage: W.user_view('foo')
    14801427            1
    14811428        """
    class Worksheet(object): 
    14981445            self.user_view(self.owner())
    14991446            d = self.__user_view
    15001447        for user, val in d.iteritems():
    1501             d[user] = [val]
     1448            if not isinstance(val, list):
     1449                d[user] = [val]
    15021450        return d
    15031451
    15041452    def set_tags(self, tags):
    15051453        """
    1506         Set the tags -- for now we ignore everything except ACTIVE, ARCHIVED, TRASH.
     1454        Set the tags -- for now we ignore everything except ACTIVE,
     1455        ARCHIVED, TRASH.
    15071456
    15081457        INPUT:
    15091458
    class Worksheet(object): 
    15201469    def set_user_view(self, user, x):
    15211470        """
    15221471        Set the view on this worksheet for the given user.
    1523        
     1472
    15241473        INPUT:
    1525        
    1526        
     1474
    15271475        -  ``user`` - a string
    1528        
     1476
    15291477        -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
    15301478           TRASH in worksheet.py
    1531        
    1532        
     1479
    15331480        EXAMPLES::
    1534        
    1535             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1481
     1482            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15361483            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    15371484            sage: W.set_user_view('admin', sagenb.notebook.worksheet.ARCHIVED)
    15381485            sage: W.user_view('admin') == sagenb.notebook.worksheet.ARCHIVED
    class Worksheet(object): 
    15541501    def user_view_is(self, user, x):
    15551502        """
    15561503        Return True if the user view of user is x.
    1557        
     1504
    15581505        INPUT:
    1559        
    1560        
     1506
    15611507        -  ``user`` - a string
    1562        
     1508
    15631509        -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
    15641510           TRASH in worksheet.py
    1565        
    1566        
     1511
    15671512        EXAMPLES::
    1568        
    1569             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1513
     1514            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15701515            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    15711516            sage: W.user_view_is('admin', sagenb.notebook.worksheet.ARCHIVED)
    15721517            False
    class Worksheet(object): 
    15741519            True
    15751520        """
    15761521        return self.user_view(user) == x
    1577                
     1522
    15781523    def is_archived(self, user):
    15791524        """
    15801525        Return True if this worksheet is archived for the given user.
    1581        
     1526
    15821527        INPUT:
    1583        
    1584        
     1528
    15851529        -  ``user`` - string
    1586        
    1587        
     1530
    15881531        OUTPUT: bool
    1589        
     1532
    15901533        EXAMPLES::
    1591        
    1592             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1534
     1535            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15931536            sage: W = nb.create_new_worksheet('Archived Test', 'admin')
    15941537            sage: W.is_archived('admin')
    15951538            False
    class Worksheet(object): 
    16021545    def is_active(self, user):
    16031546        """
    16041547        Return True if this worksheet is active for the given user.
    1605        
     1548
    16061549        INPUT:
    1607        
    1608        
     1550
    16091551        -  ``user`` - string
    1610        
    1611        
     1552
    16121553        OUTPUT: bool
    1613        
     1554
    16141555        EXAMPLES::
    1615        
    1616             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1556
     1557            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16171558            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    16181559            sage: W.is_active('admin')
    16191560            True
    class Worksheet(object): 
    16261567    def is_trashed(self, user):
    16271568        """
    16281569        Return True if this worksheet is in the trash for the given user.
    1629        
     1570
    16301571        INPUT:
    1631        
    1632        
     1572
    16331573        -  ``user`` - string
    1634        
    1635        
     1574
    16361575        OUTPUT: bool
    1637        
     1576
    16381577        EXAMPLES::
    1639        
    1640             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1578
     1579            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16411580            sage: W = nb.create_new_worksheet('Trash Test', 'admin')
    16421581            sage: W.is_trashed('admin')
    16431582            False
    class Worksheet(object): 
    16501589    def move_to_archive(self, user):
    16511590        """
    16521591        Move this worksheet to be archived for the given user.
    1653        
     1592
    16541593        INPUT:
    1655        
    1656        
     1594
    16571595        -  ``user`` - string
    1658        
    1659        
     1596
    16601597        EXAMPLES::
    1661        
    1662             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1598
     1599            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16631600            sage: W = nb.create_new_worksheet('Archive Test', 'admin')
    16641601            sage: W.move_to_archive('admin')
    16651602            sage: W.is_archived('admin')
    class Worksheet(object): 
    16701607    def set_active(self, user):
    16711608        """
    16721609        Set his worksheet to be active for the given user.
    1673        
     1610
    16741611        INPUT:
    1675        
    1676        
     1612
    16771613        -  ``user`` - string
    1678        
    1679        
     1614
    16801615        EXAMPLES::
    1681        
    1682             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1616
     1617            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16831618            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    16841619            sage: W.move_to_archive('admin')
    16851620            sage: W.is_active('admin')
    class Worksheet(object): 
    16931628    def move_to_trash(self, user):
    16941629        """
    16951630        Move this worksheet to the trash for the given user.
    1696        
     1631
    16971632        INPUT:
    1698        
    1699        
     1633
    17001634        -  ``user`` - string
    1701        
    1702        
     1635
    17031636        EXAMPLES::
    1704        
    1705             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1637
     1638            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17061639            sage: W = nb.create_new_worksheet('Trash Test', 'admin')
    17071640            sage: W.move_to_trash('admin')
    17081641            sage: W.is_trashed('admin')
    class Worksheet(object): 
    17131646    def move_out_of_trash(self, user):
    17141647        """
    17151648        Exactly the same as set_active(user).
    1716        
     1649
    17171650        INPUT:
    1718        
    1719        
     1651
    17201652        -  ``user`` - string
    1721        
    1722        
     1653
    17231654        EXAMPLES::
    1724        
    1725             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1655
     1656            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17261657            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    17271658            sage: W.move_to_trash('admin')
    17281659            sage: W.is_active('admin')
    class Worksheet(object): 
    17321663            True
    17331664        """
    17341665        self.set_active(user)
    1735        
     1666
    17361667    #############
    17371668
    17381669    def delete_cells_directory(self):
    17391670        r"""
    17401671        Delete the directory in which all the cell computations occur.
    1741        
     1672
    17421673        EXAMPLES::
    1743        
    1744             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1674
     1675            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17451676            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17461677            sage: W = nb.create_new_worksheet('Test', 'sage')
    1747             sage: W.edit_save('Sage\n{{{\n3^20\n}}}')
     1678            sage: W.edit_save('{{{\n3^20\n}}}')
     1679            sage: W.cell_list()[0].evaluate()
     1680            sage: W.check_comp()    # random output -- depends on computer speed
    17481681            sage: sorted(os.listdir(W.directory()))
    1749             ['cells', 'snapshots']
    1750             sage: W.cell_list()[0].evaluate()
     1682            ['cells', 'data']
     1683            sage: W.save_snapshot('admin')
    17511684            sage: sorted(os.listdir(W.directory()))
    1752             ['cells', 'data', 'snapshots']
     1685            ['cells', 'data', 'snapshots', 'worksheet.html']
    17531686            sage: W.delete_cells_directory()
    17541687            sage: sorted(os.listdir(W.directory()))
    1755             ['data', 'snapshots']
     1688            ['data', 'snapshots', 'worksheet.html']
     1689            sage: W.quit()
     1690            sage: nb.delete()
    17561691        """
    17571692        dir = self.cells_directory()
    17581693        if os.path.exists(dir):
    class Worksheet(object): 
    17751710
    17761711    def set_owner(self, owner):
    17771712        self.__owner = owner
    1778         if not owner in self.__collaborators:
     1713        if not owner in self.collaborators():
    17791714            self.__collaborators.append(owner)
    17801715
    17811716    def is_only_viewer(self, user):
    class Worksheet(object): 
    17911726            return True
    17921727
    17931728    def is_collaborator(self, user):
    1794         try:
    1795             return user in self.__collaborators
    1796         except AttributeError:
    1797             return True
     1729        return user in self.collaborators()
    17981730
    17991731    def user_can_edit(self, user):
    18001732        """
    18011733        Return True if the user with given name is allowed to edit this
    18021734        worksheet.
    1803        
     1735
    18041736        INPUT:
    1805        
    1806        
     1737
    18071738        -  ``user`` - string
    1808        
    1809        
     1739
    18101740        OUTPUT: bool
    1811        
    1812         EXAMPLES: We create a notebook with one worksheet and two users.
    1813        
    1814         ::
    1815        
    1816             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1741
     1742        EXAMPLES: We create a notebook with one worksheet and two users.::
     1743
     1744            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    18171745            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    18181746            sage: nb.add_user('william', 'william', 'wstein@sagemath.org', force=True)
    18191747            sage: W = nb.create_new_worksheet('Test', 'sage')
    18201748            sage: W.user_can_edit('sage')
    18211749            True
    1822        
     1750
    18231751        At first the user 'william' can't edit this worksheet::
    1824        
     1752
    18251753            sage: W.user_can_edit('william')
    18261754            False
    1827        
     1755
    18281756        After adding 'william' as a collaborator he can edit the
    1829         worksheet.
    1830        
    1831         ::
    1832        
     1757        worksheet.::
     1758
    18331759            sage: W.add_collaborator('william')
    18341760            sage: W.user_can_edit('william')
    18351761            True
    1836        
     1762
    18371763        Clean up::
    1838        
     1764
    18391765            sage: nb.delete()
    18401766        """
    18411767        return self.is_collaborator(user) or self.is_owner(user)
    1842        
     1768
    18431769    def delete_user(self, user):
    18441770        """
    18451771        Delete a user from having any view or ownership of this worksheet.
    1846        
     1772
    18471773        INPUT:
    1848        
    1849        
     1774
    18501775        -  ``user`` - string; the name of a user
    1851        
    1852        
     1776
    18531777        EXAMPLES: We create a notebook with 2 users and 1 worksheet that
    1854         both view.
    1855        
    1856         ::
    1857        
    1858             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1778        both view.::
     1779
     1780            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    18591781            sage: nb.add_user('wstein','sage','wstein@sagemath.org',force=True)
    18601782            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    18611783            sage: W = nb.new_worksheet_with_title_from_text('Sage', owner='sage')
    class Worksheet(object): 
    18641786            'sage'
    18651787            sage: W.viewers()
    18661788            ['wstein']
    1867        
     1789
    18681790        We delete the sage user from the worksheet W. This makes wstein the
    1869         new owner.
    1870        
    1871         ::
    1872        
     1791        new owner.::
     1792
    18731793            sage: W.delete_user('sage')
    18741794            sage: W.viewers()
    18751795            ['wstein']
    18761796            sage: W.owner()
    18771797            'wstein'
    1878        
     1798
    18791799        Then we delete wstein from W, which makes the owner None::
    1880        
     1800
    18811801            sage: W.delete_user('wstein')
    18821802            sage: W.owner() is None
    18831803            True
    18841804            sage: W.viewers()
    18851805            []
    1886        
    1887         Finally, we clean up.
    1888        
    1889         ::
    1890        
     1806
     1807        Finally, we clean up.::
     1808