Ticket #7650: trac_7650-sagenb_doctesting_v2.patch

File trac_7650-sagenb_doctesting_v2.patch, 224.9 KB (added by Mitesh Patel, 13 years ago)

Quit spawned worksheet processes. Replaces previous sagenb repo patch.

  • sagenb/notebook/all.py

    # HG changeset patch
    # User Mitesh Patel <qed777@gmail.com>
    # Date 1260713762 28800
    # Node ID 489b4173fb8360449f181e891fc2f43e4239cabb
    # Parent  c45cf8480e88c25ec55fe4c74456a7ae0d8dbc7e
    #7650/sagenb: Fix doctesting under sagenb/
    
    diff --git a/sagenb/notebook/all.py b/sagenb/notebook/all.py
    a b from sage_email import email 
    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): 
    21112056                    jmol_file = open(jmol_name, 'r')
    21122057                    jmol_script = jmol_file.read()
    21132058                    jmol_file.close()
    2114                    
     2059
    21152060                    jmol_script = jmol_script.replace('defaultdirectory "', 'defaultdirectory "' + self.url_to_self() + '/')
    21162061
    21172062                    jmol_file = open(jmol_name, 'w')
    21182063                    jmol_file.write(jmol_script)
    21192064                    jmol_file.close()
    2120                    
     2065
    21212066                script = '<div><script>jmol_applet(%s, "%s?%d");</script></div>' % (size, url, time.time())
    21222067                images.append(script)
    21232068            elif F.endswith('.jmol.zip'):
    class Cell(Cell_generic): 
    21452090        Returns the HTML for self's output.
    21462091
    21472092        INPUT:
    2148        
     2093
    21492094        - ``do_print`` -- a boolean stating whether to output HTML
    21502095          for print
    21512096
    class Cell(Cell_generic): 
    21532098
    21542099        EXAMPLES::
    21552100
    2156             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     2101            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    21572102            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    21582103            sage: W = nb.create_new_worksheet('Test', 'sage')
    21592104            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    21622107        """
    21632108        if do_print and self.cell_output_type() == 'hidden':
    21642109            return '<pre>\n</pre>'
    2165        
     2110
    21662111        out_nowrap = self.output_text(0, html=True)
    21672112
    21682113        out_html = self.output_html()
    class Cell(Cell_generic): 
    21702115            out_wrap = out_nowrap
    21712116        else:
    21722117            out_wrap = self.output_text(ncols, html=True)
    2173            
     2118
    21742119        typ = self.cell_output_type()
    2175        
     2120
    21762121        if self.computing():
    21772122            cls = "cell_div_output_running"
    21782123        else:
    class Cell(Cell_generic): 
    21982143            out = out_wrap + out_html
    21992144        else:
    22002145            out = out_wrap + out_nowrap + out_html
    2201            
     2146
    22022147        s = top + out + '</div>'
    22032148
    22042149        r = ''
    class Cell(Cell_generic): 
    22152160                   r, s)
    22162161
    22172162        return tbl
    2218    
     2163
    22192164
    22202165
    22212166########
    class Cell(Cell_generic): 
    22232168def format_exception(s0, ncols):
    22242169    r"""
    22252170    Make it so exceptions don't appear expanded by default.
    2226    
     2171
    22272172    INPUT:
    2228    
    2229    
    2230     -  ``s0`` - string
    2231    
    2232     -  ``ncols`` - integer
    2233    
    2234    
    2235     OUTPUT: string
    2236    
    2237     If s0 contains "notracebacks" then this function always returns s0
    2238    
     2173
     2174    - ``s0`` - string
     2175
     2176    - ``ncols`` - integer
     2177
     2178    OUTPUT:
     2179
     2180    - a string
     2181
     2182    If s0 contains "notracebacks" then this function always returns
     2183    s0.
     2184
    22392185    EXAMPLES::
    2240    
     2186
    22412187        sage: sagenb.notebook.cell.format_exception(sagenb.notebook.cell.TRACEBACK,80)
    22422188        '\nTraceback (click to the left of this block for traceback)\n...\nTraceback (most recent call last):'
    22432189        sage: sagenb.notebook.cell.format_exception(sagenb.notebook.cell.TRACEBACK + "notracebacks",80)
    22442190        'Traceback (most recent call last):notracebacks'
    22452191    """
    22462192    s = s0.lstrip()
    2247     # Add a notracebacks option -- if it is in the string then tracebacks aren't shrunk.
    2248     # This is currently used by the sage.server.support.help command.
     2193    # Add a notracebacks option -- if it is in the string then
     2194    # tracebacks aren't shrunk.  This is currently used by the
     2195    # sage.server.support.help command.
    22492196    if TRACEBACK not in s or 'notracebacks' in s:
    22502197        return s0
    22512198    if ncols > 0:
    def format_exception(s0, ncols): 
    22592206        s = s.replace("exec compile(ur'","")
    22602207        s = s.replace("' + '\\n', '', 'single')", "")
    22612208    return s
    2262    
     2209
    22632210ComputeCell=Cell
    22642211
    2265    
     2212
    22662213def number_of_rows(txt, ncols):
    22672214    r"""
    22682215    Returns the number of rows needed to display the string in txt if
    22692216    there are a maximum of ncols columns per row.
    2270    
     2217
    22712218    EXAMPLES::
    2272    
     2219
    22732220        sage: from sagenb.notebook.cell import number_of_rows
    22742221        sage: s = "asdfasdf\nasdfasdf\n"
    22752222        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): 
    942939        W = self.create_new_worksheet(name, username)
    943940        W.edit_save('Log Worksheet\n' + self.user_history_text(username, maxlen=None))
    944941        return W
    945        
     942
    946943    def user_history_text(self, username, maxlen=None):
    947944        H = self.user_history(username)
    948945        if maxlen:
    class Notebook(object): 
    963960    def export_worksheet(self, worksheet_filename, output_filename, title=None):
    964961        """
    965962        Export a worksheet, creating a sws file on the file system.
    966        
     963
    967964        INPUT:
    968        
     965
    969966            -  ``worksheet_filename`` - a string e.g., 'username/id_number'
    970        
     967
    971968            -  ``output_filename`` - a string, e.g., 'worksheet.sws'
    972969
    973970            - ``title`` - title to use for the exported worksheet (if
    class Notebook(object): 
    993990            - ``id_number`` - nonnegative integer or None (default)
    994991        """
    995992        S = self.__storage
    996         if id_number is None:       
     993        if id_number is None:
    997994            id_number = self.new_id_number(username)
    998995        return S.load_worksheet(username, id_number)
    999        
     996
    1000997    def new_id_number(self, username):
    1001998        """
    1002999        Find the next worksheet id for the given user.
    class Notebook(object): 
    10241021        Import a worksheet with the given ``filename`` and set its
    10251022        ``owner``.  If the file extension is not txt or sws, raise a
    10261023        ValueError.
    1027        
     1024
    10281025        INPUT:
    1029        
     1026
    10301027        -  ``filename`` - a string
    1031        
     1028
    10321029        -  ``owner`` - a string
    1033        
     1030
    10341031        OUTPUT:
    1035        
     1032
    10361033        -  ``worksheet`` - a newly created Worksheet instance
    1037        
    1038         EXAMPLES: 
     1034
     1035        EXAMPLES:
    10391036
    10401037        We create a notebook and import a plain text worksheet
    10411038        into it.
    1042        
     1039
    10431040        ::
    1044        
    1045             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
    1046             sage: name = tmp_filename() + '.txt' 
     1041
     1042            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
     1043            sage: name = tmp_filename() + '.txt'
    10471044            sage: open(name,'w').write('foo\n{{{\n2+3\n}}}')
    10481045            sage: W = nb.import_worksheet(name, 'admin')
    1049        
     1046
    10501047        W is our newly-created worksheet, with the 2+3 cell in it::
    1051        
     1048
    10521049            sage: W.name()
    10531050            'foo'
    10541051            sage: W.cell_list()
    1055             [Cell 0; in=2+3, out=]
     1052            [TextCell 0: foo, Cell 1; in=2+3, out=]
    10561053        """
    10571054        if not os.path.exists(filename):
    10581055            raise ValueError, "no file %s"%filename
    class Notebook(object): 
    10701067            raise ValueError, "unknown extension '%s'"%ext
    10711068        self.__worksheets[W.filename()] = W
    10721069        return W
    1073            
     1070
    10741071    def _import_worksheet_txt(self, filename, owner):
    10751072        r"""
    10761073        Import a plain text file as a new worksheet.
    1077        
     1074
    10781075        INPUT:
    1079        
     1076
    10801077        -  ``filename`` - a string; a filename that ends in .txt
    1081        
     1078
    10821079        -  ``owner`` - a string; the imported worksheet's owner
    1083        
     1080
    10841081        OUTPUT:
    10851082
    10861083        -  a new instance of Worksheet
    1087        
    1088         EXAMPLES: 
     1084
     1085        EXAMPLES:
    10891086
    10901087        We write a plain text worksheet to a file and import it
    1091         using this function.
    1092        
    1093         ::
    1094        
    1095             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
    1096             sage: name = tmp_filename() + '.txt' 
     1088        using this function.::
     1089
     1090            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
     1091            sage: name = tmp_filename() + '.txt'
    10971092            sage: open(name,'w').write('foo\n{{{\na = 10\n}}}')
    10981093            sage: W = nb._import_worksheet_txt(name, 'admin'); W
    1099             [Cell 0; in=a = 10, out=]
     1094            admin/0: [TextCell 0: foo, Cell 1; in=a = 10, out=]
    11001095        """
    11011096        # Open the worksheet txt file and load it in.
    11021097        worksheet_txt = open(filename).read()
    class Notebook(object): 
    11051100        # Set the new worksheet to have the contents specified by that file.
    11061101        worksheet.edit_save(worksheet_txt)
    11071102        return worksheet
    1108    
    1109     def _import_worksheet_sws(self, filename, username, verbose=True):
     1103
     1104    def _import_worksheet_sws(self, filename, username):
    11101105        r"""
    11111106        Import an sws format worksheet into this notebook as a new
    1112         worksheet.  If the worksheet cannot be read, raise a
    1113         ValueError.
    1114        
     1107        worksheet.
     1108
    11151109        INPUT:
    1116        
     1110
    11171111        - ``filename`` - a string; a filename that ends in .sws;
    11181112           internally it must be a tar'd bz2'd file.
    1119        
     1113
    11201114        - ``username`` - a string
    1121        
    1122         - ``verbose`` - a bool (default: True) if True print some the
    1123            tar command used to extract the sws file.
    1124        
     1115
    11251116        OUTPUT:
    11261117
    11271118        - a new Worksheet instance
    1128        
    1129         EXAMPLES: We create a notebook, then make a worksheet from a plain
    1130         text file first.
    1131        
    1132         ::
    1133        
    1134             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
    1135             sage: name = tmp_filename() + '.txt' 
    1136             sage: open(name,'w').write('foo\n{{{\n2+3\n}}}')
     1119
     1120        EXAMPLES:
     1121
     1122        We create a notebook, then make a worksheet from a plain text
     1123        file first.::
     1124
     1125            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
     1126            sage: name = tmp_filename() + '.txt'
     1127            sage: open(name,'w').write('{{{id=0\n2+3\n}}}')
    11371128            sage: W = nb.import_worksheet(name, 'admin')
    11381129            sage: W.filename()
    11391130            'admin/0'
    1140        
    1141         We then export the worksheet to an sws file.
    1142        
    1143         ::
    1144        
    1145             sage: nb.export_worksheet(W.filename(),  'tmp.sws', verbose=False)
    1146        
    1147         Now we import the sws.
    1148        
    1149         ::
    1150        
    1151             sage: nb._import_worksheet_sws('tmp.sws', 'admin', verbose=False)
    1152             [Cell 0; in=2+3, out=]
    1153        
     1131
     1132        We then export the worksheet to an sws file.::
     1133
     1134            sage: sws = os.path.join(tmp_dir(), 'tmp.sws')
     1135            sage: nb.export_worksheet(W.filename(), sws)
     1136
     1137        Now we import the sws.::
     1138
     1139            sage: W = nb._import_worksheet_sws(sws, 'admin')
     1140            sage: nb._Notebook__worksheets[W.filename()] = W
     1141
    11541142        Yes, it's there now (as admin/2)::
    1155        
     1143
    11561144            sage: nb.worksheet_names()
    1157             ['admin/0', 'admin/2']
     1145            ['admin/0', 'admin/1']
    11581146        """
    11591147        id_number = self.new_id_number(username)
    11601148        worksheet = self.__storage.import_worksheet(username, id_number, filename)
    class Notebook(object): 
    11631151        # support multiple worksheets with the same title very well
    11641152        # already.  So it's commented out.
    11651153        # self.change_worksheet_name_to_avoid_collision(worksheet)
    1166        
     1154
    11671155        return worksheet
    11681156
    11691157    def change_worksheet_name_to_avoid_collision(self, worksheet):
    class Notebook(object): 
    11821170                i += 1
    11831171            name = name + " (%s)"%i
    11841172            worksheet.set_name(name)
    1185            
     1173
    11861174
    11871175    ##########################################################
    11881176    # Importing and exporting worksheets to a plain text format
    class Notebook(object): 
    11931181        Return HTML containing the plain text version of a worksheet.
    11941182
    11951183        INPUT:
    1196        
     1184
    11971185        - ``filename`` - a string; filename of a worksheet
    1198        
     1186
    11991187        - ``prompts`` - a bool (default: True); whether to format the
    12001188          text for inclusion in docstrings
    12011189
    12021190        OUTPUT:
    1203        
     1191
    12041192        - a string - the worksheet's HTML representation
    12051193        """
    12061194        worksheet = self.get_worksheet_with_filename(filename)
    class Notebook(object): 
    12441232            for W in self.__worksheets.itervalues():
    12451233                if W.docbrowser() and W.compute_process_has_been_started():
    12461234                    W.quit_if_idle(DOC_TIMEOUT)
    1247             return 
     1235            return
    12481236
    12491237        for W in self.__worksheets.itervalues():
    12501238            if W.compute_process_has_been_started():
    12511239                W.quit_if_idle(timeout)
    1252            
     1240
    12531241
    12541242    ##########################################################
    12551243    # Worksheet HTML generation
    class Notebook(object): 
    12591247        Return the HTML for a given worksheet.
    12601248
    12611249        INPUT:
    1262        
     1250
    12631251        - ``filename`` - a string; the worksheet's filename
    12641252
    12651253        - ``do_print`` - a bool (default: False); whether this is a
    12661254          printed worksheet
    12671255
    12681256        OUTPUT:
    1269        
     1257
    12701258        - a string - the worksheet rendered as HTML
    12711259
    12721260        EXAMPLES::
    1273        
    1274             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1261
     1262            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12751263            sage: W = nb.create_new_worksheet('Test', 'admin')
    12761264            sage: nb.worksheet_html(W.filename())
    1277             '\n<!D...ript type="text/javascript">cell_id_list=[0];</script>\n\n\n\n\n\n    </body>\n</html>'
     1265            '\n<!D...Test...cell_id_list=[1]...</body>...</html>'
    12781266        """
    12791267        worksheet = self.get_worksheet_with_filename(filename)
    12801268        return template(os.path.join("html", "notebook", "worksheet.html"),
    class Notebook(object): 
    12821270                 worksheet_html = worksheet.html(include_title=False, do_print=do_print),
    12831271                        do_print = do_print)
    12841272
    1285    
     1273
    12861274
    12871275    def worksheet_list_for_public(self, username, sort='last_edited', reverse=False, search=None):
    12881276        W = [x for x in self.__worksheets.itervalues() if x.is_published() and not x.is_trashed(user)]
    class Notebook(object): 
    13141302        Return HTML for the revision list of a worksheet.
    13151303
    13161304        INPUT:
    1317        
     1305
    13181306        - ``username`` - a string
    1319        
     1307
    13201308        - ``worksheet`` - an instance of Worksheet
    13211309
    13221310        OUTPUT:
    class Notebook(object): 
    13241312        - a string - the HTML for the revision list
    13251313
    13261314        EXAMPLES::
    1327        
    1328             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1315
     1316            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13291317            sage: W = nb.create_new_worksheet('Test', 'admin')
     1318            sage: W.body()
     1319            '\n\n{{{id=1|\n\n///\n}}}'
     1320            sage: W.save_snapshot('admin')
    13301321            sage: nb.html_worksheet_revision_list('admin', W)
    13311322            '\n<!D...seconds ago</span></td>\n    </tr>\n\n</table>\n\n\n    </body>\n</html>'
    13321323        """
    class Notebook(object): 
    13441335        Return the HTML for a specific revision of a worksheet.
    13451336
    13461337        INPUT:
    1347        
     1338
    13481339        - ``username`` - a string
    1349        
     1340
    13501341        - ``ws`` - an instance of Worksheet
    1351        
     1342
    13521343        - ``rev`` - a string containing the key of the revision
    13531344
    13541345        OUTPUT:
    1355        
     1346
    13561347        - a string - the revision rendered as HTML
    13571348        """
    13581349        t = time.time() - float(rev[:-4])
    13591350        time_ago = worksheet.convert_seconds_to_meaningful_time_span(t)
    1360        
     1351
    13611352        filename = ws.get_snapshot_text_filename(rev)
    13621353        txt = bz2.decompress(open(filename).read())
    13631354        W = self.scratch_worksheet()
    class Notebook(object): 
    13751366                if i < len(data)-1:
    13761367                    next_rev = data[i+1][1]
    13771368                break
    1378            
     1369
    13791370        return template(os.path.join("html", "notebook", "specific_revision.html"),
    13801371                        worksheet = ws, worksheet_filename = ws.filename(),
    13811372                        username = username, rev = rev, prev_rev = prev_rev,
    class Notebook(object): 
    13881379        Return the HTML for the "share" page of a worksheet.
    13891380
    13901381        INPUT:
    1391        
     1382
    13921383        - ``username`` - a string
    1393        
     1384
    13941385        - ``worksheet`` - an instance of Worksheet
    13951386
    13961387        OUTPUT:
    13971388
    13981389        - string - the share page's HTML representation
    1399        
     1390
    14001391        EXAMPLES::
    1401        
    1402             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1392
     1393            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14031394            sage: W = nb.create_new_worksheet('Test', 'admin')
    14041395            sage: nb.html_share(W, 'admin')
    14051396            '\n<!D...span class="username">Sage Users:</span>\n<span class="users">\n    \n</span>\n\n\n\n    </body>\n</html>'
    class Notebook(object): 
    14201411        Return the HTML for the download or delete datafile page.
    14211412
    14221413        INPUT:
    1423        
     1414
    14241415        - ``username`` - a string
    1425        
     1416
    14261417        - ``ws`` - an instance of Worksheet
    1427        
     1418
    14281419        - ``filename`` - a string; the name of the file
    14291420
    14301421        OUTPUT:
    1431        
     1422
    14321423        - a string - the page rendered as HTML
    14331424
    14341425        EXAMPLES::
    1435        
    1436             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1426
     1427            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14371428            sage: W = nb.create_new_worksheet('Test', 'admin')
    14381429            sage: nb.html_download_or_delete_datafile(W, 'admin', 'bar')
    14391430            '\n<!D...ploaded to this worksheet.</p>\n\n<hr class="usercontrol" />\n\n\n\n\n    </body>\n</html>'
    class Notebook(object): 
    14431434        worksheets = self.get_worksheets_with_viewer(username)
    14441435        active_worksheets = [worksheet for worksheet in worksheets if worksheet.is_active(username)]
    14451436        sort_worksheet_list(active_worksheets, 'name', False)
    1446        
     1437
    14471438        ext = os.path.splitext(filename)[1].lower()
    14481439        file_is_image, file_is_text = False, False
    14491440        text_file_content = ""
    1450        
     1441
    14511442        if ext in ['.png', '.jpg', '.gif']:
    14521443            file_is_image = True
    14531444        if ext in ['.txt', '.tex', '.sage', '.spyx', '.py', '.f', '.f90', '.c']:
    class Notebook(object): 
    14661457
    14671458
    14681459    ##########################################################
    1469     # Accessing all worksheets with certain properties. 
     1460    # Accessing all worksheets with certain properties.
    14701461    ##########################################################
    14711462    def get_all_worksheets(self):
    14721463        return [x for x in self.__worksheets.itervalues() if not x.owner() in ['_sage_', 'pub']]
    1473    
     1464
    14741465    def get_worksheets_with_collaborator(self, user):
    1475         if self.user_is_admin(user): return self.get_all_worksheets()       
     1466        if self.user_is_admin(user): return self.get_all_worksheets()
    14761467        return [w for w in self.__worksheets.itervalues() if w.user_is_collaborator(user)]
    14771468
    14781469    def get_worksheet_names_with_collaborator(self, user):
    class Notebook(object): 
    14901481        return [w for w in self.get_worksheets_with_owner(owner) if w.user_is_viewer(user)]
    14911482
    14921483    def get_worksheet_names_with_viewer(self, user):
    1493         if self.user_is_admin(user): return [W.name() for W in self.get_all_worksheets()]       
     1484        if self.user_is_admin(user): return [W.name() for W in self.get_all_worksheets()]
    14941485        return [W.name() for W in self.get_worksheets_with_viewer(user) if not W.docbrowser()]
    14951486
    14961487    def get_worksheet_with_name(self, name):
    class Notebook(object): 
    15031494        """
    15041495        Get the worksheet with the given filename.  If there is no
    15051496        such worksheet, raise a ``KeyError``.
    1506        
     1497
    15071498        INPUT:
    15081499
    15091500        - ``filename`` - a string
    class Notebook(object): 
    15521543        Return the HTML for the debug window.
    15531544
    15541545        OUTPUT:
    1555        
     1546
    15561547        - a string - the debug window rendered as HTML
    1557    
     1548
    15581549        EXAMPLES::
    15591550
    1560             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1551            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15611552            sage: nb.html_debug_window()
    15621553            "\n<div class='debug_window'>...</div>"
    15631554        """
    15641555        return template(os.path.join("html", "notebook", "debug_window.html"))
    15651556
    1566    
     1557
    15671558    def html_plain_text_window(self, worksheet, username):
    15681559        r"""
    15691560        Return HTML for the window that displays a plain text version
    class Notebook(object): 
    15801571        - a string - the plain text window rendered as HTML
    15811572
    15821573        EXAMPLES::
    1583        
    1584             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1574
     1575            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15851576            sage: W = nb.create_new_worksheet('Test', 'admin')
    15861577            sage: nb.html_plain_text_window(W, 'admin')
    15871578            '\n<!D...>\n\n<pre class="plaintext" id="cell_intext" name="textfield"></pre>\n\n\n    </body>\n</html>'
    15881579        """
    15891580        plain_text = worksheet.plain_text(prompts=True, banner=False)
    15901581        plain_text = escape(plain_text).strip()
    1591          
     1582
    15921583        return template(os.path.join("html", "notebook", "plain_text_window.html"),
    15931584                        worksheet = worksheet,
    15941585                        worksheet_filename = worksheet.filename(),
    15951586                        username = username, plain_text = plain_text,
    15961587                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1597                        
     1588
    15981589    def html_edit_window(self, worksheet, username):
    15991590        r"""
    16001591        Return HTML for a window for editing ``worksheet``.
    1601        
     1592
    16021593        INPUT:
    1603        
     1594
    16041595        - ``username`` - a string containing the username
    1605        
     1596
    16061597        - ``worksheet`` - a Worksheet instance
    16071598
    16081599        OUTPUT:
    1609        
     1600
    16101601        - a string - the editing window's HTML representation
    16111602
    16121603        EXAMPLES::
    1613        
    1614             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1604
     1605            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16151606            sage: W = nb.create_new_worksheet('Test', 'admin')
    16161607            sage: nb.html_edit_window(W, 'admin')
    1617             '\n<!D...Test\nsystem:sage\n\n{{{id=0|\n\n///\n}}}</textarea>\n</form>\n\n\n    </body>\n</html>'
     1608            '\n<!D...Test...\n\n{{{id=1|\n\n///\n}}}</textarea>\n</form>\n\n\n    </body>\n</html>'
    16181609        """
    16191610        text = worksheet.edit_text()
    16201611        text = escape(text)
    16211612        n_lines = text.count("\n")+1
    1622          
     1613
    16231614        return template(os.path.join("html", "notebook", "edit_window.html"),
    16241615                        worksheet = worksheet,
    16251616                        worksheet_filename = worksheet.filename(),
    16261617                        username = username, text = text, n_lines = n_lines,
    16271618                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1628    
     1619
    16291620    def html_beforepublish_window(self, worksheet, username):
    16301621        r"""
    16311622        Return HTML for the warning and decision page displayed prior
    16321623        to publishing the given worksheet.
    1633        
     1624
    16341625        INPUT:
    1635        
     1626
    16361627        - ``worksheet`` - an instance of Worksheet
    1637        
     1628
    16381629        - ``username`` - a string
    16391630
    16401631        OUTPUT:
    class Notebook(object): 
    16421633        - a string - the pre-publication page rendered as HTML
    16431634
    16441635        EXAMPLES::
    1645        
    1646             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1636
     1637            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16471638            sage: W = nb.create_new_worksheet('Test', 'admin')
    16481639            sage: nb.html_beforepublish_window(W, 'admin')
    16491640            '\n<!D...publish when changes are made</form></span>\n<br /><br /><br />\n\n\n    </body>\n</html>'
    class Notebook(object): 
    16631654                        worksheet_filename = worksheet.filename(),
    16641655                        username = username,
    16651656                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1666        
     1657
    16671658    def html_afterpublish_window(self, worksheet, username, url, dtime):
    16681659        r"""
    16691660        Return HTML for a given worksheet's post-publication page.
    1670        
     1661
    16711662        INPUT:
    1672        
     1663
    16731664        - ``worksheet`` - an instance of Worksheet
    1674        
     1665
    16751666        - ``username`` - a string
    1676        
     1667
    16771668        - ``url`` - a string representing the URL of the published
    16781669          worksheet
    1679        
     1670
    16801671        - ``dtime`` - an instance of time.struct_time representing the
    16811672          publishing time
    16821673
    16831674        OUTPUT:
    16841675
    16851676        - a string - the post-publication page rendered as HTML
    1686 
    16871677        """
    16881678        from time import strftime
    16891679        time = strftime("%B %d, %Y %I:%M %p", dtime)
    1690        
     1680
    16911681        return template(os.path.join("html", "notebook", "afterpublish_window.html"),
    16921682                        worksheet = worksheet,
    16931683                        worksheet_filename = worksheet.filename(),
    class Notebook(object): 
    16991689        Return HTML for the "Upload Data" window.
    17001690
    17011691        INPUT:
    1702        
     1692
    17031693        - ``worksheet`` - an instance of Worksheet
    1704        
     1694
    17051695        - ``username`` - a string
    17061696
    17071697        OUTPUT:
    class Notebook(object): 
    17091699        - a string - the HTML representation of the data upload window
    17101700
    17111701        EXAMPLES::
    1712        
    1713             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1702
     1703            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17141704            sage: W = nb.create_new_worksheet('Test', 'admin')
    17151705            sage: nb.html_upload_data_window(W, 'admin')
    1716             '\n<!D...orksheet_menu" value="Upload File" onClick="form.submit()...r />\n</div>\n\n\n    </body>\n</html>'
     1706            '\n<!D...orksheet_menu" value="Upload or Create Data File" onClick="form.submit()...r />\n</div>\n\n\n    </body>\n</html>'
    17171707        """
    17181708        return template(os.path.join("html", "notebook", "upload_data_window.html"),
    17191709                        worksheet = ws, worksheet_filename = ws.filename(),
    class Notebook(object): 
    17251715        Return the HTML for a worksheet's index page.
    17261716
    17271717        INPUT:
    1728        
     1718
    17291719        - ``worksheet_filename`` - a string (default: None)
    1730        
     1720
    17311721        - ``username`` - a string (default: 'guest')
    17321722
    17331723        - ``show_debug`` - a bool (default: False)
    1734        
     1724
    17351725        - ``admin`` - a bool (default: False)
    17361726
    17371727        OUTPUT:
    class Notebook(object): 
    17391729        - a string - the worksheet rendered as HTML
    17401730
    17411731        EXAMPLES::
    1742        
    1743             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1732
     1733            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17441734            sage: W = nb.create_new_worksheet('Test', 'admin')
    17451735            sage: nb.html(W.filename(), 'admin')
    17461736            '\n<!D...ipt type="text/javascript">worksheet_locked=false;</script>\n\n\n\n    </body>\n</html>'
    class Notebook(object): 
    17571747        template_page = os.path.join("html", "notebook", "index.html")
    17581748        if W.docbrowser():
    17591749            template_page = os.path.join("html", "notebook", "doc_page.html")
    1760            
     1750
    17611751        return template(template_page, worksheet = W,
    17621752                        worksheet_filename = W.filename(),
    17631753                        worksheet_html = W.html(), notebook = self,
    class Notebook(object): 
    17671757    def html_doc(self, username):
    17681758        r"""
    17691759        Return the HTML for the a documentation page.
    1770        
     1760
    17711761        INPUT:
    1772        
     1762
    17731763        - ``username`` - a string
    1774        
     1764
    17751765        OUTPUT:
    17761766
    17771767        - a string - the doc page rendered as HTML
    17781768
    17791769        EXAMPLES::
    1780        
    1781             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1770
     1771            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17821772            sage: W = nb.create_new_worksheet('Test', 'admin')
    17831773            sage: nb.html_doc('admin')
    17841774            '\n<!D...c Documentation</a><br /><br />\n        <a href="/help/">Sage Notebook Howto...   </body>\n</html>'
    class Notebook(object): 
    17861776        return template(os.path.join("html", "notebook", "doc.html"),
    17871777                        username = username,
    17881778                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1789        
     1779
    17901780
    17911781####################################################################
    17921782
    def load_notebook(dir, address=None, por 
    17941784    """
    17951785    Load and return a notebook from a given directory.  Create a new
    17961786    one in that directory, if one isn't already there.
    1797    
     1787
    17981788    INPUT:
    1799    
     1789
    18001790    -  ``dir`` - a string that defines a directory name
    1801    
     1791
    18021792    -  ``address`` - the address the server listens at
    1803    
     1793
    18041794    -  ``port`` - the port the server listens on
    1805    
     1795
    18061796    -  ``secure`` - whether the notebook is secure
    18071797
    18081798    OUTPUT:
    def load_notebook(dir, address=None, por 
    18171807                raise KeyboardInterrupt, "Interrupted notebook migration.  Delete the directory '%s' and try again."%(os.path.abspath(dir+'.sagenb'))
    18181808            return nb
    18191809        dir += '.sagenb'
    1820        
     1810
    18211811    dir = make_path_relative(dir)
    18221812    nb = Notebook(dir)
    18231813    nb.address = address
    def migrate_old_notebook_v1(dir): 
    18391829    """
    18401830    nb_sobj = os.path.join(dir, 'nb.sobj')
    18411831    old_nb = cPickle.loads(open(nb_sobj).read())
    1842    
     1832
    18431833    ######################################################################
    18441834    # Tell user what is going on and make a backup
    18451835    ######################################################################
    18461836
    18471837    print ""
    18481838    print "*"*80
    1849     print "*"   
     1839    print "*"
    18501840    print "* The Sage notebook at"
    1851     print "*"   
     1841    print "*"
    18521842    print "*      '%s'"%os.path.abspath(dir)
    1853     print "*"   
     1843    print "*"
    18541844    print "* will be upgraded to a new format and stored in"
    18551845    print "*"
    18561846    print "*      '%s.sagenb'."%os.path.abspath(dir)
    def migrate_old_notebook_v1(dir): 
    18661856    # Create new notebook
    18671857    new_nb = Notebook(dir+'.sagenb')
    18681858
    1869     # Define a function for transfering the attributes of one object to another. 
     1859    # Define a function for transfering the attributes of one object to another.
    18701860    def transfer_attributes(old, new, attributes):
    18711861        for attr_old, attr_new in attributes:
    18721862            if hasattr(old, attr_old):
    18731863                setattr(new, attr_new,  getattr(old, attr_old))
    1874                
     1864
    18751865    # Transfer all the notebook attributes to our new notebook object
    1876    
     1866
    18771867    new_nb.conf().confs = old_nb.conf().confs
    18781868    for t in ['pretty_print', 'server_pool', 'ulimit', 'system']:
    18791869        if hasattr(old_nb, '_Notebook__' + t):
    18801870            new_nb.conf().confs[t] = getattr(old_nb, '_Notebook__' + t)
    1881    
     1871
    18821872    # Now update the user data from the old notebook to the new one:
    18831873    print "Migrating %s user accounts..."%len(old_nb.users())
    18841874    users = new_nb.users()
    def migrate_old_notebook_v1(dir): 
    18931883        # Fix the __conf field, which is also an instance of a class
    18941884        new_user.conf().confs = old_user.conf().confs
    18951885        users[new_user.username()] = new_user
    1896        
     1886
    18971887    ######################################################################
    18981888    # Set the worksheets of the new notebook equal to the ones from
    18991889    # the old one.
    19001890    ######################################################################
    1901    
     1891
    19021892    ######################################################################
    1903    
     1893
    19041894    def migrate_old_worksheet(old_worksheet):
    19051895        """
    1906         Migrates an old worksheet to the new format. 
     1896        Migrates an old worksheet to the new format.
    19071897        """
    19081898        old_ws_dirname = old_ws._Worksheet__filename.partition(os.path.sep)[-1]
    19091899        new_ws = new_nb.worksheet(old_ws.owner(), old_ws_dirname)
    def migrate_old_notebook_v1(dir): 
    19151905                if isinstance(user,str):
    19161906                    # There was a bug in the old notebook where sometimes the
    19171907                    # user was the *module* "user", so we don't include that
    1918                     # invalid data. 
     1908                    # invalid data.
    19191909                    tags[user] = [val]
    19201910        except AttributeError:
    19211911            pass
    def migrate_old_notebook_v1(dir): 
    19281918
    19291919        ws_pub = old_ws.worksheet_that_was_published().filename().split('/')
    19301920        ws_pub = (ws_pub[0],int(ws_pub[1]))
    1931            
     1921
    19321922        obj = {'name':old_ws.name(), 'system':old_ws.system(),
    19331923               'viewers':old_ws.viewers(), 'collaborators':old_ws.collaborators(),
    19341924               'pretty_print':old_ws.pretty_print(), 'ratings':old_ws.ratings(),
    def migrate_old_notebook_v1(dir): 
    19391929               }
    19401930
    19411931        new_ws.reconstruct_from_basic(obj)
    1942        
     1932
    19431933        base = os.path.join(dir, 'worksheets', old_ws.filename())
    19441934        worksheet_file = os.path.join(base, 'worksheet.txt')
    19451935        if os.path.exists(worksheet_file):
    def migrate_old_notebook_v1(dir): 
    19651955                shutil.copytree(old_ws.cells_directory(), dest)
    19661956        except Exception, msg:
    19671957            print msg
    1968                
     1958
    19691959
    19701960        return new_ws
    1971    
     1961
    19721962    worksheets = {}
    19731963    num_worksheets = len(old_nb._Notebook__worksheets)
    19741964    print "Migrating (at most) %s worksheets..."%num_worksheets
    def make_path_relative(dir): 
    20081998
    20091999    INPUT:
    20102000
    2011     - ``dir`` - a string containing, e.g., a directory name 
     2001    - ``dir`` - a string containing, e.g., a directory name
    20122002
    20132003    OUTPUT:
    20142004
    def make_path_relative(dir): 
    20212011
    20222012##########################################################
    20232013# Misc
    2024 ##########################################################   
     2014##########################################################
    20252015
    20262016def clean_name(name):
    20272017    return ''.join([x if (x.isalnum() or x == '_') else '_' for x in name])
    def sort_worksheet_list(v, sort, reverse 
    20312021    Sort a given list on a given key, in a given order.
    20322022
    20332023    INPUT:
    2034    
     2024
    20352025    - ``sort`` - a string; 'last_edited', 'owner', 'rating', or 'name'
    2036    
     2026
    20372027    - ``reverse`` - a bool; if True, reverse the order of the sort.
    20382028
    20392029    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 
    196196        sage: passwd = str(randint(1,1<<128))
    197197        sage: nb = test_notebook(passwd, address='localhost', port=8060)
    198198        sage: import urllib
    199         sage: h = urllib.urlopen('https://localhost:8060')
     199        sage: h = urllib.urlopen('http://localhost:8060')
    200200        sage: homepage = h.read()
    201201        sage: h.close()
    202202        sage: 'html' in homepage
    def test_notebook(admin_passwd, secure=F 
    227227        except pexpect.EOF:
    228228            pass
    229229        p.close(force=True)
    230         shutil.rmtree(nb.directory())
     230        shutil.rmtree(nb._dir)
    231231    p.dispose = dispose
    232232    if verbose:
    233233        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('Oldpass', [None])[0]
    962960        new = request.args.get('Newpass', [None])[0]
    def render_worksheet_list(args, pub, use 
    15141512    -  ``username`` - the user whose worksheets we are
    15151513       listing
    15161514
    1517     OUTPUT: 
     1515    OUTPUT:
    15181516
    15191517    a string
    15201518    """
    class EmptyTrash(resource.Resource): 
    15901588        This twisted resource empties the trash of the current user when it
    15911589        is rendered.
    15921590
    1593         EXAMPLES:
    1594 
    1595         We create an instance of this resource.
    1596 
    1597         ::
     1591        EXAMPLES:
     1592
     1593        We create an instance of this resource.::
    15981594
    15991595            sage: import sagenb.notebook.twist
    16001596            sage: E = sagenb.notebook.twist.EmptyTrash('sage'); E
    class EmptyTrash(resource.Resource): 
    16071603        Rendering this resource (1) empties the trash, and (2) returns a
    16081604        message.
    16091605
    1610         EXAMPLES: 
     1606        EXAMPLES:
    16111607
    16121608        We create a notebook with a worksheet, put it in the
    16131609        trash, then empty the trash by creating and rendering this
    1614         worksheet.
    1615 
    1616         ::
    1617 
    1618             sage: n = sagenb.notebook.notebook.Notebook('notebook-test')
     1610        worksheet.::
     1611
     1612            sage: n = sagenb.notebook.notebook.load_notebook('notebook-test.sagenb')
    16191613            sage: n.add_user('sage','sage','sage@sagemath.org',force=True)
    16201614            sage: W = n.new_worksheet_with_title_from_text('Sage', owner='sage')
    16211615            sage: W.move_to_trash('sage')
    class EmptyTrash(resource.Resource): 
    16241618            sage: sagenb.notebook.twist.notebook = n
    16251619            sage: E = sagenb.notebook.twist.EmptyTrash('sage'); E
    16261620            <sagenb.notebook.twist.EmptyTrash object at ...>
    1627             sage: E.render(None)
    1628             <twisted.web2.http.Response code=200, streamlen=...>
     1621            sage: from sagenb.notebook.twist import HTMLResponse
     1622            sage: ctx = HTMLResponse(stream = 'foo')
     1623            sage: ctx.headers.addRawHeader('referer', 'over there')
     1624            sage: E.render(ctx)
     1625            <RedirectResponse 301 Document moved to over there.>
    16291626
    16301627        Finally we verify that the trashed worksheet is gone::
    16311628
    class JSMath_js(resource.Resource): 
    18261823        s = template(os.path.join('js', 'jsmath.js'),
    18271824                     jsmath_macros = jsmath_macros,
    18281825                     jsmath_image_fonts = jsmath_image_fonts)
    1829        
     1826
    18301827        return http.Response(stream=s)
    18311828
    18321829class Main_js(resource.Resource):
    import re 
    19451942re_valid_username = re.compile('[a-z|A-Z|0-9|_|.|@]*')
    19461943def is_valid_username(username):
    19471944    r"""
    1948     Returns True if and only if ``username`` is valid, i.e., between 3
    1949     and 64 characters long. You may only use letters, numbers,
    1950     underscores, @, and dots.
     1945    Returns whether a candidate username is valid.  It must contain
     1946    between 3 and 65 of these characters: letters, numbers,
     1947    underscores, @, and/or dots ('.').
     1948
     1949    INPUT:
     1950
     1951    - ``username`` - a string; the candidate username
     1952
     1953    OUTPUT:
     1954
     1955    - a boolean
    19511956
    19521957    EXAMPLES::
    19531958
    19541959        sage: from sagenb.notebook.twist import is_valid_username
    1955 
    1956     ``username`` must start with a letter
    1957 
    1958     ::
    1959 
    19601960        sage: is_valid_username('mark10')
    19611961        True
    19621962        sage: is_valid_username('10mark')
    19631963        False
    1964 
    1965     ``username`` must be between 4 and 32 characters long
    1966 
    1967     ::
    1968 
    1969         sage: is_valid_username('bob')
     1964        sage: is_valid_username('me')
    19701965        False
    1971         sage: is_valid_username('I_love_computer_science_and_maths') #33 characters long
     1966        sage: is_valid_username('abcde' * 13)
    19721967        False
    1973 
    1974     ``username`` must not have more than one dot (.)
    1975 
    1976     ::
    1977 
    1978         sage: is_valid_username('david.andrews')
    1979         True
    1980         sage: is_valid_username('david.m.andrews')
    1981         False
    1982         sage: is_valid_username('math125.TA.5')
    1983         False
    1984 
    1985     ``username`` must not have any spaces
    1986 
    1987     ::
    1988 
    19891968        sage: is_valid_username('David Andrews')
    19901969        False
    19911970        sage: is_valid_username('David M. Andrews')
    19921971        False
    1993 
    1994     ::
    1995 
    19961972        sage: is_valid_username('sarah_andrews')
    19971973        True
    1998 
    1999     ::
    2000 
    20011974        sage: is_valid_username('TA-1')
    20021975        False
    20031976        sage: is_valid_username('math125-TA')
    20041977        False
    2005 
    2006     ::
    2007 
    20081978        sage: is_valid_username('dandrews@sagemath.org')
    2009         False
     1979        True
    20101980    """
    20111981    import string
    20121982
    class LoginResourceClass(resource.Resour 
    23952365        template_dict = {'accounts': notebook.get_accounts(),
    23962366                         'default_user': notebook.default_user(),
    23972367                         'recovery': notebook.conf()['email'],
    2398                          'sage_version':SAGE_VERSION}                         
     2368                         'sage_version':SAGE_VERSION}
    23992369        return HTMLResponse(stream=template(os.path.join('html', 'login.html'), **template_dict))
    24002370
    24012371    def childFactory(self, request, name):
    class FailedToplevel(Toplevel): 
    24602430                             'default_user': self.username,
    24612431                             'password_error': True,
    24622432                             'recovery': notebook.conf()['email'],
    2463                              'sage_version':SAGE_VERSION}                             
     2433                             'sage_version':SAGE_VERSION}
    24642434            return HTMLResponse(stream=template(os.path.join('html', 'login.html'), **template_dict))
    24652435        elif self.problem == 'suspended':
    24662436            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' 
    6868SAGE_ERROR = SC + 'r'
    6969
    7070# Integers that define which folder this worksheet is in
    71 # relative to a given user. 
     71# relative to a given user.
    7272ARCHIVED = 0
    7373ACTIVE   = 1
    7474TRASH    = 2
    all_worksheet_processes = [] 
    7777
    7878def update_worksheets():
    7979    """
    80     Iterate through and "update" all the worksheets.  This is needed for things like
    81     wall timeouts.
     80    Iterate through and "update" all the worksheets.  This is needed
     81    for things like wall timeouts.
    8282    """
    8383    for S in all_worksheet_processes:
    8484        S.update()
    def worksheet_filename(name, owner): 
    8989    """
    9090    Return the relative directory name of this worksheet with given
    9191    name and owner.
    92    
     92
    9393    INPUT:
    94    
    95    
     94
    9695    -  ``name`` - string, which may have spaces and funny
    9796       characters, which are replaced by underscores.
    98    
     97
    9998    -  ``owner`` - string, with no spaces or funny
    10099       characters
    101    
    102    
     100
    103101    OUTPUT: string
    104    
     102
    105103    EXAMPLES::
    106    
     104
    107105        sage: sagenb.notebook.worksheet.worksheet_filename('Example worksheet 3', 'sage10')
    108106        'sage10/Example_worksheet_3'
    109107        sage: sagenb.notebook.worksheet.worksheet_filename('Example#%&! work\\sheet 3', 'sage10')
    def Worksheet_from_basic(obj, notebook_w 
    123121           stores worksheets, i.e., nb.worksheet_directory().
    124122
    125123    OUTPUT:
    126    
     124
    127125        - a worksheet
    128126
    129127    EXAMPLES::
     128
    130129            sage: import sagenb.notebook.worksheet
    131             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
     130            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
    132131            sage: _=W.new_cell_after(0); B = W.basic()
    133             sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, '')
     132            sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, tmp_dir())
    134133            sage: W0.basic() == B
    135134            True
    136135    """
    class Worksheet(object): 
    146145                 auto_publish=False, create_directories=True):
    147146        """
    148147        Create and initialize a new worksheet.
    149        
     148
    150149        INPUT:
    151        
    152        
     150
    153151        -  ``name`` - string; the name of this worksheet
    154        
     152
    155153        - ``id_number`` - Integer; name of the directory in which the
    156154           worksheet's data is stored
    157        
     155
    158156        -  ``notebook_worksheet_directory`` - string; the
    159157           directory in which the notebook object that contains this worksheet
    160158           stores worksheets, i.e., nb.worksheet_directory().
    161        
     159
    162160        -  ``system`` - string; 'sage', 'gp', 'singular', etc.
    163161           - the math software system in which all code is evaluated by
    164162           default
    165        
     163
    166164        -  ``owner`` - string; username of the owner of this
    167165           worksheet
    168        
     166
    169167        -  ``docbrowser`` - bool (default: False); whether this
    170168           is a docbrowser worksheet
    171        
     169
    172170        -  ``pretty_print`` - bool (default: False); whether
    173171           all output is pretty printed by default.
    174172
    class Worksheet(object): 
    176174          creates various files and directories where data will be
    177175          stored.  This option is here only for the
    178176          migrate_old_notebook method in notebook.py
    179        
    180        
     177
    181178        EXAMPLES: We test the constructor via an indirect doctest::
    182        
    183             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     179
     180            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    184181            sage: W = nb.create_new_worksheet('Test', 'admin')
    185182            sage: W
    186             admin/0: [Cell 0; in=, out=]
     183            admin/0: [Cell 1; in=, out=]
    187184        """
    188185        if name is None:
    189186            # A fresh worksheet
    class Worksheet(object): 
    201198
    202199        # state sequence number, used for sync
    203200        self.__state_number = 0
    204        
     201
    205202        # Initialize the cell id counter.
    206203        self.__next_id = 0
    207204
    class Worksheet(object): 
    246243        EXAMPLES::
    247244
    248245            sage: from sagenb.notebook.worksheet import Worksheet
    249             sage: W = Worksheet('test', 2, '', owner='sageuser')
     246            sage: W = Worksheet('test', 2, tmp_dir(), owner='sageuser')
    250247            sage: W.id_number()
    251248            2
    252249            sage: type(W.id_number())
    class Worksheet(object): 
    264261        configuration of this worksheet, except the actual cells and
    265262        the data files in the DATA directory and images and other data
    266263        in the individual cell directories.
    267        
     264
    268265        EXAMPLES::
    269266
    270267            sage: import sagenb.notebook.worksheet
    271             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', owner='sage')
     268            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), owner='sage')
    272269            sage: sorted((W.basic().items()))
    273270            [('auto_publish', False),
    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', {}),
    284              ('viewers', []),
    285              ('worksheet_that_was_published', None)]
     271              ('collaborators', []),
     272              ('id_number', 0),
     273              ('last_change', ('sage', ...)),
     274              ('name', 'test'),
     275              ('owner', 'sage'),
     276              ('pretty_print', False),
     277              ('published_id_number', None),
     278              ('ratings', []),
     279              ('system', None),
     280              ('tags', {'sage': [1]}),
     281              ('viewers', []),
     282              ('worksheet_that_was_published', ('sage', 0))]
    286283        """
    287284        try:
    288285            published_id_number = int(os.path.split(self.__published_version)[1])
    class Worksheet(object): 
    293290            ws_pub = self.__worksheet_came_from
    294291        except AttributeError:
    295292            ws_pub = (self.owner(), self.id_number())
    296            
     293
    297294        d = {#############
    298295             # basic identification
    299296             'name':self.name(),
    class Worksheet(object): 
    320317             # worksheet.  Otherwise ws_pub is None.
    321318             'worksheet_that_was_published':ws_pub,
    322319             # Whether or not this worksheet should automatically be
    323              # republished when changed. 
     320             # republished when changed.
    324321             'auto_publish':self.is_auto_publish(),
    325322
    326323             # Appearance: e.g., whether to pretty print this
    class Worksheet(object): 
    361358              ``id_number`` is a key of obj; otherwise not.
    362359
    363360        EXAMPLES::
     361
    364362            sage: import sagenb.notebook.worksheet
    365             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
     363            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
    366364            sage: W.new_cell_after(0)
    367365            Cell 1; in=, out=
    368366            sage: b = W.basic()
    369367            sage: W0 = sagenb.notebook.worksheet.Worksheet()
    370             sage: W0.reconstruct_from_basic(b,'')
     368            sage: W0.reconstruct_from_basic(b, tmp_dir())
    371369            sage: W0.basic() == W.basic()
    372370            True
    373371        """
    class Worksheet(object): 
    403401    def __cmp__(self, other):
    404402        """
    405403        We compare two worksheets.
    406        
     404
    407405        INPUT:
    408        
    409        
     406
    410407        -  ``self, other`` - worksheets
    411        
    412        
     408
    413409        OUTPUT:
    414        
    415        
     410
    416411        -  ``-1,0,1`` - comparison is on the underlying
    417412           file names.
    418        
    419        
     413
    420414        EXAMPLES::
    421        
    422             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     415
     416            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    423417            sage: W2 = nb.create_new_worksheet('test2', 'admin')
    424418            sage: W1 = nb.create_new_worksheet('test1', 'admin')
    425419            sage: cmp(W1, W2)
    class Worksheet(object): 
    436430        r"""
    437431        Return string representation of this worksheet, which is simply the
    438432        string representation of the underlying list of cells.
    439        
     433
    440434        OUTPUT: string
    441        
     435
    442436        EXAMPLES::
    443        
    444             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     437
     438            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    445439            sage: W = nb.create_new_worksheet('test1', 'admin')
    446440            sage: W.__repr__()
    447             'admin/0: [Cell 0; in=, out=]'
    448             sage: W.edit_save('Sage\n{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
     441            'admin/0: [Cell 1; in=, out=]'
     442            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
    449443            sage: W.__repr__()
    450444            'admin/0: [Cell 0; in=2+3, out=\n5, Cell 10; in=2+8, out=\n10]'
    451445        """
    class Worksheet(object): 
    453447    def __len__(self):
    454448        r"""
    455449        Return the number of cells in this worksheet.
    456        
     450
    457451        OUTPUT: int
    458        
     452
    459453        EXAMPLES::
    460        
    461             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     454
     455            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    462456            sage: W = nb.create_new_worksheet('test1', 'admin')
    463457            sage: len(W)
    464458            1
    465             sage: W.edit_save('Sage\n{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
     459            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
    466460            sage: len(W)
    467461            2
    468462        """
    class Worksheet(object): 
    484478    def docbrowser(self):
    485479        """
    486480        Return True if this is a docbrowser worksheet.
    487        
     481
    488482        OUTPUT: bool
    489        
     483
    490484        EXAMPLES: We first create a standard worksheet for which docbrowser
    491485        is of course False::
    492        
    493             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     486
     487            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    494488            sage: W = nb.create_new_worksheet('test1', 'admin')
    495489            sage: W.docbrowser()
    496490            False
    497        
     491
    498492        We create a worksheet for which docbrowser is True::
    499        
     493
    500494            sage: W = nb.create_new_worksheet('docs', 'admin', docbrowser=True)
    501495            sage: W.docbrowser()
    502496            True
    class Worksheet(object): 
    516510        """
    517511        Return a (reference to the) list of the collaborators who can also
    518512        view and modify this worksheet.
    519        
     513
    520514        OUTPUT: list
    521        
     515
    522516        EXAMPLES::
    523        
    524             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     517
     518            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    525519            sage: W = nb.create_new_worksheet('test1', 'admin')
    526520            sage: C = W.collaborators(); C
    527521            []
    class Worksheet(object): 
    534528        except AttributeError:
    535529            self.__collaborators = []
    536530            return self.__collaborators
    537        
     531
    538532    def collaborator_names(self, max=None):
    539533        """
    540534        Returns a string of the non-owner collaborators on this worksheet.
    541        
     535
    542536        INPUT:
    543        
    544        
     537
    545538        -  ``max`` - an integer. If this is specified, then
    546539           only max number of collaborators are shown.
    547        
    548        
     540
    549541        EXAMPLES::
    550        
    551             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     542
     543            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    552544            sage: W = nb.create_new_worksheet('test1', 'admin')
    553545            sage: C = W.collaborators(); C
    554546            []
    class Worksheet(object): 
    568560        """
    569561        Set the list of collaborators to those listed in the list v of
    570562        strings.
    571        
     563
    572564        INPUT:
    573        
    574        
     565
    575566        -  ``v`` - a list of strings
    576        
    577        
     567
    578568        EXAMPLES::
    579        
    580             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     569
     570            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    581571            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    582572            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    583573            sage: W = nb.create_new_worksheet('test1', 'admin')
    584574            sage: W.set_collaborators(['sage', 'admin', 'hilbert', 'sage'])
    585        
     575
    586576        Note that repeats are not added multiple times and admin - the
    587577        owner - isn't added::
    588        
     578
    589579            sage: W.collaborators()
    590580            ['hilbert', 'sage']
    591581        """
    class Worksheet(object): 
    608598    def viewers(self):
    609599        """
    610600        Return list of viewers of this worksheet.
    611        
     601
    612602        OUTPUT:
    613        
    614        
     603
    615604        -  ``list`` - of string
    616        
    617        
     605
    618606        EXAMPLES::
    619        
    620             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     607
     608            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    621609            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    622610            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    623611            sage: W = nb.create_new_worksheet('test1', 'admin')
    class Worksheet(object): 
    637625    def viewer_names(self, max=None):
    638626        """
    639627        Returns a string of the non-owner viewers on this worksheet.
    640        
     628
    641629        INPUT:
    642        
    643        
     630
    644631        -  ``max`` - an integer. If this is specified, then
    645632           only max number of viewers are shown.
    646        
    647        
     633
    648634        EXAMPLES::
    649        
    650             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     635
     636            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    651637            sage: W = nb.create_new_worksheet('test1', 'admin')
    652638            sage: C = W.viewers(); C
    653639            []
    class Worksheet(object): 
    668654        Delete data from this worksheet this is specific to a certain
    669655        notebook. This means deleting the attached files, collaborators,
    670656        and viewers.
    671        
     657
    672658        EXAMPLES::
    673        
    674             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     659
     660            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    675661            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    676662            sage: W = nb.create_new_worksheet('test1', 'admin')
    677663            sage: W.add_viewer('hilbert')
    class Worksheet(object): 
    688674        self.__attached = {}
    689675        self.__collaborators = [self.owner()]
    690676        self.__viewers = []
    691    
     677
    692678    def name(self):
    693679        """
    694680        Return the name of this worksheet.
    695        
     681
    696682        OUTPUT: string
    697        
     683
    698684        EXAMPLES::
    699        
    700             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     685
     686            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    701687            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    702688            sage: W.name()
    703689            'A Test Worksheet'
    class Worksheet(object): 
    711697    def set_name(self, name):
    712698        """
    713699        Set the name of this worksheet.
    714        
     700
    715701        INPUT:
    716        
    717        
     702
    718703        -  ``name`` - string
    719        
    720        
     704
    721705        EXAMPLES: We create a worksheet and change the name::
    722        
    723             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     706
     707            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    724708            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    725709            sage: W.set_name('A renamed worksheet')
    726710            sage: W.name()
    class Worksheet(object): 
    734718        r"""
    735719        Set this worksheet filename (actually directory) by getting the
    736720        owner from the pre-stored owner via ``self.owner()``.
    737        
     721
    738722        INPUT:
    739        
    740        
     723
    741724        -  ``nm`` - string
    742        
    743        
     725
    744726        EXAMPLES::
    745        
    746             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     727
     728            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    747729            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    748730            sage: W.filename()
    749731            'admin/0'
    class Worksheet(object): 
    757739    def set_filename(self, filename):
    758740        """
    759741        Set the worksheet filename (actually directory).
    760        
     742
    761743        INPUT:
    762        
    763        
     744
    764745        -  ``filename`` - string
    765        
    766        
     746
    767747        EXAMPLES::
    768        
    769             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     748
     749            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    770750            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    771751            sage: W.filename()
    772752            'admin/0'
    class Worksheet(object): 
    776756        """
    777757        old_filename = self.__filename
    778758        self.__filename = filename
    779         self.__dir = os.path.join(self.notebook().worksheet_directory(), filename)
     759        self.__dir = os.path.join(self.notebook()._dir, filename)
    780760        self.notebook().change_worksheet_key(old_filename, filename)
    781761
    782762    def filename(self):
    783763        """
    784764        Return the filename (really directory) where the files associated
    785765        to this worksheet are stored.
    786        
     766
    787767        EXAMPLES::
    788        
    789             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     768
     769            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    790770            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    791771            sage: W.filename()
    792772            'admin/0'
    793             sage: sorted(os.listdir(nb.directory() + '/worksheets/' + W.filename()))
    794             ['cells', 'snapshots']
     773            sage: os.path.isdir(os.path.join(nb._dir, 'home', W.filename()))
     774            True
    795775        """
    796776        return self.__filename
    797777
    class Worksheet(object): 
    799779        """
    800780        Return the part of the worksheet filename after the last /, i.e.,
    801781        without any information about the owner of this worksheet.
    802        
     782
    803783        EXAMPLES::
    804        
    805             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     784
     785            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    806786            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    807787            sage: W.filename_without_owner()
    808788            '0'
    class Worksheet(object): 
    815795        """
    816796        Return the full path to the directory where this worksheet is
    817797        stored.
    818        
     798
    819799        OUTPUT: string
    820        
     800
    821801        EXAMPLES::
    822        
    823             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     802
     803            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    824804            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    825805            sage: W.directory()
    826             '.../worksheets/admin/0'
     806            '.../home/admin/0'
    827807        """
    828808        return self.__dir
    829809
    830810    def data_directory(self):
    831811        """
    832812        Return path to directory where worksheet data is stored.
    833        
     813
    834814        OUTPUT: string
    835        
     815
    836816        EXAMPLES::
    837        
    838             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     817
     818            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    839819            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    840820            sage: W.data_directory()
    841             '.../worksheets/admin/0/data'
     821            '.../home/admin/0/data'
    842822        """
    843823        d = os.path.join(self.directory(), 'data')
    844824        if not os.path.exists(d):
    class Worksheet(object): 
    849829        """
    850830        Return a list of the file names of files in the worksheet data
    851831        directory.
    852        
     832
    853833        OUTPUT: list of strings
    854        
     834
    855835        EXAMPLES::
    856        
    857             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     836
     837            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    858838            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    859839            sage: W.attached_data_files()
    860840            []
    class Worksheet(object): 
    871851        """
    872852        Return the directory in which the cells of this worksheet are
    873853        evaluated.
    874        
     854
    875855        OUTPUT: string
    876        
     856
    877857        EXAMPLES::
    878        
    879             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     858
     859            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    880860            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    881861            sage: W.cells_directory()
    882             '.../worksheets/admin/0/cells'
     862            '.../home/admin/0/cells'
    883863        """
    884864        path = os.path.join(self.directory(), 'cells')
    885865        if not os.path.exists(path):
    class Worksheet(object): 
    889869    def notebook(self):
    890870        """
    891871        Return the notebook that contains this worksheet.
    892        
     872
    893873        OUTPUT: a Notebook object.
    894        
     874
    895875        EXAMPLES: This really returns the Notebook object that is set as a
    896         global variable of the twist module.
    897        
    898         ::
    899        
    900             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     876        global variable of the twist module.::
     877
     878            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    901879            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    902880            sage: W.notebook()
    903881            <...sagenb.notebook.notebook.Notebook...>
    class Worksheet(object): 
    914892        """
    915893        Return the math software system in which by default all input to
    916894        the notebook is evaluated.
    917        
     895
    918896        OUTPUT: string
    919        
     897
    920898        EXAMPLES::
    921        
    922             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     899
     900            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    923901            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    924902            sage: W.system()
    925903            'sage'
    class Worksheet(object): 
    942920        Sage installed to running a server from the same directory
    943921        without Sage installed.   We might as well support this.
    944922
    945         OUTPUT:
    946 
    947             - integer
     923        OUTPUT: integer
    948924        """
    949925        S = self.system()
    950926        names = self.notebook().system_names()
    class Worksheet(object): 
    959935        """
    960936        Set the math software system in which input is evaluated by
    961937        default.
    962        
     938
    963939        INPUT:
    964        
    965        
     940
    966941        -  ``system`` - string (default: 'sage')
    967        
    968        
     942
    969943        EXAMPLES::
    970        
    971             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     944
     945            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    972946            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    973947            sage: W.set_system('magma')
    974948            sage: W.system()
    class Worksheet(object): 
    979953    def pretty_print(self):
    980954        """
    981955        Return True if output should be pretty printed by default.
    982        
     956
    983957        OUTPUT:
    984        
    985        
     958
    986959        -  ``bool`` - True of False
    987        
    988        
     960
    989961        EXAMPLES::
    990        
    991             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     962
     963            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    992964            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    993965            sage: W.pretty_print()
    994966            False
    995967            sage: W.set_pretty_print('true')
    996968            sage: W.pretty_print()
    997969            True
     970            sage: W.quit()
     971            sage: nb.delete()
    998972        """
    999973        try:
    1000974            return self.__pretty_print
    class Worksheet(object): 
    1005979    def set_pretty_print(self, check='false'):
    1006980        """
    1007981        Set whether or not output should be pretty printed by default.
    1008        
     982
    1009983        INPUT:
    1010        
    1011        
     984
    1012985        -  ``check`` - string (default: 'false'); either 'true'
    1013986           or 'false'.
    1014        
    1015        
     987
    1016988        .. note::
    1017989
    1018990           The reason the input is a string and lower case instead of
    class Worksheet(object): 
    1020992           JavaScript. (And, Jason Grout wrote this and didn't realize
    1021993           how unpythonic this design is - it should be redone to use
    1022994           True/False.)
    1023        
     995
    1024996        EXAMPLES::
    1025        
    1026             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     997
     998            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    1027999            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    10281000            sage: W.set_pretty_print('false')
    10291001            sage: W.pretty_print()
    class Worksheet(object): 
    10311003            sage: W.set_pretty_print('true')
    10321004            sage: W.pretty_print()
    10331005            True
     1006            sage: W.quit()
     1007            sage: nb.delete()
    10341008        """
    10351009        if check == 'false':
    10361010            check=False
    class Worksheet(object): 
    10381012            check=True
    10391013        self.__pretty_print = check
    10401014        self.eval_asap_no_output("pretty_print_default(%r)"%(check))
    1041        
     1015
    10421016    ##########################################################
    10431017    # Publication
    10441018    ##########################################################
    10451019    def is_auto_publish(self):
    10461020        """
    1047         Returns True if this worksheet should be automatically published. 
     1021        Returns True if this worksheet should be automatically published.
    10481022        """
    1049         try: 
     1023        try:
    10501024            return self.__autopublish
    10511025        except AttributeError:
    10521026            self.__autopublish = False
    10531027            return False
    1054    
     1028
    10551029    def set_auto_publish(self, x):
    10561030        self.__autopublish = x
    1057    
     1031
    10581032    def is_published(self):
    10591033        """
    10601034        Return True if this worksheet is a published worksheet.
    1061        
     1035
    10621036        OUTPUT:
    1063        
    1064        
     1037
    10651038        -  ``bool`` - whether or not owner is 'pub'
    1066        
    1067        
     1039
    10681040        EXAMPLES::
    1069        
    1070             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1041
     1042            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10711043            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    10721044            sage: W.is_published()
    10731045            False
    class Worksheet(object): 
    10821054        Return owner and id_number of the worksheet that was published
    10831055        to get this worksheet, if this worksheet was
    10841056        published. Otherwise just return this worksheet.
    1085        
     1057
    10861058        OUTPUT: Worksheet
    1087        
     1059
    10881060        EXAMPLES::
    1089        
    1090             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1061
     1062            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    10911063            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    10921064            sage: W.worksheet_that_was_published() is W
    10931065            True
    1094        
    1095         ::
    1096        
    10971066            sage: S = nb.publish_worksheet(W, 'admin')
    10981067            sage: S.worksheet_that_was_published() is S
    10991068            False
    class Worksheet(object): 
    11041073            return self.notebook().get_worksheet_with_filename('%s/%s'%self.__worksheet_came_from)
    11051074        except Exception:  # things can go wrong (especially with old migrated
    11061075                           # Sage notebook servers!), but we don't want such
    1107                            # problems to crash the notebook server. 
     1076                           # problems to crash the notebook server.
    11081077            return self
    11091078
    11101079    def publisher(self):
    11111080        """
    11121081        Return username of user that published this worksheet.
    1113        
     1082
    11141083        OUTPUT: string
    1115        
     1084
    11161085        EXAMPLES::
    1117        
    1118             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1086
     1087            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11191088            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11201089            sage: S = nb.publish_worksheet(W, 'admin')
    11211090            sage: S.publisher()
    class Worksheet(object): 
    11271096        """
    11281097        Return True if username is the username of the publisher of this
    11291098        worksheet, assuming this worksheet was published.
    1130        
     1099
    11311100        INPUT:
    1132        
    1133        
     1101
    11341102        -  ``username`` - string
    1135        
    1136        
     1103
    11371104        EXAMPLES::
    1138        
    1139             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1105
     1106            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    11401107            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11411108            sage: P = nb.publish_worksheet(W, 'admin')
    11421109            sage: P.is_publisher('hearst')
    class Worksheet(object): 
    11491116    def has_published_version(self):
    11501117        """
    11511118        Return True if there is a published version of this worksheet.
    1152        
     1119
    11531120        OUTPUT: bool
    1154        
     1121
    11551122        EXAMPLES::
    1156        
    1157             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1123
     1124            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11581125            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11591126            sage: P = nb.publish_worksheet(W, 'admin')
    11601127            sage: P.has_published_version()
    class Worksheet(object): 
    11721139        """
    11731140        Set the published version of this worksheet to be the worksheet
    11741141        with given filename.
    1175        
     1142
    11761143        INPUT:
    1177        
    1178        
     1144
    11791145        -  ``filename`` - string
    1180        
    1181        
     1146
    11821147        EXAMPLES::
    1183        
    1184             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1148
     1149            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11851150            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11861151            sage: P = nb.publish_worksheet(W, 'admin')  # indirect test
    11871152            sage: W._Worksheet__published_version
     1153            'pub/1'
     1154            sage: W.set_published_version('pub/0')
     1155            sage: W._Worksheet__published_version
    11881156            'pub/0'
    1189             sage: W.set_published_version('pub/0')
    11901157        """
    11911158        self.__published_version = filename
    11921159
    class Worksheet(object): 
    11941161        """
    11951162        If this worksheet was published, return the published version of
    11961163        this worksheet. Otherwise, raise a ValueError.
    1197        
     1164
    11981165        OUTPUT: a worksheet (or raise a ValueError)
    1199        
     1166
    12001167        EXAMPLES::
    1201        
    1202             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1168
     1169            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12031170            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12041171            sage: P = nb.publish_worksheet(W, 'admin')
    12051172            sage: W.published_version() is P
    12061173            True
    1207         """       
     1174        """
    12081175        try:
    12091176            filename =self.__published_version
    12101177            try:
    class Worksheet(object): 
    12151182                raise ValueError
    12161183        except AttributeError:
    12171184            raise ValueError, "no published version"
    1218                              
     1185
    12191186    def set_worksheet_that_was_published(self, W):
    12201187        """
    12211188        Set the owner and id_number of the worksheet that was
    12221189        published to get self.
    1223        
     1190
    12241191        INPUT:
    12251192
    12261193            - ``W`` -- worksheet or 2-tuple ('owner', id_number)
    12271194
    1228        
    12291195        EXAMPLES::
    1230        
    1231             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1196
     1197            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12321198            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12331199            sage: P = nb.publish_worksheet(W, 'admin')
    12341200            sage: P.worksheet_that_was_published() is W
    12351201            True
    1236        
     1202
    12371203        We fake things and make it look like P published itself::
    1238        
     1204
    12391205            sage: P.set_worksheet_that_was_published(P)
    12401206            sage: P.worksheet_that_was_published() is P
    12411207            True
    class Worksheet(object): 
    12491215        """
    12501216        Set the rating on this worksheet by the given user to x and also
    12511217        set the given comment.
    1252        
     1218
    12531219        INPUT:
    1254        
    1255        
     1220
    12561221        -  ``x`` - integer
    1257        
     1222
    12581223        -  ``comment`` - string
    1259        
     1224
    12601225        -  ``username`` - string
    1261        
    1262        
     1226
    12631227        EXAMPLES: We create a worksheet and rate it, then look at the
    1264         ratings.
    1265        
    1266         ::
    1267        
    1268             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1228        ratings.::
     1229
     1230            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    12691231            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12701232            sage: W.rate(3, 'this is great', 'hilbert')
    12711233            sage: W.ratings()
    12721234            [('hilbert', 3, 'this is great')]
    1273        
     1235
    12741236        Note that only the last rating by a user counts::
    1275        
     1237
    12761238            sage: W.rate(1, 'this lacks content', 'riemann')
    12771239            sage: W.rate(0, 'this lacks content', 'riemann')
    12781240            sage: W.ratings()
    class Worksheet(object): 
    12901252        """
    12911253        Return True is the user with given username has rated this
    12921254        worksheet.
    1293        
     1255
    12941256        INPUT:
    1295        
    1296        
     1257
    12971258        -  ``username`` - string
    1298        
    1299        
     1259
    13001260        OUTPUT: bool
    1301        
     1261
    13021262        EXAMPLES::
    1303        
    1304             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1263
     1264            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13051265            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13061266            sage: W.rate(0, 'this lacks content', 'riemann')
    13071267            sage: W.is_rater('admin')
    class Worksheet(object): 
    13171277    def ratings(self):
    13181278        """
    13191279        Return all the ratings of this worksheet.
    1320        
     1280
    13211281        OUTPUT:
    1322        
    1323        
     1282
    13241283        -  ``list`` - a reference to the list of ratings.
    1325        
    1326        
     1284
    13271285        EXAMPLES::
    1328        
    1329             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1286
     1287            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13301288            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13311289            sage: W.ratings()
    13321290            []
    class Worksheet(object): 
    13461304        r"""
    13471305        Return html that renders to give a summary of how this worksheet
    13481306        has been rated.
    1349        
     1307
    13501308        OUTPUT:
    1351        
    1352        
    1353         -  ``string`` -- a string of HTML as a bunch of table
    1354            rows.
    1355        
    1356        
     1309
     1310        - ``string`` -- a string of HTML as a bunch of table rows.
     1311
    13571312        EXAMPLES::
    1358        
    1359             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1313
     1314            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13601315            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13611316            sage: W.rate(0, 'this lacks content', 'riemann')
    13621317            sage: W.rate(3, 'this is great', 'hilbert')
    class Worksheet(object): 
    13781333    def rating(self):
    13791334        """
    13801335        Return overall average rating of self.
    1381        
     1336
    13821337        OUTPUT: float or the int -1 to mean "not rated"
    1383        
     1338
    13841339        EXAMPLES::
    1385        
    1386             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1340
     1341            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13871342            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13881343            sage: W.rating()
    13891344            -1
    class Worksheet(object): 
    13981353        else:
    13991354            rating = float(sum(r))/float(len(r))
    14001355        return rating
    1401        
     1356
    14021357    ##########################################################
    14031358    # Active, trash can and archive
    14041359    ##########################################################
    class Worksheet(object): 
    14061361        """
    14071362        Return True if all users have deleted this worksheet, so we know we
    14081363        can safely purge it from disk.
    1409        
     1364
    14101365        OUTPUT: bool
    1411        
     1366
    14121367        EXAMPLES::
    1413        
    1414             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1368
     1369            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14151370            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    14161371            sage: W.everyone_has_deleted_this_worksheet()
    14171372            False
    class Worksheet(object): 
    14191374            sage: W.everyone_has_deleted_this_worksheet()
    14201375            True
    14211376        """
    1422         for user in self.__collaborators + [self.owner()]:
     1377        for user in self.collaborators() + [self.owner()]:
    14231378            # When the worksheet has been deleted by the owner,
    14241379            # self.owner() returns None, so we have to be careful
    14251380            # about that case.
    14261381            if user is not None and not self.is_trashed(user):
    14271382                return False
    14281383        return True
    1429        
     1384
    14301385    def user_view(self, user):
    14311386        """
    14321387        Return the view that the given user has of this worksheet. If the
    14331388        user currently doesn't have a view set it to ACTIVE and return
    14341389        ACTIVE.
    1435        
     1390
    14361391        INPUT:
    1437        
    1438        
     1392
    14391393        -  ``user`` - a string
    1440        
    1441        
     1394
    14421395        OUTPUT:
    1443        
    1444        
     1396
    14451397        -  ``Python int`` - one of ACTIVE, ARCHIVED, TRASH,
    14461398           which are defined in worksheet.py
    1447        
    1448        
     1399
    14491400        EXAMPLES: We create a new worksheet and get the view, which is
    14501401        ACTIVE::
    1451        
    1452             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1402
     1403            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14531404            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    14541405            sage: W.user_view('admin')
    14551406            1
    14561407            sage: sagenb.notebook.worksheet.ACTIVE
    14571408            1
    1458        
     1409
    14591410        Now for the admin user we move W to the archive::
    1460        
     1411
    14611412            sage: W.move_to_archive('admin')
    1462        
    1463         The view is now archive.
    1464        
    1465         ::
    1466        
     1413
     1414        The view is now archive.::
     1415
    14671416            sage: W.user_view('admin')
    14681417            0
    14691418            sage: sagenb.notebook.worksheet.ARCHIVED
    14701419            0
    1471        
    1472         For any other random viewer the view is set by default to ACTIVE.
    1473        
    1474         ::
    1475        
     1420
     1421        For any other random viewer the view is set by default to ACTIVE.::
     1422
    14761423            sage: W.user_view('foo')
    14771424            1
    14781425        """
    class Worksheet(object): 
    14951442            self.user_view(self.owner())
    14961443            d = self.__user_view
    14971444        for user, val in d.iteritems():
    1498             d[user] = [val]
     1445            if not isinstance(val, list):
     1446                d[user] = [val]
    14991447        return d
    15001448
    15011449    def set_tags(self, tags):
    15021450        """
    1503         Set the tags -- for now we ignore everything except ACTIVE, ARCHIVED, TRASH.
     1451        Set the tags -- for now we ignore everything except ACTIVE,
     1452        ARCHIVED, TRASH.
    15041453
    15051454        INPUT:
    15061455
    class Worksheet(object): 
    15171466    def set_user_view(self, user, x):
    15181467        """
    15191468        Set the view on this worksheet for the given user.
    1520        
     1469
    15211470        INPUT:
    1522        
    1523        
     1471
    15241472        -  ``user`` - a string
    1525        
     1473
    15261474        -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
    15271475           TRASH in worksheet.py
    1528        
    1529        
     1476
    15301477        EXAMPLES::
    1531        
    1532             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1478
     1479            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15331480            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    15341481            sage: W.set_user_view('admin', sagenb.notebook.worksheet.ARCHIVED)
    15351482            sage: W.user_view('admin') == sagenb.notebook.worksheet.ARCHIVED
    class Worksheet(object): 
    15511498    def user_view_is(self, user, x):
    15521499        """
    15531500        Return True if the user view of user is x.
    1554        
     1501
    15551502        INPUT:
    1556        
    1557        
     1503
    15581504        -  ``user`` - a string
    1559        
     1505
    15601506        -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
    15611507           TRASH in worksheet.py
    1562        
    1563        
     1508
    15641509        EXAMPLES::
    1565        
    1566             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1510
     1511            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15671512            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    15681513            sage: W.user_view_is('admin', sagenb.notebook.worksheet.ARCHIVED)
    15691514            False
    class Worksheet(object): 
    15711516            True
    15721517        """
    15731518        return self.user_view(user) == x
    1574                
     1519
    15751520    def is_archived(self, user):
    15761521        """
    15771522        Return True if this worksheet is archived for the given user.
    1578        
     1523
    15791524        INPUT:
    1580        
    1581        
     1525
    15821526        -  ``user`` - string
    1583        
    1584        
     1527
    15851528        OUTPUT: bool
    1586        
     1529
    15871530        EXAMPLES::
    1588        
    1589             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1531
     1532            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15901533            sage: W = nb.create_new_worksheet('Archived Test', 'admin')
    15911534            sage: W.is_archived('admin')
    15921535            False
    class Worksheet(object): 
    15991542    def is_active(self, user):
    16001543        """
    16011544        Return True if this worksheet is active for the given user.
    1602        
     1545
    16031546        INPUT:
    1604        
    1605        
     1547
    16061548        -  ``user`` - string
    1607        
    1608        
     1549
    16091550        OUTPUT: bool
    1610        
     1551
    16111552        EXAMPLES::
    1612        
    1613             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1553
     1554            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16141555            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    16151556            sage: W.is_active('admin')
    16161557            True
    class Worksheet(object): 
    16231564    def is_trashed(self, user):
    16241565        """
    16251566        Return True if this worksheet is in the trash for the given user.
    1626        
     1567
    16271568        INPUT:
    1628        
    1629        
     1569
    16301570        -  ``user`` - string
    1631        
    1632        
     1571
    16331572        OUTPUT: bool
    1634        
     1573
    16351574        EXAMPLES::
    1636        
    1637             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1575
     1576            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16381577            sage: W = nb.create_new_worksheet('Trash Test', 'admin')
    16391578            sage: W.is_trashed('admin')
    16401579            False
    class Worksheet(object): 
    16471586    def move_to_archive(self, user):
    16481587        """
    16491588        Move this worksheet to be archived for the given user.
    1650        
     1589
    16511590        INPUT:
    1652        
    1653        
     1591
    16541592        -  ``user`` - string
    1655        
    1656        
     1593
    16571594        EXAMPLES::
    1658        
    1659             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1595
     1596            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16601597            sage: W = nb.create_new_worksheet('Archive Test', 'admin')
    16611598            sage: W.move_to_archive('admin')
    16621599            sage: W.is_archived('admin')
    class Worksheet(object): 
    16671604    def set_active(self, user):
    16681605        """
    16691606        Set his worksheet to be active for the given user.
    1670        
     1607
    16711608        INPUT:
    1672        
    1673        
     1609
    16741610        -  ``user`` - string
    1675        
    1676        
     1611
    16771612        EXAMPLES::
    1678        
    1679             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1613
     1614            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16801615            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    16811616            sage: W.move_to_archive('admin')
    16821617            sage: W.is_active('admin')
    class Worksheet(object): 
    16901625    def move_to_trash(self, user):
    16911626        """
    16921627        Move this worksheet to the trash for the given user.
    1693        
     1628
    16941629        INPUT:
    1695        
    1696        
     1630
    16971631        -  ``user`` - string
    1698        
    1699        
     1632
    17001633        EXAMPLES::
    1701        
    1702             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1634
     1635            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17031636            sage: W = nb.create_new_worksheet('Trash Test', 'admin')
    17041637            sage: W.move_to_trash('admin')
    17051638            sage: W.is_trashed('admin')
    class Worksheet(object): 
    17101643    def move_out_of_trash(self, user):
    17111644        """
    17121645        Exactly the same as set_active(user).
    1713        
     1646
    17141647        INPUT:
    1715        
    1716        
     1648
    17171649        -  ``user`` - string
    1718        
    1719        
     1650
    17201651        EXAMPLES::
    1721        
    1722             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1652
     1653            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17231654            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    17241655            sage: W.move_to_trash('admin')
    17251656            sage: W.is_active('admin')
    class Worksheet(object): 
    17291660            True
    17301661        """
    17311662        self.set_active(user)
    1732        
     1663
    17331664    #############
    17341665
    17351666    def delete_cells_directory(self):
    17361667        r"""
    17371668        Delete the directory in which all the cell computations occur.
    1738        
     1669
    17391670        EXAMPLES::
    1740        
    1741             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1671
     1672            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17421673            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17431674            sage: W = nb.create_new_worksheet('Test', 'sage')
    1744             sage: W.edit_save('Sage\n{{{\n3^20\n}}}')
     1675            sage: W.edit_save('{{{\n3^20\n}}}')
     1676            sage: W.cell_list()[0].evaluate()
     1677            sage: W.check_comp()    # random output -- depends on computer speed
    17451678            sage: sorted(os.listdir(W.directory()))
    1746             ['cells', 'snapshots']
    1747             sage: W.cell_list()[0].evaluate()
     1679            ['cells', 'data']
     1680            sage: W.save_snapshot('admin')
    17481681            sage: sorted(os.listdir(W.directory()))
    1749             ['cells', 'data', 'snapshots']
     1682            ['cells', 'data', 'snapshots', 'worksheet.html']
    17501683            sage: W.delete_cells_directory()
    17511684            sage: sorted(os.listdir(W.directory()))
    1752             ['data', 'snapshots']
     1685            ['data', 'snapshots', 'worksheet.html']
     1686            sage: W.quit()
     1687            sage: nb.delete()
    17531688        """
    17541689        dir = self.cells_directory()
    17551690        if os.path.exists(dir):
    class Worksheet(object): 
    17721707
    17731708    def set_owner(self, owner):
    17741709        self.__owner = owner
    1775         if not owner in self.__collaborators:
     1710        if not owner in self.collaborators():
    17761711            self.__collaborators.append(owner)
    17771712
    17781713    def user_is_only_viewer(self, user):
    class Worksheet(object): 
    17881723            return True
    17891724
    17901725    def user_is_collaborator(self, user):
    1791         try:
    1792             return user in self.__collaborators
    1793         except AttributeError:
    1794             return True
     1726        return user in self.collaborators()
    17951727
    17961728    def user_can_edit(self, user):
    17971729        """
    17981730        Return True if the user with given name is allowed to edit this
    17991731        worksheet.
    1800        
     1732
    18011733        INPUT:
    1802        
    1803        
     1734
    18041735        -  ``user`` - string
    1805        
    1806        
     1736
    18071737        OUTPUT: bool
    1808        
    1809         EXAMPLES: We create a notebook with one worksheet and two users.
    1810        
    1811         ::
    1812        
    1813             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1738
     1739        EXAMPLES: We create a notebook with one worksheet and two users.::
     1740
     1741            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    18141742            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    18151743            sage: nb.add_user('william', 'william', 'wstein@sagemath.org', force=True)
    18161744            sage: W = nb.create_new_worksheet('Test', 'sage')
    18171745            sage: W.user_can_edit('sage')
    18181746            True
    1819        
     1747
    18201748        At first the user 'william' can't edit this worksheet::
    1821        
     1749
    18221750            sage: W.user_can_edit('william')
    18231751            False
    1824        
     1752
    18251753        After adding 'william' as a collaborator he can edit the
    1826         worksheet.
    1827        
    1828         ::
    1829        
     1754        worksheet.::
     1755
    18301756            sage: W.add_collaborator('william')
    18311757            sage: W.user_can_edit('william')
    18321758            True
    1833        
     1759
    18341760        Clean up::
    1835        
     1761
    18361762            sage: nb.delete()
    18371763        """
    18381764        return self.user_is_collaborator(user) or self.is_owner(user)
    1839        
     1765
    18401766    def delete_user(self, user):
    18411767        """
    18421768        Delete a user from having any view or ownership of this worksheet.
    1843        
     1769
    18441770        INPUT:
    1845        
    1846        
     1771
    18471772        -  ``user`` - string; the name of a user
    1848        
    1849        
     1773
    18501774        EXAMPLES: We create a notebook with 2 users and 1 worksheet that
    1851         both view.
    1852