Ticket #7650: trac_7650-sagenb_doctesting.patch

File trac_7650-sagenb_doctesting.patch, 223.1 KB (added by mpatel, 13 years ago)

Add --force_lib option to sage-doctest. Use os.path.join. scripts repo.

  • sagenb/notebook/all.py

    # HG changeset patch
    # User Mitesh Patel <qed777@gmail.com>
    # Date 1260444087 28800
    # Node ID 1e2d24b52979aa1095554204ab376a8ab8046f09
    # Parent  c020f13934265ebd80b2f68742efec9d2c9c61e3
    #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: nb.delete()
    505496        """
    506497        # Cells are never considered evaluated in a new session.
    507498        if not self.worksheet().compute_process_has_been_started():
    class Cell(Cell_generic): 
    519510                return False
    520511            return self.__evaluated
    521512        except AttributeError:
    522             # Default assumption is that cell has not been evaluated. 
     513            # Default assumption is that cell has not been evaluated.
    523514            self.__evaluated = False
    524515            return False
    525516
    class Cell(Cell_generic): 
    527518        """
    528519        Sets whether or not this is an no_output cell, i.e., a cell for
    529520        which we don't care at all about the output.
    530        
     521
    531522        EXAMPLES::
    532        
     523
    533524            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    534525            sage: C.is_no_output()
    535526            False
    class Cell(Cell_generic): 
    543534        """
    544535        Return True if this is an no_output cell, i.e., a cell for which
    545536        we don't care at all about the output.
    546        
     537
    547538        EXAMPLES::
    548        
     539
    549540            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    550541            sage: C.is_no_output()
    551542            False
    class Cell(Cell_generic): 
    562553    def set_cell_output_type(self, typ='wrap'):
    563554        """
    564555        Sets the cell output type.
    565        
     556
    566557        EXAMPLES::
    567        
     558
    568559            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    569560            sage: C.cell_output_type()
    570561            'wrap'
    class Cell(Cell_generic): 
    577568    def cell_output_type(self):
    578569        """
    579570        Returns the cell output type.
    580        
     571
    581572        EXAMPLES::
    582        
     573
    583574            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    584575            sage: C.cell_output_type()
    585576            'wrap'
    class Cell(Cell_generic): 
    597588        """
    598589        Sets the worksheet object of self to be worksheet and optionally
    599590        changes the id of self.
    600        
     591
    601592        EXAMPLES::
    602        
     593
    603594            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    604595            sage: W = "worksheet object"
    605596            sage: C.set_worksheet(W)
    class Cell(Cell_generic): 
    616607    def worksheet(self):
    617608        """
    618609        Returns the worksheet object associated to self.
    619        
     610
    620611        EXAMPLES::
    621        
     612
    622613            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', 'worksheet object')
    623614            sage: C.worksheet()
    624615            'worksheet object'
    class Cell(Cell_generic): 
    629620        """
    630621        Update the list of files with html-style links or embeddings for
    631622        this cell.
    632        
     623
    633624        For interactive cells the html output section is always empty,
    634625        mainly because there is no good way to distinguish content (e.g.,
    635626        images in the current directory) that goes into the interactive
    class Cell(Cell_generic): 
    637628
    638629        EXAMPLES::
    639630
    640             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     631            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    641632            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    642633            sage: W = nb.create_new_worksheet('Test', 'sage')
    643634            sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
    644635            sage: C.evaluate()
    645             sage: W.check_comp(wait=9999)
     636            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    646637            ('d', Cell 0; in=plot(sin(x),0,5), out=
    647638            <html><font color='black'><img src='cell://sage0.png'></font></html>
    648639            <BLANKLINE>
    649640            )
    650641            sage: C.update_html_output()
    651             sage: C.output_html()
     642            sage: C.output_html()     # random output -- depends on computer speed
    652643            '<img src="/home/sage/0/cells/0/sage0.png?...">'
    653644        """
    654645        if self.is_interactive_cell():
    class Cell(Cell_generic): 
    659650    def id(self):
    660651        """
    661652        Returns the id of self.
    662        
     653
    663654        EXAMPLES::
    664        
     655
    665656            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    666657            sage: C.id()
    667658            0
    class Cell(Cell_generic): 
    671662    def set_id(self, id):
    672663        """
    673664        Sets the id of self to id.
    674        
     665
    675666        EXAMPLES::
    676        
     667
    677668            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    678669            sage: C.set_id(2)
    679670            sage: C.id()
    class Cell(Cell_generic): 
    684675    def worksheet(self):
    685676        """
    686677        Returns the workseet associated to self.
    687        
     678
    688679        EXAMPLES::
    689        
    690             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     680
     681            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    691682            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    692683            sage: W = nb.create_new_worksheet('Test', 'sage')
    693684            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    694685            sage: C.worksheet() is W
    695686            True
    696        
    697         ::
    698        
    699             sage: import shutil; shutil.rmtree(nb.directory())
     687            sage: nb.delete()
    700688        """
    701689        return self.__worksheet
    702690
    703691    def worksheet_filename(self):
    704692        """
    705693        Returns the filename of the worksheet associated to self.
    706        
     694
    707695        EXAMPLES::
    708        
    709             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     696
     697            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    710698            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    711699            sage: W = nb.create_new_worksheet('Test', 'sage')
    712700            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    713701            sage: C.worksheet_filename()
    714702            'sage/0'
    715        
    716         ::
    717        
    718             sage: import shutil; shutil.rmtree(nb.directory())
     703            sage: nb.delete()
    719704        """
    720705        return self.__worksheet.filename()
    721706
    class Cell(Cell_generic): 
    723708    def notebook(self):
    724709        """
    725710        Returns the notebook object associated to self.
    726        
     711
    727712        EXAMPLES::
    728        
    729             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     713
     714            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    730715            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    731716            sage: W = nb.create_new_worksheet('Test', 'sage')
    732717            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    733718            sage: C.notebook() is nb
    734719            True
    735        
    736         ::
    737        
    738             sage: import shutil; shutil.rmtree(nb.directory())
     720            sage: nb.delete()
    739721        """
    740722        return self.__worksheet.notebook()
    741723
    class Cell(Cell_generic): 
    743725        """
    744726        Returns the directory associated to self. If the directory doesn't
    745727        already exist, then this method creates it.
    746        
     728
    747729        EXAMPLES::
    748        
    749             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     730
     731            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    750732            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    751733            sage: W = nb.create_new_worksheet('Test', 'sage')
    752734            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    753735            sage: C.directory()
    754             '.../worksheets/sage/0/cells/0'
    755        
    756         ::
    757        
    758             sage: import shutil; shutil.rmtree(nb.directory())
     736            '.../home/sage/0/cells/0'
     737            sage: nb.delete()
    759738        """
    760739        dir = self._directory_name()
    761740        if not os.path.exists(dir):
    class Cell(Cell_generic): 
    766745    def _directory_name(self):
    767746        """
    768747        Returns a string of the directory associated to self.
    769        
     748
    770749        EXAMPLES::
    771        
    772             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     750
     751            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    773752            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    774753            sage: W = nb.create_new_worksheet('Test', 'sage')
    775754            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    776755            sage: C._directory_name()
    777             '.../worksheets/sage/0/cells/0'
    778        
    779         ::
    780        
    781             sage: import shutil; shutil.rmtree(nb.directory())
     756            '.../home/sage/0/cells/0'
     757            sage: nb.delete()
    782758        """
    783759        return os.path.join(self.__worksheet.directory(), 'cells', str(self.id()))
    784760
    class Cell(Cell_generic): 
    786762    def __cmp__(self, right):
    787763        """
    788764        Compares cells by their IDs.
    789        
     765
    790766        EXAMPLES::
    791        
     767
    792768            sage: C1 = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    793769            sage: C2 = sagenb.notebook.cell.Cell(0, '3+2', '5', None)
    794770            sage: C3 = sagenb.notebook.cell.Cell(1, '2+3', '5', None)
    class Cell(Cell_generic): 
    804780    def __repr__(self):
    805781        """
    806782        Returns a string representation of self.
    807        
     783
    808784        EXAMPLES::
    809        
     785
    810786            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None); C
    811787            Cell 0; in=2+3, out=5
    812788        """
    class Cell(Cell_generic): 
    816792        """
    817793        Returns the number of columns for word wrapping. This defaults to
    818794        70, but the default setting for a notebook is 72.
    819        
     795
    820796        EXAMPLES::
    821        
     797
    822798            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    823799            sage: C.word_wrap_cols()
    824800            70
    825        
    826         ::
    827        
    828             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     801            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    829802            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    830803            sage: W = nb.create_new_worksheet('Test', 'sage')
    831804            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    832805            sage: C.word_wrap_cols()
    833806            72
    834        
    835         ::
    836        
    837             sage: import shutil; shutil.rmtree(nb.directory())
     807            sage: nb.delete()
    838808        """
    839809        try:
    840810            return self.notebook().conf()['word_wrap_cols']
    841811        except AttributeError:
    842812            return 70
    843        
     813
    844814    def plain_text(self, ncols=0, prompts=True, max_out=None):
    845815        r"""
    846816        Returns the plain text version of self.
    class Cell(Cell_generic): 
    857827
    858828        input_lines = self.__in
    859829        pr = 'sage: '
    860            
     830
    861831        if prompts:
    862832            input_lines = input_lines.splitlines()
    863833            has_prompt = False
    class Cell(Cell_generic): 
    911881        if not max_out is None and len(out) > max_out:
    912882            out = out[:max_out] + '...'
    913883
    914         # Get rid of spurious carriage returns 
     884        # Get rid of spurious carriage returns
    915885        s = s.strip('\n')
    916886        out = out.strip('\n').strip('\r').strip('\r\n')
    917887        s = s + '\n' + out
    class Cell(Cell_generic): 
    919889        if not prompts:
    920890            s = s.rstrip('\n')
    921891        return s
    922    
     892
    923893    def edit_text(self, ncols=0, prompts=False, max_out=None):
    924894        r"""
    925895        Returns the text displayed in the Edit window.
    926        
     896
    927897        EXAMPLES::
    928        
     898
    929899            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    930900            sage: C.edit_text()
    931901            '{{{id=0|\n2+3\n///\n5\n}}}'
    class Cell(Cell_generic): 
    936906    def is_last(self):
    937907        """
    938908        Returns True if self is the last cell in the worksheet.
    939        
     909
    940910        EXAMPLES::
    941        
    942             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     911
     912            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    943913            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    944914            sage: W = nb.create_new_worksheet('Test', 'sage')
    945915            sage: C = W.new_cell_after(0, "2^2"); C
    946             Cell 1; in=2^2, out=
     916            Cell 2; in=2^2, out=
    947917            sage: C.is_last()
    948918            True
    949919            sage: C = W.get_cell_with_id(0)
    950920            sage: C.is_last()
    951921            False
    952        
    953         ::
    954        
    955             sage: import shutil; shutil.rmtree(nb.directory())
     922            sage: nb.delete()
    956923        """
    957924        return self.__worksheet.cell_list()[-1] == self
    958925
    class Cell(Cell_generic): 
    961928        Returns the id of the next cell in the worksheet associated to
    962929        self. If self is not in the worksheet or self is the last cell in
    963930        the cell_list, then the id of the first cell is returned.
    964        
     931
    965932        EXAMPLES::
    966        
    967             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     933
     934            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    968935            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    969936            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)
     937            sage: C = W.new_cell_after(1, "2^2")
     938            sage: C = W.get_cell_with_id(1)
     939            sage: C.next_id()
     940            2
     941            sage: C = W.get_cell_with_id(2)
    972942            sage: C.next_id()
    973943            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())
     944            sage: nb.delete()
    981945        """
    982946        L = self.__worksheet.cell_list()
    983947        try:
    class Cell(Cell_generic): 
    993957    def interrupt(self):
    994958        """
    995959        Record that the calculation running in this cell was interrupted.
    996        
     960
    997961        EXAMPLES::
    998        
    999             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     962
     963            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    1000964            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    1001965            sage: W = nb.create_new_worksheet('Test', 'sage')
    1002966            sage: C = W.new_cell_after(0, "2^2")
    class Cell(Cell_generic): 
    1005969            True
    1006970            sage: C.evaluated()
    1007971            False
    1008        
    1009         ::
    1010        
    1011             sage: import shutil; shutil.rmtree(nb.directory())
     972            sage: nb.delete()
    1012973        """
    1013974        self.__interrupted = True
    1014975        self.__evaluated = False
    class Cell(Cell_generic): 
    1016977    def interrupted(self):
    1017978        """
    1018979        Returns True if the evaluation of this cell has been interrupted.
    1019        
     980
    1020981        EXAMPLES::
    1021        
    1022             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     982
     983            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    1023984            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    1024985            sage: W = nb.create_new_worksheet('Test', 'sage')
    1025986            sage: C = W.new_cell_after(0, "2^2")
    1026987            sage: C.interrupt()
    1027988            sage: C.interrupted()
    1028989            True
    1029        
    1030         ::
    1031        
    1032             sage: import shutil; shutil.rmtree(nb.directory())
     990            sage: nb.delete()
    1033991        """
    1034992        return self.__interrupted
    1035993
    1036994    def computing(self):
    1037995        """
    1038996        Returns True if self is in its worksheet's queue.
    1039        
     997
    1040998        EXAMPLES::
    1041        
    1042             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     999
     1000            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10431001            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    10441002            sage: W = nb.create_new_worksheet('Test', 'sage')
    10451003            sage: C = W.new_cell_after(0, "2^2")
    10461004            sage: C.computing()
    10471005            False
    1048        
    1049         ::
    1050        
    1051             sage: import shutil; shutil.rmtree(nb.directory())
     1006            sage: nb.delete()
    10521007        """
    10531008        return self in self.__worksheet.queue()
    10541009
    class Cell(Cell_generic): 
    10561011        r"""
    10571012        Return True if this cell contains the use of interact either as a
    10581013        function call or a decorator.
    1059        
     1014
    10601015        EXAMPLES::
    1061        
    1062             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1016
     1017            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10631018            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    10641019            sage: W = nb.create_new_worksheet('Test', 'sage')
    10651020            sage: C = W.new_cell_after(0, "@interact\ndef f(a=slider(0,10,1,5):\n    print a^2")
    class Cell(Cell_generic): 
    10681023            sage: C = W.new_cell_after(C.id(), "2+2")
    10691024            sage: C.is_interactive_cell()
    10701025            False
    1071        
    1072         ::
    1073        
    1074             sage: import shutil; shutil.rmtree(nb.directory())
     1026            sage: nb.delete()
    10751027        """
    10761028        # Do *not* cache
    10771029        s = strip_string_literals(self.input_text())
    class Cell(Cell_generic): 
    10821034    def is_interacting(self):
    10831035        r"""
    10841036        Returns True if this cell is currently interacting with the user.
    1085        
     1037
    10861038        EXAMPLES::
    1087        
    1088             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1039
     1040            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10891041            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    10901042            sage: W = nb.create_new_worksheet('Test', 'sage')
    10911043            sage: C = W.new_cell_after(0, "@interact\ndef f(a=slider(0,10,1,5):\n    print a^2")
    class Cell(Cell_generic): 
    10981050        """
    10991051        Stops interaction with user.
    11001052
    1101         TODO: Add doctests for :meth:`stop_interacting`.           
     1053        TODO: Add doctests for :meth:`stop_interacting`.
    11021054        """
    11031055        if self.is_interacting():
    11041056            del self.interact
    class Cell(Cell_generic): 
    11061058    def set_input_text(self, input):
    11071059        """
    11081060        Sets the input text of self to be the string input.
    1109        
     1061
    11101062        TODO: Add doctests for the code dealing with interact.
    1111        
     1063
    11121064        EXAMPLES::
    1113        
    1114             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1065
     1066            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11151067            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    11161068            sage: W = nb.create_new_worksheet('Test', 'sage')
    11171069            sage: C = W.new_cell_after(0, "2^2")
    11181070            sage: C.evaluate()
    1119             sage: W.check_comp(wait=9999)
     1071            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    11201072            ('d', Cell 1; in=2^2, out=
    11211073            4
    11221074            )
    11231075            sage: C.version()
    11241076            0
    1125        
    1126         ::
    1127        
    11281077            sage: C.set_input_text('3+3')
    11291078            sage: C.input_text()
    11301079            '3+3'
    class Cell(Cell_generic): 
    11321081            False
    11331082            sage: C.version()
    11341083            1
    1135        
    1136         ::
    1137        
    1138             sage: import shutil; shutil.rmtree(nb.directory())
     1084            sage: nb.delete()
    11391085        """
    11401086        # Stuff to deal with interact
    11411087        if input.startswith('%__sage_interact__'):
    class Cell(Cell_generic): 
    11491095            except AttributeError:
    11501096                pass
    11511097
    1152         # We have updated the input text so the cell can't have 
    1153         # been evaluated. 
     1098        # We have updated the input text so the cell can't have
     1099        # been evaluated.
    11541100        self.__evaluated = False
    11551101        self.__version = self.version() + 1
    11561102        self.__in = input
    class Cell(Cell_generic): 
    11601106        #Run get the input text with all of the percent
    11611107        #directives parsed
    11621108        self._cleaned_input = self.parse_percent_directives()
    1163        
     1109
    11641110    def input_text(self):
    11651111        """
    11661112        Returns self's input text.
    1167        
     1113
    11681114        EXAMPLES::
    1169        
     1115
    11701116            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    11711117            sage: C.input_text()
    11721118            '2+3'
    class Cell(Cell_generic): 
    11801126        text is returned.
    11811127
    11821128        EXAMPLES::
    1183        
     1129
    11841130            sage: C = sagenb.notebook.cell.Cell(0, '%hide\n%maxima\n2+3', '5', None)
    11851131            sage: C.cleaned_input_text()
    11861132            '2+3'
    1187 
    11881133        """
    11891134        if self.is_interacting():
    11901135            return self.interact
    class Cell(Cell_generic): 
    11971142        with the percent directives at the top removed.  As it's doing
    11981143        this, it computes a list of all the directives and which
    11991144        system (if any) the cell should be run under.
    1200        
     1145
    12011146        EXAMPLES::
    1202        
     1147
    12031148            sage: C = sagenb.notebook.cell.Cell(0, '%hide\n%maxima\n2+3', '5', None)
    12041149            sage: C.parse_percent_directives()
    12051150            '2+3'
    12061151            sage: C.percent_directives()
    12071152            ['hide', 'maxima']
    1208        
    12091153        """
    12101154        self._system = None
    12111155        text = self.input_text().splitlines()
    class Cell(Cell_generic): 
    12251169                pass
    12261170            else:
    12271171                self._system = line[1:]
    1228                
     1172
    12291173            directives.append(line[1:])
    1230            
     1174
    12311175        self._percent_directives = directives
    12321176        return "\n".join(text[i:]).strip()
    1233            
     1177
    12341178    def percent_directives(self):
    12351179        r"""
    12361180        Returns a list of all the percent directives that appear
    12371181        in this cell.
    12381182
    12391183        EXAMPLES::
    1240        
     1184
    12411185            sage: C = sagenb.notebook.cell.Cell(0, '%hide\n%maxima\n2+3', '5', None)
    12421186            sage: C.percent_directives()
    12431187            ['hide', 'maxima']
    1244        
    12451188        """
    12461189        return self._percent_directives
    12471190
    class Cell(Cell_generic): 
    12561199        worksheet's default system.
    12571200
    12581201        EXAMPLES::
    1259        
     1202
    12601203            sage: C = sagenb.notebook.cell.Cell(0, '%maxima\n2+3', '5', None)
    12611204            sage: C.system()
    12621205            'maxima'
    class Cell(Cell_generic): 
    12711214    def is_auto_cell(self):
    12721215        r"""
    12731216        Returns True if self is an auto cell.
    1274        
     1217
    12751218        An auto cell is a cell that is automatically evaluated when the
    12761219        worksheet starts up.
    1277        
     1220
    12781221        EXAMPLES::
    1279        
     1222
    12801223            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    12811224            sage: C.is_auto_cell()
    12821225            False
    class Cell(Cell_generic): 
    12911234        Returns the changed input text for the cell. If there was any
    12921235        changed input text, then it is reset to " before this method
    12931236        returns.
    1294        
     1237
    12951238        EXAMPLES::
    1296        
     1239
    12971240            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    12981241            sage: C.changed_input_text()
    12991242            ''
    class Cell(Cell_generic): 
    13181261        """
    13191262        Note that this does not update the version of the cell. This is
    13201263        typically used for things like tab completion.
    1321        
     1264
    13221265        EXAMPLES::
    1323        
     1266
    13241267            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    13251268            sage: C.set_changed_input_text('3+3')
    13261269            sage: C.input_text()
    class Cell(Cell_generic): 
    13361279        Sets the output text for self.
    13371280
    13381281        EXAMPLES::
    1339        
     1282
    13401283            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    13411284            sage: len(C.plain_text())
    13421285            11
    class Cell(Cell_generic): 
    13491292            output = ''
    13501293
    13511294        # In interacting mode, we just save the computed output
    1352         # (do not overwrite). 
     1295        # (do not overwrite).
    13531296        if self.is_interacting():
    13541297            self._interact_output = (output, html)
    13551298            return
    1356        
     1299
    13571300        if hasattr(self, '_html_cache'):
    13581301            del self._html_cache
    13591302
    class Cell(Cell_generic): 
    13861329    def sage(self):
    13871330        """
    13881331        TODO: Figure out what exactly this does.
    1389        
     1332
    13901333        EXAMPLES::
    1391        
     1334
    13921335            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    13931336            sage: C.sage() is None
    13941337            True
    class Cell(Cell_generic): 
    14031346        Returns the HTML for self's output.
    14041347
    14051348        EXAMPLES::
    1406        
     1349
    14071350            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    14081351            sage: C.output_html()
    14091352            ''
    class Cell(Cell_generic): 
    14161359        except AttributeError:
    14171360            self.__out_html = ''
    14181361            return ''
    1419    
     1362
    14201363    def process_cell_urls(self, urls):
    14211364        """
    14221365        Processes URLs of the form ``'cell://.*?'`` by replacing the
    class Cell(Cell_generic): 
    14281371        - ``urls`` - a string
    14291372
    14301373        EXAMPLES::
    1431        
    1432             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1374
     1375            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14331376            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    14341377            sage: W = nb.create_new_worksheet('Test', 'sage')
    14351378            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    14491392        INPUT:
    14501393
    14511394        - ``ncols`` -- maximum number of columns
    1452            
     1395
    14531396        - ``html`` -- boolean stating whether to output HTML
    1454            
     1397
    14551398        - ``raw`` -- boolean stating whether to output raw text
    14561399          (takes precedence over HTML)
    14571400
    class Cell(Cell_generic): 
    14591402
    14601403        EXAMPLES::
    14611404
    1462             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1405            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14631406            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    14641407            sage: W = nb.create_new_worksheet('Test', 'sage')
    14651408            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    15011444                return '<h2>Click to the left again to hide and once more to show the dynamic interactive window</h2>'
    15021445        else:
    15031446            s = self.__out
    1504        
     1447
    15051448        if raw:
    15061449            return s
    15071450
    class Cell(Cell_generic): 
    15101453
    15111454        if not is_interact and not self.is_html() and len(s.strip()) > 0:
    15121455            s = '<pre class="shrunk">' + s.strip('\n') + '</pre>'
    1513            
     1456
    15141457        return s.strip('\n')
    15151458
    15161459    def parse_html(self, s, ncols):
    class Cell(Cell_generic): 
    15181461        Parse HTML for output.
    15191462
    15201463        INPUT:
    1521        
     1464
    15221465        - ``s`` -- the input string containing HTML
    1523            
     1466
    15241467        - ``ncols`` -- maximum number of columns
    1525            
     1468
    15261469        EXAMPLES::
    1527        
    1528             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1470
     1471            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15291472            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    15301473            sage: W = nb.create_new_worksheet('Test', 'sage')
    15311474            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    15691512                j = t[i:].lower().find('</script>')
    15701513                if j == -1: break
    15711514                t = t[:i] + t[i+j+len('</script>'):]
    1572                
     1515
    15731516        return t
    1574        
     1517
    15751518
    15761519    def has_output(self):
    15771520        """
    15781521        Returns True if there is output for this cell.
    1579        
     1522
    15801523        EXAMPLES::
    1581        
     1524
    15821525            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    15831526            sage: C.has_output()
    15841527            True
    class Cell(Cell_generic): 
    15921535        r"""
    15931536        Returns True if this is an HTML cell. An HTML cell whose system is
    15941537        'html' and is typically specified by ``%html``.
    1595        
     1538
    15961539        EXAMPLES::
    1597        
     1540
    15981541            sage: C = sagenb.notebook.cell.Cell(0, "%html\nTest HTML", None, None)
    15991542            sage: C.system()
    16001543            'html'
    class Cell(Cell_generic): 
    16031546            sage: C = sagenb.notebook.cell.Cell(0, "Test HTML", None, None)
    16041547            sage: C.is_html()
    16051548            False
    1606 
    16071549        """
    16081550        try:
    16091551            return self.__is_html
    class Cell(Cell_generic): 
    16131555    def set_is_html(self, v):
    16141556        """
    16151557        Sets whether or not this cell is an HTML cell.
    1616        
     1558
    16171559        This is called by check_for_system_switching in worksheet.py.
    1618        
     1560
    16191561        EXAMPLES::
    1620        
     1562
    16211563            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    16221564            sage: C.is_html()
    16231565            False
    class Cell(Cell_generic): 
    16301572    #################
    16311573    # Introspection #
    16321574    #################
    1633     def set_introspect_html(self, html, completing=False, verbose=False, raw=False):
     1575    def set_introspect_html(self, html, completing=False, raw=False):
    16341576        """
    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 
    16411577        EXAMPLES::
    16421578
    1643             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1579            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16441580            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    16451581            sage: W = nb.create_new_worksheet('Test', 'sage')
    16461582            sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
    16471583            sage: C.introspect()
    16481584            False
    16491585            sage: C.evaluate(username='sage')
    1650             sage: W.check_comp(9999)
     1586            sage: W.check_comp(9999)     # random output -- depends on computer speed
    16511587            ('d', Cell 0; in=sage?, out=)
    16521588            sage: C.set_introspect_html('foobar')
    16531589            sage: C.introspect_html()
    1654             '<div class="docstring"><pre>foobar</pre></div>'
     1590            'foobar'
    16551591            sage: C.set_introspect_html('`foobar`')
    16561592            sage: C.introspect_html()
    1657             '<div class="docstring">...<span class="math">foobar</span>...</div>'
     1593            '`foobar`'
    16581594        """
    16591595        self.__introspect_html = html
    16601596        self.introspection_status = 'done'
    1661        
     1597
    16621598    def get_introspection_status(self):
    16631599        try:
    16641600            return self.__introspection_status
    class Cell(Cell_generic): 
    16691605        self.__introspection_status = value
    16701606
    16711607    introspection_status = property(get_introspection_status, set_introspection_status)
    1672        
    1673        
     1608
     1609
    16741610    def introspect_html(self):
    16751611        """
    16761612        Returns HTML for introspection.
    16771613
    16781614        EXAMPLES::
    1679        
    1680             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1615
     1616            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16811617            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    16821618            sage: W = nb.create_new_worksheet('Test', 'sage')
    16831619            sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
    16841620            sage: C.introspect()
    16851621            False
    16861622            sage: C.evaluate(username='sage')
    1687             sage: W.check_comp(9999)
     1623            sage: W.check_comp(9999)     # random output -- depends on computer speed
    16881624            ('d', Cell 0; in=sage?, out=)
    1689             sage: C.introspect_html()
    1690             u'<div class="docstring">...</pre></div>'
     1625            sage: C.introspect_html()     # random output -- depends on computer speed
     1626            u'...<div class="docstring">...sage...</pre></div>...'
    16911627        """
    16921628        if not self.introspect():
    16931629            return ''
    class Cell(Cell_generic): 
    17001636    def introspect(self):
    17011637        """
    17021638        Returns self's introspection text.
    1703        
     1639
    17041640        EXAMPLES::
    17051641
    1706             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1642            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17071643            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17081644            sage: W = nb.create_new_worksheet('Test', 'sage')
    17091645            sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
    17101646            sage: C.introspect()
    17111647            False
    17121648            sage: C.evaluate(username='sage')
    1713             sage: W.check_comp(9999)
     1649            sage: W.check_comp(9999)     # random output -- depends on computer speed
    17141650            ('d', Cell 0; in=sage?, out=)
    17151651            sage: C.introspect()
    17161652            ['sage?', '']
    class Cell(Cell_generic): 
    17231659    def unset_introspect(self):
    17241660        """
    17251661        Unsets self's introspection text.
    1726        
     1662
    17271663        EXAMPLES::
    17281664
    1729             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1665            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17301666            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17311667            sage: W = nb.create_new_worksheet('Test', 'sage')
    17321668            sage: C = sagenb.notebook.cell.Cell(0, 'sage?', '', W)
    17331669            sage: C.introspect()
    17341670            False
    17351671            sage: C.evaluate(username='sage')
    1736             sage: W.check_comp(9999)
     1672            sage: W.check_comp(9999)     # random output -- depends on computer speed
    17371673            ('d', Cell 0; in=sage?, out=)
    17381674            sage: C.introspect()
    17391675            ['sage?', '']
    class Cell(Cell_generic): 
    17461682    def set_introspect(self, before_prompt, after_prompt):
    17471683        """
    17481684        Set self's introspection text.
    1749        
     1685
    17501686        EXAMPLES::
    1751        
     1687
    17521688            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    17531689            sage: C.set_introspect("a", "b")
    17541690            sage: C.introspect()
    class Cell(Cell_generic): 
    17591695    def evaluate(self, introspect=False, time=None, username=None):
    17601696        r"""
    17611697        INPUT:
    1762        
    1763        
     1698
    17641699        -  ``username`` - name of user doing the evaluation
    1765        
     1700
    17661701        -  ``time`` - if True return time computation takes
    1767        
     1702
    17681703        -  ``introspect`` - either False or a pair
    17691704           [before_cursor, after_cursor] of strings.
    1770        
    1771        
     1705
    17721706        EXAMPLES:
    17731707
    17741708        We create a notebook, worksheet, and cell and evaluate it
    17751709        in order to compute `3^5`::
    1776        
    1777             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1710
     1711            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17781712            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17791713            sage: W = nb.create_new_worksheet('Test', 'sage')
    1780             sage: W.edit_save('Sage\n{{{\n3^5\n}}}')
     1714            sage: W.edit_save('{{{\n3^5\n}}}')
    17811715            sage: C = W.cell_list()[0]; C
    17821716            Cell 0; in=3^5, out=
    17831717            sage: C.evaluate(username='sage')
    1784             sage: W.check_comp(wait=9999)
     1718            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    17851719            ('d', Cell 0; in=3^5, out=
    17861720            243
    17871721            )
    1788             sage: C
     1722            sage: C     # random output -- depends on computer speed
    17891723            Cell 0; in=3^5, out=
    1790             243       
    1791        
    1792         ::
    1793        
    1794             sage: import shutil; shutil.rmtree(nb.directory())
     1724            243
     1725            sage: nb.delete()
    17951726        """
    17961727        self.__interrupted = False
    17971728        self.__evaluated = True
    class Cell(Cell_generic): 
    18101741                    shutil.rmtree(F)
    18111742                except:
    18121743                    pass
    1813                
     1744
    18141745    def version(self):
    18151746        """
    18161747        Returns the version number of this cell.
    1817        
     1748
    18181749        EXAMPLES::
    1819        
     1750
    18201751            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    18211752            sage: C.version()
    18221753            0
    class Cell(Cell_generic): 
    18341765        r"""
    18351766        Returns True if the time it takes to evaluate this cell should be
    18361767        printed.
    1837        
     1768
    18381769        EXAMPLES::
    1839        
     1770
    18401771            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    18411772            sage: C.time()
    18421773            False
    class Cell(Cell_generic): 
    18741805        if div_wrap:
    18751806            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>'
    18761807        return s
    1877    
     1808
    18781809    def html(self, wrap=None, div_wrap=True, do_print=False):
    18791810        r"""
    18801811        Returns the HTML for self.
    class Cell(Cell_generic): 
    18911822
    18921823        EXAMPLES::
    18931824
    1894             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1825            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    18951826            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    18961827            sage: W = nb.create_new_worksheet('Test', 'sage')
    18971828            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    19221853
    19231854        if div_wrap:
    19241855            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            
     1856
    19261857        #self._html_cache[key] = s
    19271858        return s
    19281859
    19291860    def html_in(self, do_print=False, ncols=80):
    19301861        """
    19311862        Returns the HTML code for the input of this cell.
    1932        
     1863
    19331864        EXAMPLES::
    1934        
     1865
    19351866            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', None)
    19361867            sage: print C.html_in()
    1937             <div class="insert_new_cell" id="insert_new_cell_0"...</a>
     1868            <div class="insert_new_cell" id="insert_new_cell_before0"...</a>
    19381869        """
    19391870        s = ''
    19401871        id = self.__id
    19411872        t = self.__in.rstrip()
    19421873
    19431874        cls = "cell_input_hide" if 'hide' in self.percent_directives() else "cell_input"
    1944    
     1875
    19451876        if not do_print:
    19461877            s += self.html_new_cell_before()
    19471878
    class Cell(Cell_generic): 
    19691900           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)
    19701901
    19711902        t = escape(t)+" "
    1972        
     1903
    19731904        return s
    19741905
    19751906
    class Cell(Cell_generic): 
    19781909        Returns a notebook URL for this cell.
    19791910
    19801911        EXAMPLES::
    1981        
    1982             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1912
     1913            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    19831914            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    19841915            sage: W = nb.create_new_worksheet('Test', 'sage')
    19851916            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    19861917            sage: C.url_to_self()
    19871918            '/home/sage/0/cells/0'
    1988        
    19891919        """
    19901920        try:
    19911921            return self.__url_to_self
    class Cell(Cell_generic): 
    19961926    def files(self):
    19971927        """
    19981928        Returns a list of all the files in self's directory.
    1999        
     1929
    20001930        EXAMPLES::
    2001        
    2002             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1931
     1932            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    20031933            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    20041934            sage: W = nb.create_new_worksheet('Test', 'sage')
    20051935            sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
    20061936            sage: C.evaluate()
    2007             sage: W.check_comp(wait=9999)
     1937            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    20081938            ('d', Cell 0; in=plot(sin(x),0,5), out=
    20091939            <html><font color='black'><img src='cell://sage0.png'></font></html>
    20101940            <BLANKLINE>
    20111941            )
    2012             sage: C.files()
     1942            sage: C.files()     # random output -- depends on computer speed
    20131943            ['sage0.png']
    2014        
    2015         ::
    2016        
    2017             sage: import shutil; shutil.rmtree(nb.directory())
     1944            sage: nb.delete()
    20181945        """
    20191946        dir = self.directory()
    20201947        D = os.listdir(dir)
    class Cell(Cell_generic): 
    20231950    def delete_files(self):
    20241951        """
    20251952        Deletes all of the files associated with this cell.
    2026        
     1953
    20271954        EXAMPLES::
    2028        
    2029             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1955
     1956            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    20301957            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    20311958            sage: W = nb.create_new_worksheet('Test', 'sage')
    20321959            sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
    20331960            sage: C.evaluate()
    2034             sage: W.check_comp(wait=9999)
     1961            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    20351962            ('d', Cell 0; in=plot(sin(x),0,5), out=
    20361963            <html><font color='black'><img src='cell://sage0.png'></font></html>
    20371964            <BLANKLINE>
    20381965            )
    2039             sage: C.files()
     1966            sage: C.files()     # random output -- depends on computer speed
    20401967            ['sage0.png']
    20411968            sage: C.delete_files()
    20421969            sage: C.files()
    class Cell(Cell_generic): 
    20621989
    20631990        EXAMPLES::
    20641991
    2065             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1992            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    20661993            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    20671994            sage: W = nb.create_new_worksheet('Test', 'sage')
    20681995            sage: C = sagenb.notebook.cell.Cell(0, 'plot(sin(x),0,5)', '', W)
    20691996            sage: C.evaluate()
    2070             sage: W.check_comp(wait=9999)
     1997            sage: W.check_comp(wait=9999)     # random output -- depends on computer speed
    20711998            ('d', Cell 0; in=plot(sin(x),0,5), out=
    20721999            <html><font color='black'><img src='cell://sage0.png'></font></html>
    20732000            <BLANKLINE>
    20742001            )
    2075             sage: C.files_html('')
     2002            sage: C.files_html('')     # random output -- depends on computer speed
    20762003            '<img src="/home/sage/0/cells/0/sage0.png?...">'
    20772004        """
    20782005        import time
    class Cell(Cell_generic): 
    21112038                    jmol_file = open(jmol_name, 'r')
    21122039                    jmol_script = jmol_file.read()
    21132040                    jmol_file.close()
    2114                    
     2041
    21152042                    jmol_script = jmol_script.replace('defaultdirectory "', 'defaultdirectory "' + self.url_to_self() + '/')
    21162043
    21172044                    jmol_file = open(jmol_name, 'w')
    21182045                    jmol_file.write(jmol_script)
    21192046                    jmol_file.close()
    2120                    
     2047
    21212048                script = '<div><script>jmol_applet(%s, "%s?%d");</script></div>' % (size, url, time.time())
    21222049                images.append(script)
    21232050            elif F.endswith('.jmol.zip'):
    class Cell(Cell_generic): 
    21452072        Returns the HTML for self's output.
    21462073
    21472074        INPUT:
    2148        
     2075
    21492076        - ``do_print`` -- a boolean stating whether to output HTML
    21502077          for print
    21512078
    class Cell(Cell_generic): 
    21532080
    21542081        EXAMPLES::
    21552082
    2156             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     2083            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    21572084            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    21582085            sage: W = nb.create_new_worksheet('Test', 'sage')
    21592086            sage: C = sagenb.notebook.cell.Cell(0, '2+3', '5', W)
    class Cell(Cell_generic): 
    21622089        """
    21632090        if do_print and self.cell_output_type() == 'hidden':
    21642091            return '<pre>\n</pre>'
    2165        
     2092
    21662093        out_nowrap = self.output_text(0, html=True)
    21672094
    21682095        out_html = self.output_html()
    class Cell(Cell_generic): 
    21702097            out_wrap = out_nowrap
    21712098        else:
    21722099            out_wrap = self.output_text(ncols, html=True)
    2173            
     2100
    21742101        typ = self.cell_output_type()
    2175        
     2102
    21762103        if self.computing():
    21772104            cls = "cell_div_output_running"
    21782105        else:
    class Cell(Cell_generic): 
    21982125            out = out_wrap + out_html
    21992126        else:
    22002127            out = out_wrap + out_nowrap + out_html
    2201            
     2128
    22022129        s = top + out + '</div>'
    22032130
    22042131        r = ''
    class Cell(Cell_generic): 
    22152142                   r, s)
    22162143
    22172144        return tbl
    2218    
     2145
    22192146
    22202147
    22212148########
    class Cell(Cell_generic): 
    22232150def format_exception(s0, ncols):
    22242151    r"""
    22252152    Make it so exceptions don't appear expanded by default.
    2226    
     2153
    22272154    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    
     2155
     2156    - ``s0`` - string
     2157
     2158    - ``ncols`` - integer
     2159
     2160    OUTPUT:
     2161
     2162    - a string
     2163
     2164    If s0 contains "notracebacks" then this function always returns
     2165    s0.
     2166
    22392167    EXAMPLES::
    2240    
     2168
    22412169        sage: sagenb.notebook.cell.format_exception(sagenb.notebook.cell.TRACEBACK,80)
    22422170        '\nTraceback (click to the left of this block for traceback)\n...\nTraceback (most recent call last):'
    22432171        sage: sagenb.notebook.cell.format_exception(sagenb.notebook.cell.TRACEBACK + "notracebacks",80)
    22442172        'Traceback (most recent call last):notracebacks'
    22452173    """
    22462174    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.
     2175    # Add a notracebacks option -- if it is in the string then
     2176    # tracebacks aren't shrunk.  This is currently used by the
     2177    # sage.server.support.help command.
    22492178    if TRACEBACK not in s or 'notracebacks' in s:
    22502179        return s0
    22512180    if ncols > 0:
    def format_exception(s0, ncols): 
    22592188        s = s.replace("exec compile(ur'","")
    22602189        s = s.replace("' + '\\n', '', 'single')", "")
    22612190    return s
    2262    
     2191
    22632192ComputeCell=Cell
    22642193
    2265    
     2194
    22662195def number_of_rows(txt, ncols):
    22672196    r"""
    22682197    Returns the number of rows needed to display the string in txt if
    22692198    there are a maximum of ncols columns per row.
    2270    
     2199
    22712200    EXAMPLES::
    2272    
     2201
    22732202        sage: from sagenb.notebook.cell import number_of_rows
    22742203        sage: s = "asdfasdf\nasdfasdf\n"
    22752204        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::
    130128            sage: import sagenb.notebook.worksheet
    131             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
     129            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
    132130            sage: _=W.new_cell_after(0); B = W.basic()
    133             sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, '')
     131            sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, tmp_dir())
    134132            sage: W0.basic() == B
    135133            True
    136134    """
    class Worksheet(object): 
    146144                 auto_publish=False, create_directories=True):
    147145        """
    148146        Create and initialize a new worksheet.
    149        
     147
    150148        INPUT:
    151        
    152        
     149
    153150        -  ``name`` - string; the name of this worksheet
    154        
     151
    155152        - ``id_number`` - Integer; name of the directory in which the
    156153           worksheet's data is stored
    157        
     154
    158155        -  ``notebook_worksheet_directory`` - string; the
    159156           directory in which the notebook object that contains this worksheet
    160157           stores worksheets, i.e., nb.worksheet_directory().
    161        
     158
    162159        -  ``system`` - string; 'sage', 'gp', 'singular', etc.
    163160           - the math software system in which all code is evaluated by
    164161           default
    165        
     162
    166163        -  ``owner`` - string; username of the owner of this
    167164           worksheet
    168        
     165
    169166        -  ``docbrowser`` - bool (default: False); whether this
    170167           is a docbrowser worksheet
    171        
     168
    172169        -  ``pretty_print`` - bool (default: False); whether
    173170           all output is pretty printed by default.
    174171
    class Worksheet(object): 
    176173          creates various files and directories where data will be
    177174          stored.  This option is here only for the
    178175          migrate_old_notebook method in notebook.py
    179        
    180        
     176
    181177        EXAMPLES: We test the constructor via an indirect doctest::
    182        
    183             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     178
     179            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    184180            sage: W = nb.create_new_worksheet('Test', 'admin')
    185181            sage: W
    186             admin/0: [Cell 0; in=, out=]
     182            admin/0: [Cell 1; in=, out=]
    187183        """
    188184        if name is None:
    189185            # A fresh worksheet
    class Worksheet(object): 
    201197
    202198        # state sequence number, used for sync
    203199        self.__state_number = 0
    204        
     200
    205201        # Initialize the cell id counter.
    206202        self.__next_id = 0
    207203
    class Worksheet(object): 
    246242        EXAMPLES::
    247243
    248244            sage: from sagenb.notebook.worksheet import Worksheet
    249             sage: W = Worksheet('test', 2, '', owner='sageuser')
     245            sage: W = Worksheet('test', 2, tmp_dir(), owner='sageuser')
    250246            sage: W.id_number()
    251247            2
    252248            sage: type(W.id_number())
    class Worksheet(object): 
    264260        configuration of this worksheet, except the actual cells and
    265261        the data files in the DATA directory and images and other data
    266262        in the individual cell directories.
    267        
     263
    268264        EXAMPLES::
    269265
    270266            sage: import sagenb.notebook.worksheet
    271             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', owner='sage')
     267            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), owner='sage')
    272268            sage: sorted((W.basic().items()))
    273269            [('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)]
     270              ('collaborators', []),
     271              ('id_number', 0),
     272              ('last_change', ('sage', ...)),
     273              ('name', 'test'),
     274              ('owner', 'sage'),
     275              ('pretty_print', False),
     276              ('published_id_number', None),
     277              ('ratings', []),
     278              ('system', None),
     279              ('tags', {'sage': [1]}),
     280              ('viewers', []),
     281              ('worksheet_that_was_published', ('sage', 0))]
    286282        """
    287283        try:
    288284            published_id_number = int(os.path.split(self.__published_version)[1])
    class Worksheet(object): 
    293289            ws_pub = self.__worksheet_came_from
    294290        except AttributeError:
    295291            ws_pub = (self.owner(), self.id_number())
    296            
     292
    297293        d = {#############
    298294             # basic identification
    299295             'name':self.name(),
    class Worksheet(object): 
    320316             # worksheet.  Otherwise ws_pub is None.
    321317             'worksheet_that_was_published':ws_pub,
    322318             # Whether or not this worksheet should automatically be
    323              # republished when changed. 
     319             # republished when changed.
    324320             'auto_publish':self.is_auto_publish(),
    325321
    326322             # Appearance: e.g., whether to pretty print this
    class Worksheet(object): 
    361357              ``id_number`` is a key of obj; otherwise not.
    362358
    363359        EXAMPLES::
     360
    364361            sage: import sagenb.notebook.worksheet
    365             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
     362            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
    366363            sage: W.new_cell_after(0)
    367364            Cell 1; in=, out=
    368365            sage: b = W.basic()
    369366            sage: W0 = sagenb.notebook.worksheet.Worksheet()
    370             sage: W0.reconstruct_from_basic(b,'')
     367            sage: W0.reconstruct_from_basic(b, tmp_dir())
    371368            sage: W0.basic() == W.basic()
    372369            True
    373370        """
    class Worksheet(object): 
    403400    def __cmp__(self, other):
    404401        """
    405402        We compare two worksheets.
    406        
     403
    407404        INPUT:
    408        
    409        
     405
    410406        -  ``self, other`` - worksheets
    411        
    412        
     407
    413408        OUTPUT:
    414        
    415        
     409
    416410        -  ``-1,0,1`` - comparison is on the underlying
    417411           file names.
    418        
    419        
     412
    420413        EXAMPLES::
    421        
    422             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     414
     415            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    423416            sage: W2 = nb.create_new_worksheet('test2', 'admin')
    424417            sage: W1 = nb.create_new_worksheet('test1', 'admin')
    425418            sage: cmp(W1, W2)
    class Worksheet(object): 
    436429        r"""
    437430        Return string representation of this worksheet, which is simply the
    438431        string representation of the underlying list of cells.
    439        
     432
    440433        OUTPUT: string
    441        
     434
    442435        EXAMPLES::
    443        
    444             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     436
     437            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    445438            sage: W = nb.create_new_worksheet('test1', 'admin')
    446439            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}}}')
     440            'admin/0: [Cell 1; in=, out=]'
     441            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
    449442            sage: W.__repr__()
    450443            'admin/0: [Cell 0; in=2+3, out=\n5, Cell 10; in=2+8, out=\n10]'
    451444        """
    class Worksheet(object): 
    453446    def __len__(self):
    454447        r"""
    455448        Return the number of cells in this worksheet.
    456        
     449
    457450        OUTPUT: int
    458        
     451
    459452        EXAMPLES::
    460        
    461             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     453
     454            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    462455            sage: W = nb.create_new_worksheet('test1', 'admin')
    463456            sage: len(W)
    464457            1
    465             sage: W.edit_save('Sage\n{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
     458            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
    466459            sage: len(W)
    467460            2
    468461        """
    class Worksheet(object): 
    484477    def docbrowser(self):
    485478        """
    486479        Return True if this is a docbrowser worksheet.
    487        
     480
    488481        OUTPUT: bool
    489        
     482
    490483        EXAMPLES: We first create a standard worksheet for which docbrowser
    491484        is of course False::
    492        
    493             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     485
     486            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    494487            sage: W = nb.create_new_worksheet('test1', 'admin')
    495488            sage: W.docbrowser()
    496489            False
    497        
     490
    498491        We create a worksheet for which docbrowser is True::
    499        
     492
    500493            sage: W = nb.create_new_worksheet('docs', 'admin', docbrowser=True)
    501494            sage: W.docbrowser()
    502495            True
    class Worksheet(object): 
    516509        """
    517510        Return a (reference to the) list of the collaborators who can also
    518511        view and modify this worksheet.
    519        
     512
    520513        OUTPUT: list
    521        
     514
    522515        EXAMPLES::
    523        
    524             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     516
     517            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    525518            sage: W = nb.create_new_worksheet('test1', 'admin')
    526519            sage: C = W.collaborators(); C
    527520            []
    class Worksheet(object): 
    534527        except AttributeError:
    535528            self.__collaborators = []
    536529            return self.__collaborators
    537        
     530
    538531    def collaborator_names(self, max=None):
    539532        """
    540533        Returns a string of the non-owner collaborators on this worksheet.
    541        
     534
    542535        INPUT:
    543        
    544        
     536
    545537        -  ``max`` - an integer. If this is specified, then
    546538           only max number of collaborators are shown.
    547        
    548        
     539
    549540        EXAMPLES::
    550        
    551             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     541
     542            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    552543            sage: W = nb.create_new_worksheet('test1', 'admin')
    553544            sage: C = W.collaborators(); C
    554545            []
    class Worksheet(object): 
    568559        """
    569560        Set the list of collaborators to those listed in the list v of
    570561        strings.
    571        
     562
    572563        INPUT:
    573        
    574        
     564
    575565        -  ``v`` - a list of strings
    576        
    577        
     566
    578567        EXAMPLES::
    579        
    580             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     568
     569            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    581570            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    582571            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    583572            sage: W = nb.create_new_worksheet('test1', 'admin')
    584573            sage: W.set_collaborators(['sage', 'admin', 'hilbert', 'sage'])
    585        
     574
    586575        Note that repeats are not added multiple times and admin - the
    587576        owner - isn't added::
    588        
     577
    589578            sage: W.collaborators()
    590579            ['hilbert', 'sage']
    591580        """
    class Worksheet(object): 
    608597    def viewers(self):
    609598        """
    610599        Return list of viewers of this worksheet.
    611        
     600
    612601        OUTPUT:
    613        
    614        
     602
    615603        -  ``list`` - of string
    616        
    617        
     604
    618605        EXAMPLES::
    619        
    620             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     606
     607            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    621608            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    622609            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    623610            sage: W = nb.create_new_worksheet('test1', 'admin')
    class Worksheet(object): 
    637624    def viewer_names(self, max=None):
    638625        """
    639626        Returns a string of the non-owner viewers on this worksheet.
    640        
     627
    641628        INPUT:
    642        
    643        
     629
    644630        -  ``max`` - an integer. If this is specified, then
    645631           only max number of viewers are shown.
    646        
    647        
     632
    648633        EXAMPLES::
    649        
    650             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     634
     635            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    651636            sage: W = nb.create_new_worksheet('test1', 'admin')
    652637            sage: C = W.viewers(); C
    653638            []
    class Worksheet(object): 
    668653        Delete data from this worksheet this is specific to a certain
    669654        notebook. This means deleting the attached files, collaborators,
    670655        and viewers.
    671        
     656
    672657        EXAMPLES::
    673        
    674             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     658
     659            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    675660            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    676661            sage: W = nb.create_new_worksheet('test1', 'admin')
    677662            sage: W.add_viewer('hilbert')
    class Worksheet(object): 
    688673        self.__attached = {}
    689674        self.__collaborators = [self.owner()]
    690675        self.__viewers = []
    691    
     676
    692677    def name(self):
    693678        """
    694679        Return the name of this worksheet.
    695        
     680
    696681        OUTPUT: string
    697        
     682
    698683        EXAMPLES::
    699        
    700             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     684
     685            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    701686            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    702687            sage: W.name()
    703688            'A Test Worksheet'
    class Worksheet(object): 
    711696    def set_name(self, name):
    712697        """
    713698        Set the name of this worksheet.
    714        
     699
    715700        INPUT:
    716        
    717        
     701
    718702        -  ``name`` - string
    719        
    720        
     703
    721704        EXAMPLES: We create a worksheet and change the name::
    722        
    723             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     705
     706            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    724707            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    725708            sage: W.set_name('A renamed worksheet')
    726709            sage: W.name()
    class Worksheet(object): 
    734717        r"""
    735718        Set this worksheet filename (actually directory) by getting the
    736719        owner from the pre-stored owner via ``self.owner()``.
    737        
     720
    738721        INPUT:
    739        
    740        
     722
    741723        -  ``nm`` - string
    742        
    743        
     724
    744725        EXAMPLES::
    745        
    746             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     726
     727            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    747728            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    748729            sage: W.filename()
    749730            'admin/0'
    class Worksheet(object): 
    757738    def set_filename(self, filename):
    758739        """
    759740        Set the worksheet filename (actually directory).
    760        
     741
    761742        INPUT:
    762        
    763        
     743
    764744        -  ``filename`` - string
    765        
    766        
     745
    767746        EXAMPLES::
    768        
    769             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     747
     748            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    770749            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    771750            sage: W.filename()
    772751            'admin/0'
    class Worksheet(object): 
    776755        """
    777756        old_filename = self.__filename
    778757        self.__filename = filename
    779         self.__dir = os.path.join(self.notebook().worksheet_directory(), filename)
     758        self.__dir = os.path.join(self.notebook()._dir, filename)
    780759        self.notebook().change_worksheet_key(old_filename, filename)
    781760
    782761    def filename(self):
    783762        """
    784763        Return the filename (really directory) where the files associated
    785764        to this worksheet are stored.
    786        
     765
    787766        EXAMPLES::
    788        
    789             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     767
     768            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    790769            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    791770            sage: W.filename()
    792771            'admin/0'
    793             sage: sorted(os.listdir(nb.directory() + '/worksheets/' + W.filename()))
    794             ['cells', 'snapshots']
     772            sage: os.path.isdir(os.path.join(nb._dir, 'home', W.filename()))
     773            True
    795774        """
    796775        return self.__filename
    797776
    class Worksheet(object): 
    799778        """
    800779        Return the part of the worksheet filename after the last /, i.e.,
    801780        without any information about the owner of this worksheet.
    802        
     781
    803782        EXAMPLES::
    804        
    805             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     783
     784            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    806785            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    807786            sage: W.filename_without_owner()
    808787            '0'
    class Worksheet(object): 
    815794        """
    816795        Return the full path to the directory where this worksheet is
    817796        stored.
    818        
     797
    819798        OUTPUT: string
    820        
     799
    821800        EXAMPLES::
    822        
    823             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     801
     802            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    824803            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    825804            sage: W.directory()
    826             '.../worksheets/admin/0'
     805            '.../home/admin/0'
    827806        """
    828807        return self.__dir
    829808
    830809    def data_directory(self):
    831810        """
    832811        Return path to directory where worksheet data is stored.
    833        
     812
    834813        OUTPUT: string
    835        
     814
    836815        EXAMPLES::
    837        
    838             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     816
     817            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    839818            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    840819            sage: W.data_directory()
    841             '.../worksheets/admin/0/data'
     820            '.../home/admin/0/data'
    842821        """
    843822        d = os.path.join(self.directory(), 'data')
    844823        if not os.path.exists(d):
    class Worksheet(object): 
    849828        """
    850829        Return a list of the file names of files in the worksheet data
    851830        directory.
    852        
     831
    853832        OUTPUT: list of strings
    854        
     833
    855834        EXAMPLES::
    856        
    857             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     835
     836            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    858837            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    859838            sage: W.attached_data_files()
    860839            []
    class Worksheet(object): 
    871850        """
    872851        Return the directory in which the cells of this worksheet are
    873852        evaluated.
    874        
     853
    875854        OUTPUT: string
    876        
     855
    877856        EXAMPLES::
    878        
    879             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     857
     858            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    880859            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    881860            sage: W.cells_directory()
    882             '.../worksheets/admin/0/cells'
     861            '.../home/admin/0/cells'
    883862        """
    884863        path = os.path.join(self.directory(), 'cells')
    885864        if not os.path.exists(path):
    class Worksheet(object): 
    889868    def notebook(self):
    890869        """
    891870        Return the notebook that contains this worksheet.
    892        
     871
    893872        OUTPUT: a Notebook object.
    894        
     873
    895874        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())
     875        global variable of the twist module.::
     876
     877            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    901878            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    902879            sage: W.notebook()
    903880            <...sagenb.notebook.notebook.Notebook...>
    class Worksheet(object): 
    914891        """
    915892        Return the math software system in which by default all input to
    916893        the notebook is evaluated.
    917        
     894
    918895        OUTPUT: string
    919        
     896
    920897        EXAMPLES::
    921        
    922             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     898
     899            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    923900            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    924901            sage: W.system()
    925902            'sage'
    class Worksheet(object): 
    942919        Sage installed to running a server from the same directory
    943920        without Sage installed.   We might as well support this.
    944921
    945         OUTPUT:
    946 
    947             - integer
     922        OUTPUT: integer
    948923        """
    949924        S = self.system()
    950925        names = self.notebook().system_names()
    class Worksheet(object): 
    959934        """
    960935        Set the math software system in which input is evaluated by
    961936        default.
    962        
     937
    963938        INPUT:
    964        
    965        
     939
    966940        -  ``system`` - string (default: 'sage')
    967        
    968        
     941
    969942        EXAMPLES::
    970        
    971             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     943
     944            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    972945            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    973946            sage: W.set_system('magma')
    974947            sage: W.system()
    class Worksheet(object): 
    979952    def pretty_print(self):
    980953        """
    981954        Return True if output should be pretty printed by default.
    982        
     955
    983956        OUTPUT:
    984        
    985        
     957
    986958        -  ``bool`` - True of False
    987        
    988        
     959
    989960        EXAMPLES::
    990        
    991             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     961
     962            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    992963            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    993964            sage: W.pretty_print()
    994965            False
    class Worksheet(object): 
    1005976    def set_pretty_print(self, check='false'):
    1006977        """
    1007978        Set whether or not output should be pretty printed by default.
    1008        
     979
    1009980        INPUT:
    1010        
    1011        
     981
    1012982        -  ``check`` - string (default: 'false'); either 'true'
    1013983           or 'false'.
    1014        
    1015        
     984
    1016985        .. note::
    1017986
    1018987           The reason the input is a string and lower case instead of
    class Worksheet(object): 
    1020989           JavaScript. (And, Jason Grout wrote this and didn't realize
    1021990           how unpythonic this design is - it should be redone to use
    1022991           True/False.)
    1023        
     992
    1024993        EXAMPLES::
    1025        
    1026             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     994
     995            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    1027996            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    1028997            sage: W.set_pretty_print('false')
    1029998            sage: W.pretty_print()
    class Worksheet(object): 
    10381007            check=True
    10391008        self.__pretty_print = check
    10401009        self.eval_asap_no_output("pretty_print_default(%r)"%(check))
    1041        
     1010
    10421011    ##########################################################
    10431012    # Publication
    10441013    ##########################################################
    10451014    def is_auto_publish(self):
    10461015        """
    1047         Returns True if this worksheet should be automatically published. 
     1016        Returns True if this worksheet should be automatically published.
    10481017        """
    1049         try: 
     1018        try:
    10501019            return self.__autopublish
    10511020        except AttributeError:
    10521021            self.__autopublish = False
    10531022            return False
    1054    
     1023
    10551024    def set_auto_publish(self, x):
    10561025        self.__autopublish = x
    1057    
     1026
    10581027    def is_published(self):
    10591028        """
    10601029        Return True if this worksheet is a published worksheet.
    1061        
     1030
    10621031        OUTPUT:
    1063        
    1064        
     1032
    10651033        -  ``bool`` - whether or not owner is 'pub'
    1066        
    1067        
     1034
    10681035        EXAMPLES::
    1069        
    1070             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1036
     1037            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10711038            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    10721039            sage: W.is_published()
    10731040            False
    class Worksheet(object): 
    10821049        Return owner and id_number of the worksheet that was published
    10831050        to get this worksheet, if this worksheet was
    10841051        published. Otherwise just return this worksheet.
    1085        
     1052
    10861053        OUTPUT: Worksheet
    1087        
     1054
    10881055        EXAMPLES::
    1089        
    1090             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1056
     1057            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    10911058            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    10921059            sage: W.worksheet_that_was_published() is W
    10931060            True
    1094        
    1095         ::
    1096        
    10971061            sage: S = nb.publish_worksheet(W, 'admin')
    10981062            sage: S.worksheet_that_was_published() is S
    10991063            False
    class Worksheet(object): 
    11041068            return self.notebook().get_worksheet_with_filename('%s/%s'%self.__worksheet_came_from)
    11051069        except Exception:  # things can go wrong (especially with old migrated
    11061070                           # Sage notebook servers!), but we don't want such
    1107                            # problems to crash the notebook server. 
     1071                           # problems to crash the notebook server.
    11081072            return self
    11091073
    11101074    def publisher(self):
    11111075        """
    11121076        Return username of user that published this worksheet.
    1113        
     1077
    11141078        OUTPUT: string
    1115        
     1079
    11161080        EXAMPLES::
    1117        
    1118             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1081
     1082            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11191083            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11201084            sage: S = nb.publish_worksheet(W, 'admin')
    11211085            sage: S.publisher()
    class Worksheet(object): 
    11271091        """
    11281092        Return True if username is the username of the publisher of this
    11291093        worksheet, assuming this worksheet was published.
    1130        
     1094
    11311095        INPUT:
    1132        
    1133        
     1096
    11341097        -  ``username`` - string
    1135        
    1136        
     1098
    11371099        EXAMPLES::
    1138        
    1139             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1100
     1101            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11401102            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11411103            sage: P = nb.publish_worksheet(W, 'admin')
    11421104            sage: P.is_publisher('hearst')
    class Worksheet(object): 
    11491111    def has_published_version(self):
    11501112        """
    11511113        Return True if there is a published version of this worksheet.
    1152        
     1114
    11531115        OUTPUT: bool
    1154        
     1116
    11551117        EXAMPLES::
    1156        
    1157             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1118
     1119            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11581120            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11591121            sage: P = nb.publish_worksheet(W, 'admin')
    11601122            sage: P.has_published_version()
    class Worksheet(object): 
    11721134        """
    11731135        Set the published version of this worksheet to be the worksheet
    11741136        with given filename.
    1175        
     1137
    11761138        INPUT:
    1177        
    1178        
     1139
    11791140        -  ``filename`` - string
    1180        
    1181        
     1141
    11821142        EXAMPLES::
    1183        
    1184             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1143
     1144            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11851145            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11861146            sage: P = nb.publish_worksheet(W, 'admin')  # indirect test
    11871147            sage: W._Worksheet__published_version
     1148            'pub/1'
     1149            sage: W.set_published_version('pub/0')
     1150            sage: W._Worksheet__published_version
    11881151            'pub/0'
    1189             sage: W.set_published_version('pub/0')
    11901152        """
    11911153        self.__published_version = filename
    11921154
    class Worksheet(object): 
    11941156        """
    11951157        If this worksheet was published, return the published version of
    11961158        this worksheet. Otherwise, raise a ValueError.
    1197        
     1159
    11981160        OUTPUT: a worksheet (or raise a ValueError)
    1199        
     1161
    12001162        EXAMPLES::
    1201        
    1202             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1163
     1164            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12031165            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12041166            sage: P = nb.publish_worksheet(W, 'admin')
    12051167            sage: W.published_version() is P
    12061168            True
    1207         """       
     1169        """
    12081170        try:
    12091171            filename =self.__published_version
    12101172            try:
    class Worksheet(object): 
    12151177                raise ValueError
    12161178        except AttributeError:
    12171179            raise ValueError, "no published version"
    1218                              
     1180
    12191181    def set_worksheet_that_was_published(self, W):
    12201182        """
    12211183        Set the owner and id_number of the worksheet that was
    12221184        published to get self.
    1223        
     1185
    12241186        INPUT:
    12251187
    12261188            - ``W`` -- worksheet or 2-tuple ('owner', id_number)
    12271189
    1228        
    12291190        EXAMPLES::
    1230        
    1231             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1191
     1192            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12321193            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12331194            sage: P = nb.publish_worksheet(W, 'admin')
    12341195            sage: P.worksheet_that_was_published() is W
    12351196            True
    1236        
     1197
    12371198        We fake things and make it look like P published itself::
    1238        
     1199
    12391200            sage: P.set_worksheet_that_was_published(P)
    12401201            sage: P.worksheet_that_was_published() is P
    12411202            True
    class Worksheet(object): 
    12491210        """
    12501211        Set the rating on this worksheet by the given user to x and also
    12511212        set the given comment.
    1252        
     1213
    12531214        INPUT:
    1254        
    1255        
     1215
    12561216        -  ``x`` - integer
    1257        
     1217
    12581218        -  ``comment`` - string
    1259        
     1219
    12601220        -  ``username`` - string
    1261        
    1262        
     1221
    12631222        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())
     1223        ratings.::
     1224
     1225            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    12691226            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12701227            sage: W.rate(3, 'this is great', 'hilbert')
    12711228            sage: W.ratings()
    12721229            [('hilbert', 3, 'this is great')]
    1273        
     1230
    12741231        Note that only the last rating by a user counts::
    1275        
     1232
    12761233            sage: W.rate(1, 'this lacks content', 'riemann')
    12771234            sage: W.rate(0, 'this lacks content', 'riemann')
    12781235            sage: W.ratings()
    class Worksheet(object): 
    12901247        """
    12911248        Return True is the user with given username has rated this
    12921249        worksheet.
    1293        
     1250
    12941251        INPUT:
    1295        
    1296        
     1252
    12971253        -  ``username`` - string
    1298        
    1299        
     1254
    13001255        OUTPUT: bool
    1301        
     1256
    13021257        EXAMPLES::
    1303        
    1304             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1258
     1259            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13051260            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13061261            sage: W.rate(0, 'this lacks content', 'riemann')
    13071262            sage: W.is_rater('admin')
    class Worksheet(object): 
    13171272    def ratings(self):
    13181273        """
    13191274        Return all the ratings of this worksheet.
    1320        
     1275
    13211276        OUTPUT:
    1322        
    1323        
     1277
    13241278        -  ``list`` - a reference to the list of ratings.
    1325        
    1326        
     1279
    13271280        EXAMPLES::
    1328        
    1329             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1281
     1282            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13301283            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13311284            sage: W.ratings()
    13321285            []
    class Worksheet(object): 
    13461299        r"""
    13471300        Return html that renders to give a summary of how this worksheet
    13481301        has been rated.
    1349        
     1302
    13501303        OUTPUT:
    1351        
    1352        
    1353         -  ``string`` -- a string of HTML as a bunch of table
    1354            rows.
    1355        
    1356        
     1304
     1305        - ``string`` -- a string of HTML as a bunch of table rows.
     1306
    13571307        EXAMPLES::
    1358        
    1359             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1308
     1309            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13601310            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13611311            sage: W.rate(0, 'this lacks content', 'riemann')
    13621312            sage: W.rate(3, 'this is great', 'hilbert')
    class Worksheet(object): 
    13781328    def rating(self):
    13791329        """
    13801330        Return overall average rating of self.
    1381        
     1331
    13821332        OUTPUT: float or the int -1 to mean "not rated"
    1383        
     1333
    13841334        EXAMPLES::
    1385        
    1386             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1335
     1336            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13871337            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13881338            sage: W.rating()
    13891339            -1
    class Worksheet(object): 
    13981348        else:
    13991349            rating = float(sum(r))/float(len(r))
    14001350        return rating
    1401        
     1351
    14021352    ##########################################################
    14031353    # Active, trash can and archive
    14041354    ##########################################################
    class Worksheet(object): 
    14061356        """
    14071357        Return True if all users have deleted this worksheet, so we know we
    14081358        can safely purge it from disk.
    1409        
     1359
    14101360        OUTPUT: bool
    1411        
     1361
    14121362        EXAMPLES::
    1413        
    1414             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1363
     1364            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14151365            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    14161366            sage: W.everyone_has_deleted_this_worksheet()
    14171367            False
    class Worksheet(object): 
    14191369            sage: W.everyone_has_deleted_this_worksheet()
    14201370            True
    14211371        """
    1422         for user in self.__collaborators + [self.owner()]:
     1372        for user in self.collaborators() + [self.owner()]:
    14231373            # When the worksheet has been deleted by the owner,
    14241374            # self.owner() returns None, so we have to be careful
    14251375            # about that case.
    14261376            if user is not None and not self.is_trashed(user):
    14271377                return False
    14281378        return True
    1429        
     1379
    14301380    def user_view(self, user):
    14311381        """
    14321382        Return the view that the given user has of this worksheet. If the
    14331383        user currently doesn't have a view set it to ACTIVE and return
    14341384        ACTIVE.
    1435        
     1385
    14361386        INPUT:
    1437        
    1438        
     1387
    14391388        -  ``user`` - a string
    1440        
    1441        
     1389
    14421390        OUTPUT:
    1443        
    1444        
     1391
    14451392        -  ``Python int`` - one of ACTIVE, ARCHIVED, TRASH,
    14461393           which are defined in worksheet.py
    1447        
    1448        
     1394
    14491395        EXAMPLES: We create a new worksheet and get the view, which is
    14501396        ACTIVE::
    1451        
    1452             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1397
     1398            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14531399            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    14541400            sage: W.user_view('admin')
    14551401            1
    14561402            sage: sagenb.notebook.worksheet.ACTIVE
    14571403            1
    1458        
     1404
    14591405        Now for the admin user we move W to the archive::
    1460        
     1406
    14611407            sage: W.move_to_archive('admin')
    1462        
    1463         The view is now archive.
    1464        
    1465         ::
    1466        
     1408
     1409        The view is now archive.::
     1410
    14671411            sage: W.user_view('admin')
    14681412            0
    14691413            sage: sagenb.notebook.worksheet.ARCHIVED
    14701414            0
    1471        
    1472         For any other random viewer the view is set by default to ACTIVE.
    1473        
    1474         ::
    1475        
     1415
     1416        For any other random viewer the view is set by default to ACTIVE.::
     1417
    14761418            sage: W.user_view('foo')
    14771419            1
    14781420        """
    class Worksheet(object): 
    14951437            self.user_view(self.owner())
    14961438            d = self.__user_view
    14971439        for user, val in d.iteritems():
    1498             d[user] = [val]
     1440            if not isinstance(val, list):
     1441                d[user] = [val]
    14991442        return d
    15001443
    15011444    def set_tags(self, tags):
    15021445        """
    1503         Set the tags -- for now we ignore everything except ACTIVE, ARCHIVED, TRASH.
     1446        Set the tags -- for now we ignore everything except ACTIVE,
     1447        ARCHIVED, TRASH.
    15041448
    15051449        INPUT:
    15061450
    class Worksheet(object): 
    15171461    def set_user_view(self, user, x):
    15181462        """
    15191463        Set the view on this worksheet for the given user.
    1520        
     1464
    15211465        INPUT:
    1522        
    1523        
     1466
    15241467        -  ``user`` - a string
    1525        
     1468
    15261469        -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
    15271470           TRASH in worksheet.py
    1528        
    1529        
     1471
    15301472        EXAMPLES::
    1531        
    1532             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1473
     1474            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15331475            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    15341476            sage: W.set_user_view('admin', sagenb.notebook.worksheet.ARCHIVED)
    15351477            sage: W.user_view('admin') == sagenb.notebook.worksheet.ARCHIVED
    class Worksheet(object): 
    15511493    def user_view_is(self, user, x):
    15521494        """
    15531495        Return True if the user view of user is x.
    1554        
     1496
    15551497        INPUT:
    1556        
    1557        
     1498
    15581499        -  ``user`` - a string
    1559        
     1500
    15601501        -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
    15611502           TRASH in worksheet.py
    1562        
    1563        
     1503
    15641504        EXAMPLES::
    1565        
    1566             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1505
     1506            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15671507            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    15681508            sage: W.user_view_is('admin', sagenb.notebook.worksheet.ARCHIVED)
    15691509            False
    class Worksheet(object): 
    15711511            True
    15721512        """
    15731513        return self.user_view(user) == x
    1574                
     1514
    15751515    def is_archived(self, user):
    15761516        """
    15771517        Return True if this worksheet is archived for the given user.
    1578        
     1518
    15791519        INPUT:
    1580        
    1581        
     1520
    15821521        -  ``user`` - string
    1583        
    1584        
     1522
    15851523        OUTPUT: bool
    1586        
     1524
    15871525        EXAMPLES::
    1588        
    1589             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1526
     1527            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15901528            sage: W = nb.create_new_worksheet('Archived Test', 'admin')
    15911529            sage: W.is_archived('admin')
    15921530            False
    class Worksheet(object): 
    15991537    def is_active(self, user):
    16001538        """
    16011539        Return True if this worksheet is active for the given user.
    1602        
     1540
    16031541        INPUT:
    1604        
    1605        
     1542
    16061543        -  ``user`` - string
    1607        
    1608        
     1544
    16091545        OUTPUT: bool
    1610        
     1546
    16111547        EXAMPLES::
    1612        
    1613             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1548
     1549            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16141550            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    16151551            sage: W.is_active('admin')
    16161552            True
    class Worksheet(object): 
    16231559    def is_trashed(self, user):
    16241560        """
    16251561        Return True if this worksheet is in the trash for the given user.
    1626        
     1562
    16271563        INPUT:
    1628        
    1629        
     1564
    16301565        -  ``user`` - string
    1631        
    1632        
     1566
    16331567        OUTPUT: bool
    1634        
     1568
    16351569        EXAMPLES::
    1636        
    1637             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1570
     1571            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16381572            sage: W = nb.create_new_worksheet('Trash Test', 'admin')
    16391573            sage: W.is_trashed('admin')
    16401574            False
    class Worksheet(object): 
    16471581    def move_to_archive(self, user):
    16481582        """
    16491583        Move this worksheet to be archived for the given user.
    1650        
     1584
    16511585        INPUT:
    1652        
    1653        
     1586
    16541587        -  ``user`` - string
    1655        
    1656        
     1588
    16571589        EXAMPLES::
    1658        
    1659             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1590
     1591            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16601592            sage: W = nb.create_new_worksheet('Archive Test', 'admin')
    16611593            sage: W.move_to_archive('admin')
    16621594            sage: W.is_archived('admin')
    class Worksheet(object): 
    16671599    def set_active(self, user):
    16681600        """
    16691601        Set his worksheet to be active for the given user.
    1670        
     1602
    16711603        INPUT:
    1672        
    1673        
     1604
    16741605        -  ``user`` - string
    1675        
    1676        
     1606
    16771607        EXAMPLES::
    1678        
    1679             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1608
     1609            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16801610            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    16811611            sage: W.move_to_archive('admin')
    16821612            sage: W.is_active('admin')
    class Worksheet(object): 
    16901620    def move_to_trash(self, user):
    16911621        """
    16921622        Move this worksheet to the trash for the given user.
    1693        
     1623
    16941624        INPUT:
    1695        
    1696        
     1625
    16971626        -  ``user`` - string
    1698        
    1699        
     1627
    17001628        EXAMPLES::
    1701        
    1702             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1629
     1630            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17031631            sage: W = nb.create_new_worksheet('Trash Test', 'admin')
    17041632            sage: W.move_to_trash('admin')
    17051633            sage: W.is_trashed('admin')
    class Worksheet(object): 
    17101638    def move_out_of_trash(self, user):
    17111639        """
    17121640        Exactly the same as set_active(user).
    1713        
     1641
    17141642        INPUT:
    1715        
    1716        
     1643
    17171644        -  ``user`` - string
    1718        
    1719        
     1645
    17201646        EXAMPLES::
    1721        
    1722             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1647
     1648            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17231649            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    17241650            sage: W.move_to_trash('admin')
    17251651            sage: W.is_active('admin')
    class Worksheet(object): 
    17291655            True
    17301656        """
    17311657        self.set_active(user)
    1732        
     1658
    17331659    #############
    17341660
    17351661    def delete_cells_directory(self):
    17361662        r"""
    17371663        Delete the directory in which all the cell computations occur.
    1738        
     1664
    17391665        EXAMPLES::
    1740        
    1741             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1666
     1667            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17421668            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17431669            sage: W = nb.create_new_worksheet('Test', 'sage')
    1744             sage: W.edit_save('Sage\n{{{\n3^20\n}}}')
     1670            sage: W.edit_save('{{{\n3^20\n}}}')
     1671            sage: W.cell_list()[0].evaluate()
     1672            sage: W.check_comp()    # random output -- depends on computer speed
    17451673            sage: sorted(os.listdir(W.directory()))
    1746             ['cells', 'snapshots']
    1747             sage: W.cell_list()[0].evaluate()
     1674            ['cells', 'data']
     1675            sage: W.save_snapshot('admin')
    17481676            sage: sorted(os.listdir(W.directory()))
    1749             ['cells', 'data', 'snapshots']
     1677            ['cells', 'data', 'snapshots', 'worksheet.html']
    17501678            sage: W.delete_cells_directory()
    17511679            sage: sorted(os.listdir(W.directory()))
    1752             ['data', 'snapshots']
     1680            ['data', 'snapshots', 'worksheet.html']
    17531681        """
    17541682        dir = self.cells_directory()
    17551683        if os.path.exists(dir):
    class Worksheet(object): 
    17721700
    17731701    def set_owner(self, owner):
    17741702        self.__owner = owner
    1775         if not owner in self.__collaborators:
     1703        if not owner in self.collaborators():
    17761704            self.__collaborators.append(owner)
    17771705
    17781706    def user_is_only_viewer(self, user):
    class Worksheet(object): 
    17881716            return True
    17891717
    17901718    def user_is_collaborator(self, user):
    1791         try:
    1792             return user in self.__collaborators
    1793         except AttributeError:
    1794             return True
     1719        return user in self.collaborators()
    17951720
    17961721    def user_can_edit(self, user):
    17971722        """
    17981723        Return True if the user with given name is allowed to edit this
    17991724        worksheet.
    1800        
     1725
    18011726        INPUT:
    1802        
    1803        
     1727
    18041728        -  ``user`` - string
    1805        
    1806        
     1729
    18071730        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())
     1731
     1732        EXAMPLES: We create a notebook with one worksheet and two users.::
     1733
     1734            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    18141735            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    18151736            sage: nb.add_user('william', 'william', 'wstein@sagemath.org', force=True)
    18161737            sage: W = nb.create_new_worksheet('Test', 'sage')
    18171738            sage: W.user_can_edit('sage')
    18181739            True
    1819        
     1740
    18201741        At first the user 'william' can't edit this worksheet::
    1821        
     1742
    18221743            sage: W.user_can_edit('william')
    18231744            False
    1824        
     1745
    18251746        After adding 'william' as a collaborator he can edit the
    1826         worksheet.
    1827        
    1828         ::
    1829        
     1747        worksheet.::
     1748
    18301749            sage: W.add_collaborator('william')
    18311750            sage: W.user_can_edit('william')
    18321751            True
    1833        
     1752
    18341753        Clean up::
    1835        
     1754
    18361755            sage: nb.delete()
    18371756        """
    18381757        return self.user_is_collaborator(user) or self.is_owner(user)
    1839        
     1758
    18401759    def delete_user(self, user):
    18411760        """
    18421761        Delete a user from having any view or ownership of this worksheet.
    1843        
     1762
    18441763        INPUT:
    1845        
    1846        
     1764
    18471765        -  ``user`` - string; the name of a user
    1848        
    1849        
     1766
    18501767        EXAMPLES: We create a notebook with 2 users and 1 worksheet that
    1851         both view.
    1852        
    1853         ::
    1854        
    1855             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1768        both view.::
     1769
     1770            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    18561771            sage: nb.add_user('wstein','sage','wstein@sagemath.org',force=True)
    18571772            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    18581773            sage: W = nb.new_worksheet_with_title_from_text('Sage', owner='sage')
    class Worksheet(object): 
    18611776            'sage'
    18621777            sage: W.viewers()
    18631778            ['wstein']
    1864        
     1779
    18651780        We delete the sage user from the worksheet W. This makes wstein the
    1866         new owner.
    1867        
    1868         ::
    1869        
     1781        new owner.::
     1782
    18701783            sage: W.delete_user('sage')
    18711784            sage: W.viewers()
    18721785            ['wstein']
    18731786            sage: W.owner()
    18741787            'wstein'
    1875        
     1788
    18761789        Then we delete wstein from W, which makes the owner None::
    1877        
     1790
    18781791            sage: W.delete_user('wstein')
    18791792            sage: W.owner() is None
    18801793            True
    18811794            sage: W.viewers()
    18821795            []
    1883        
    1884         Finally, we clean up.
    1885        
    1886         ::
    1887        
     1796
     1797        Finally, we clean up.::
     1798
    18881799            sage: nb.delete()
    18891800        """
    1890         if user in self.__collaborators:
     1801        if user in self.collaborators():
    18911802            self.__collaborators.remove(user)
    18921803        if user in self.__viewers:
    18931804            self.__viewers.remove(us