Ticket #7650: trac_7650-sagenb_doctesting_v6.patch

File trac_7650-sagenb_doctesting_v6.patch, 223.0 KB (added by mpatel, 13 years ago)

Fix interact doctests for 4.3.1.alpha2 (colors.py). Replaces previous sagenb patch.

  • sagenb/misc/ipaddr.py

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

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

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

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

    diff --git a/sagenb/notebook/interact.py b/sagenb/notebook/interact.py
    a b class InputBox(InteractControl): 
    944944        EXAMPLES::
    945945
    946946            sage: sagenb.notebook.interact.InputBox('theta', Color('red'), type=Color)._adaptor('#aaaaaa',globals())
    947             RGB color (0.6640625, 0.6640625, 0.6640625)
     947            RGB color (0.66666666666666663, 0.66666666666666663, 0.66666666666666663)
    948948        """
    949949        if self.__type is None:
    950950            return sage_eval(value, globs)
    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)
    class color_selector(input_box): 
    27232723            ...
    27242724            ValueError: unknown color 'crayon'
    27252725            sage: color_selector('#abcdef', label='height', widget='jpicker')
    2726             Interact color selector labeled 'height', with default RGB color (0.66796875, 0.80078125, 0.93359375), widget 'jpicker', and visible input box
     2726            Interact color selector labeled 'height', with default RGB color (0.6705882352941176, 0.80392156862745101, 0.93725490196078431), widget 'jpicker', and visible input box
    27272727            sage: color_selector('abcdef', label='height', widget='jpicker')
    27282728            Traceback (most recent call last):
    27292729            ...
    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): 
    100100        for username in self.__users.keys():
    101101            for w in S.worksheets(username):
    102102                W['%s/%s'%(username, w.id_number())] = w
    103                
     103
    104104        self.__worksheets = W
    105        
     105
    106106    def delete(self):
    107107        """
    108108        Delete all files related to this notebook.
    109        
     109
    110110        This is used for doctesting mainly. This command is obviously
    111111        *VERY* dangerous to use on a notebook you actually care about.
    112112        You could easily lose all data.
    113        
     113
    114114        EXAMPLES::
    115        
    116             sage: tmp = tmp_dir()
    117             sage: nb = sagenb.notebook.notebook.Notebook(tmp) 
    118             sage: sorted(os.listdir(tmp)) 
    119             ['backups', 'nb2.sobj', 'objects', 'worksheets']
     115
     116            sage: tmp = tmp_dir() + '.sagenb'
     117            sage: nb = sagenb.notebook.notebook.Notebook(tmp)
     118            sage: sorted(os.listdir(tmp))
     119            ['home']
    120120            sage: nb.delete()
    121        
    122         Now the directory is gone.
    123        
    124         ::
    125        
     121
     122        Now the directory is gone.::
     123
    126124            sage: os.listdir(tmp)
    127125            Traceback (most recent call last):
    128126            ...
    class Notebook(object): 
    135133
    136134    def system_names(self):
    137135        return SYSTEM_NAMES
    138    
     136
    139137    ##########################################################
    140138    # Users
    141139    ##########################################################
    142140    def create_default_users(self, passwd):
    143141        """
    144142        Create the default users for a notebook.
    145        
     143
    146144        INPUT:
    147145
    148146        -  ``passwd`` - a string
    149        
     147
    150148        EXAMPLES::
    151        
    152             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     149
     150            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    153151            sage: nb.create_default_users('password')
    154152            Creating default users.
    155153            sage: list(sorted(nb.users().iteritems()))
    class Notebook(object): 
    174172    def user_exists(self, username):
    175173        """
    176174        Return whether a user with the given ``username`` exists.
    177        
     175
    178176        INPUT:
    179177
    180178        - ``username`` - a string
    class Notebook(object): 
    184182        - a bool
    185183
    186184        EXAMPLES::
    187        
    188             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     185
     186            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    189187            sage: nb.create_default_users('password')
    190188            Creating default users.
    191189            sage: nb.user_exists('admin')
    class Notebook(object): 
    198196            True
    199197        """
    200198        return username in self.users()
    201            
     199
    202200    def users(self):
    203201        """
    204202        Return a dictionary of users in a notebook.
    205        
     203
    206204        OUTPUT:
    207205
    208206        - a string:User instance dictionary
    209207
    210208        EXAMPLES::
    211        
    212             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     209
     210            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    213211            sage: nb.create_default_users('password')
    214212            Creating default users.
    215213            sage: list(sorted(nb.users().iteritems()))
    class Notebook(object): 
    225223        """
    226224        Return an instance of the User class given the ``username`` of a user
    227225        in a notebook.
    228        
     226
    229227        INPUT:
    230228
    231229        - ``username`` - a string
    class Notebook(object): 
    235233        - an instance of User
    236234
    237235        EXAMPLES::
    238        
    239             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     236
     237            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    240238            sage: nb.create_default_users('password')
    241239            Creating default users.
    242240            sage: nb.user('admin')
    243241            admin
    244             sage: nb.user('admin')._User__email
     242            sage: nb.user('admin').get_email()
    245243            ''
    246             sage: nb.user('admin')._User__password
     244            sage: nb.user('admin').password()
    247245            'aajfMKNH1hTm2'
    248246        """
    249247        if not isinstance(username, str) or '/' in username:
    class Notebook(object): 
    265263    def create_user_with_same_password(self, user, other_user):
    266264        r"""
    267265        Change the password of ``user`` to that of ``other_user``.
    268        
     266
    269267        INPUT:
    270        
     268
    271269        -  ``user`` - a string
    272        
     270
    273271        -  ``other_user`` - a string
    274        
     272
    275273        EXAMPLES::
    276        
    277             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     274
     275            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    278276            sage: nb.add_user('bob', 'an**d', 'bob@gmail.com', force=True)
    279277            sage: nb.user('bob').password()
    280278            'aa4Q6Jbx/MiUs'
    class Notebook(object): 
    297295        INPUT:
    298296
    299297        - ``user`` - an instance of User
    300        
     298
    301299        OUTPUT:
    302        
     300
    303301        - a bool
    304302
    305303        EXAMPLES::
    306        
    307             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     304
     305            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    308306            sage: nb.add_user('Administrator', 'password', '', 'admin', True)
    309307            sage: nb.add_user('RegularUser', 'password', '', 'user', True)
    310308            sage: nb.user_is_admin('Administrator')
    class Notebook(object): 
    321319        INPUT:
    322320
    323321        - ``username`` - a string
    324        
     322
    325323        OUTPUT:
    326324
    327325        - a bool
    328326
    329327        EXAMPLES::
    330        
    331             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     328
     329            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    332330            sage: nb.create_default_users('password')
    333331            Creating default users.
    334332            sage: nb.user_is_guest('guest')
    class Notebook(object): 
    340338            return self.user(username).is_guest()
    341339        except KeyError:
    342340            return False
    343    
     341
    344342    def user_list(self):
    345343        """
    346344        Return a list of user objects.
    347        
     345
    348346        OUTPUT:
    349347
    350348        - a list of User instances
    351349
    352350        EXAMPLES::
    353        
    354             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     351
     352            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    355353            sage: nb.create_default_users('password')
    356354            Creating default users.
    357355            sage: sorted(nb.user_list(), key=lambda k: k.username())
    class Notebook(object): 
    362360    def usernames(self):
    363361        """
    364362        Return a list of usernames.
    365        
     363
    366364        OUTPUT:
    367365
    368366        - a list of strings
    369367
    370368        EXAMPLES::
    371        
    372             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     369
     370            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    373371            sage: nb.create_default_users('password')
    374372            Creating default users.
    375373            sage: sorted(nb.usernames())
    class Notebook(object): 
    381379    def valid_login_names(self):
    382380        """
    383381        Return a list of users that can log in.
    384        
     382
    385383        OUTPUT:
    386384
    387385        - a list of strings
    388386
    389387        EXAMPLES::
    390        
    391             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     388
     389            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    392390            sage: nb.create_default_users('password')
    393391            Creating default users.
    394392            sage: nb.valid_login_names()
    class Notebook(object): 
    407405        confronted with the Sage notebook login page.  Currently, this
    408406        returns 'admin' if that is the *only* user.  Otherwise it
    409407        returns an empty string ('').
    410        
     408
    411409        OUTPUT:
    412410
    413         - a string - the default username. 
    414        
     411        - a string - the default username.
     412
    415413        EXAMPLES::
    416        
    417             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     414
     415            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    418416            sage: nb.create_default_users('password')
    419417            Creating default users.
    420418            sage: nb.default_user()
    class Notebook(object): 
    433431        Set the accounts attribute of the server configuration to
    434432        ``value``.  This property determines whether users can create
    435433        new accounts.
    436        
     434
    437435        INPUT:
    438        
     436
    439437        - ``value`` - a bool
    440438
    441439        EXAMPLES::
    442        
    443             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     440
     441            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    444442            sage: nb.get_accounts()
    445443            False
    446444            sage: nb.set_accounts(True)
    class Notebook(object): 
    454452
    455453    def get_accounts(self):
    456454        r"""
    457         Return whether or not users can create new accounts. 
    458        
     455        Return whether or not users can create new accounts.
     456
    459457        OUTPUT:
    460458
    461459        - a bool
    462460
    463461        EXAMPLES::
    464        
    465             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     462
     463            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    466464            sage: nb.get_accounts()
    467465            False
    468466            sage: nb.set_accounts(True)
    class Notebook(object): 
    476474        Add a user with the given credentials.
    477475
    478476        INPUT:
    479        
     477
    480478        -  ``username`` - the username
    481        
     479
    482480        -  ``password`` - the password
    483        
     481
    484482        -  ``email`` - the email address
    485        
     483
    486484        -  ``account_type`` - one of 'user', 'admin', or 'guest'
    487        
     485
    488486        -  ``force`` - a bool (default: False)
    489        
     487
    490488        If the method :meth:`get_accounts` returns False then user can
    491489        only be added if ``force`` is True.
    492490
    493491        EXAMPLES::
    494        
    495             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     492
     493            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    496494            sage: nb.add_user('Mark', 'password', '', force=True)
    497495            sage: nb.user('Mark')
    498496            Mark
    class Notebook(object): 
    506504        """
    507505        if not self.get_accounts() and not force:
    508506            raise ValueError, "creating new accounts disabled."
    509                                  
     507
    510508        us = self.users()
    511509        if us.has_key(username):
    512510            print "WARNING: User '%s' already exists -- and is now being replaced."%username
    class Notebook(object): 
    515513
    516514        # Save the user database
    517515        self.__storage.save_users(self.users())
    518        
     516
    519517
    520518    def change_password(self, username, password):
    521519        """
    522520        Change a user's password.
    523521
    524522        INPUT:
    525        
     523
    526524        - ``username`` - a string, the username
    527        
     525
    528526        - ``password`` - a string, the user's new password
    529        
     527
    530528        EXAMPLES::
    531        
    532             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     529
     530            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    533531            sage: nb.add_user('Mark', 'password', '', force=True)
    534532            sage: nb.user('Mark').password()
    535533            'aajfMKNH1hTm2'
    class Notebook(object): 
    542540    def del_user(self, username):
    543541        """
    544542        Delete the given user.
    545        
     543
    546544        INPUT:
    547545
    548546        - ``username`` - a string
    549547
    550548        EXAMPLES::
    551        
    552             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     549
     550            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    553551            sage: nb.add_user('Mark', 'password', '', force=True)
    554552            sage: nb.user('Mark')
    555553            Mark
    class Notebook(object): 
    565563    def passwords(self):
    566564        """
    567565        Return a username:password dictionary.
    568        
     566
    569567        OUTPUT:
    570568
    571569        - a string:string dictionary
    572570
    573571        EXAMPLES::
    574        
    575             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     572
     573            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    576574            sage: nb.create_default_users('password')
    577575            Creating default users.
    578576            sage: nb.add_user('Mark', 'password', '', force=True)
    class Notebook(object): 
    584582    def user_conf(self, username):
    585583        """
    586584        Return a user's configuration object.
    587        
     585
    588586        OUTPUT:
    589587
    590588        - an instance of Configuration.
    591589
    592590        EXAMPLES::
    593        
    594             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     591
     592            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    595593            sage: nb.create_default_users('password')
    596594            Creating default users.
    597595            sage: config = nb.user_conf('admin')
    598596            sage: config['max_history_length']
    599597            1000
    600             sage: config['system']
     598            sage: config['default_system']
    601599            'sage'
    602600            sage: config['autosave_interval']
    603601            3600
    604602            sage: config['default_pretty_print']
    605603            False
    606         """       
     604        """
    607605        return self.users()[username].conf()
    608606
    609607    ##########################################################
    class Notebook(object): 
    639637        r"""
    640638        Publish a user's worksheet.  This creates a new worksheet in
    641639        the 'pub' directory with the same contents as ``worksheet``.
    642        
     640
    643641        INPUT:
    644642
    645643        - ``worksheet`` - an instance of Worksheet
    class Notebook(object): 
    651649        - a new or existing published instance of Worksheet
    652650
    653651        EXAMPLES::
    654        
    655             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     652
     653            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    656654            sage: nb.add_user('Mark','password','',force=True)
    657655            sage: W = nb.new_worksheet_with_title_from_text('First steps', owner='Mark')
    658656            sage: nb.worksheet_names()
    659657            ['Mark/0']
    660658            sage: nb.publish_worksheet(nb.get_worksheet_with_filename('Mark/0'), 'Mark')
    661             <BLANKLINE>
    662             [Cell 0; in=, out=]
     659            pub/1: [Cell 1; in=, out=]
    663660            sage: sorted(nb.worksheet_names())
    664             ['Mark/0', 'pub/0']
     661            ['Mark/0', 'pub/1']
    665662        """
    666663        for X in self.__worksheets.itervalues():
    667664            if X.is_published() and X.worksheet_that_was_published() == worksheet:
    class Notebook(object): 
    753750    def empty_trash(self, username):
    754751        """
    755752        Empty the trash for the given user.
    756        
     753
    757754        INPUT:
    758        
     755
    759756        -  ``username`` - a string
    760        
     757
    761758        This empties the trash for the given user and cleans up all files
    762759        associated with the worksheets that are in the trash.
    763        
     760
    764761        EXAMPLES::
    765        
    766             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     762
     763            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    767764            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    768765            sage: W = nb.new_worksheet_with_title_from_text('Sage', owner='sage')
    769766            sage: W.move_to_trash('sage')
    class Notebook(object): 
    783780    def worksheet_names(self):
    784781        """
    785782        Return a list of all the names of worksheets in this notebook.
    786        
     783
    787784        OUTPUT:
    788785
    789786        - a list of strings.
    790        
    791         EXAMPLES: 
     787
     788        EXAMPLES:
    792789
    793790        We make a new notebook with two users and two worksheets,
    794791        then list their names::
    795        
    796             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     792
     793            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    797794            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    798795            sage: W = nb.new_worksheet_with_title_from_text('Sage', owner='sage')
    799796            sage: nb.add_user('wstein','sage','wstein@sagemath.org',force=True)
    800797            sage: W2 = nb.new_worksheet_with_title_from_text('Elliptic Curves', owner='wstein')
    801798            sage: nb.worksheet_names()
    802             ['sage/0', 'wstein/0']
     799            ['sage/0', 'wstein/1']
    803800        """
    804801        W = self.__worksheets.keys()
    805802        W.sort()
    class Notebook(object): 
    808805
    809806    ##########################################################
    810807    # Information about the pool of worksheet compute servers
    811     ##########################################################   
     808    ##########################################################
    812809
    813810    def server_pool(self):
    814811        return self.conf()['server_pool']
    class Notebook(object): 
    853850        ulimit = self.get_ulimit()
    854851        from sagenb.interfaces import ProcessLimits
    855852        # We have to parse the ulimit format to our ProcessLimits.
    856         # The typical format is. 
     853        # The typical format is.
    857854        # '-u 400 -v 1000000 -t 3600'
    858855        # Despite -t being cputime for ulimit, we map it to walltime,
    859856        # since that is the only thing that really makes sense for a
    class Notebook(object): 
    869866                if x.startswith(k): tbl[k] = int(x.split()[1].strip())
    870867        if tbl['v'] is not None:
    871868            tbl['v'] = tbl['v']/1000.0
    872            
    873                
     869
     870
    874871        process_limits = ProcessLimits(max_vmem=tbl['v'], max_walltime=tbl['t'],
    875872                                       max_processes=tbl['u'])
    876        
     873
    877874        server_pool = self.server_pool()
    878875        if not server_pool or len(server_pool) == 0:
    879876            return WorksheetProcess_ExpectImplementation(process_limits=process_limits)
    class Notebook(object): 
    884881            return WorksheetProcess_RemoteExpectImplementation(user_at_host=user_at_host,
    885882                             process_limits=process_limits,
    886883                             remote_python=python_command)
    887        
    888    
     884
     885
    889886    def _python_command(self):
    890887        """
    891888        """
    892889        try: return self.__python_command
    893890        except AttributeError: pass
    894        
    895            
    896        
     891
     892
     893
    897894    ##########################################################
    898895    # The default math software system for new worksheets for
    899896    # a given user or the whole notebook (if username is None).
    900897    ##########################################################
    901    
     898
    902899    def system(self, username=None):
    903900        return self.user(username).conf()['default_system']
    904901
    class Notebook(object): 
    906903    # The default typeset setting for new worksheets for
    907904    # a given user or the whole notebook (if username is None).
    908905    ##########################################################
    909    
     906
    910907    # TODO -- only implemented for the notebook right now
    911908    def pretty_print(self, username=None):
    912909        return self.user(username).conf()['default_pretty_print']
    class Notebook(object): 
    947944        W = self.create_new_worksheet(name, username)
    948945        W.edit_save('Log Worksheet\n' + self.user_history_text(username, maxlen=None))
    949946        return W
    950        
     947
    951948    def user_history_text(self, username, maxlen=None):
    952949        history = self.user_history(username)
    953950        if maxlen:
    class Notebook(object): 
    968965    def export_worksheet(self, worksheet_filename, output_filename, title=None):
    969966        """
    970967        Export a worksheet, creating a sws file on the file system.
    971        
     968
    972969        INPUT:
    973        
     970
    974971            -  ``worksheet_filename`` - a string e.g., 'username/id_number'
    975        
     972
    976973            -  ``output_filename`` - a string, e.g., 'worksheet.sws'
    977974
    978975            - ``title`` - title to use for the exported worksheet (if
    class Notebook(object): 
    998995            - ``id_number`` - nonnegative integer or None (default)
    999996        """
    1000997        S = self.__storage
    1001         if id_number is None:       
     998        if id_number is None:
    1002999            id_number = self.new_id_number(username)
    10031000        return S.load_worksheet(username, id_number)
    1004        
     1001
    10051002    def new_id_number(self, username):
    10061003        """
    10071004        Find the next worksheet id for the given user.
    class Notebook(object): 
    10291026        Import a worksheet with the given ``filename`` and set its
    10301027        ``owner``.  If the file extension is not txt or sws, raise a
    10311028        ValueError.
    1032        
     1029
    10331030        INPUT:
    1034        
     1031
    10351032        -  ``filename`` - a string
    1036        
     1033
    10371034        -  ``owner`` - a string
    1038        
     1035
    10391036        OUTPUT:
    1040        
     1037
    10411038        -  ``worksheet`` - a newly created Worksheet instance
    1042        
    1043         EXAMPLES: 
     1039
     1040        EXAMPLES:
    10441041
    10451042        We create a notebook and import a plain text worksheet
    10461043        into it.
    1047        
     1044
    10481045        ::
    1049        
    1050             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
    1051             sage: name = tmp_filename() + '.txt' 
     1046
     1047            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
     1048            sage: name = tmp_filename() + '.txt'
    10521049            sage: open(name,'w').write('foo\n{{{\n2+3\n}}}')
    10531050            sage: W = nb.import_worksheet(name, 'admin')
    1054        
     1051
    10551052        W is our newly-created worksheet, with the 2+3 cell in it::
    1056        
     1053
    10571054            sage: W.name()
    10581055            'foo'
    10591056            sage: W.cell_list()
    1060             [Cell 0; in=2+3, out=]
     1057            [TextCell 0: foo, Cell 1; in=2+3, out=]
    10611058        """
    10621059        if not os.path.exists(filename):
    10631060            raise ValueError, "no file %s"%filename
    class Notebook(object): 
    10751072            raise ValueError, "unknown extension '%s'"%ext
    10761073        self.__worksheets[W.filename()] = W
    10771074        return W
    1078            
     1075
    10791076    def _import_worksheet_txt(self, filename, owner):
    10801077        r"""
    10811078        Import a plain text file as a new worksheet.
    1082        
     1079
    10831080        INPUT:
    1084        
     1081
    10851082        -  ``filename`` - a string; a filename that ends in .txt
    1086        
     1083
    10871084        -  ``owner`` - a string; the imported worksheet's owner
    1088        
     1085
    10891086        OUTPUT:
    10901087
    10911088        -  a new instance of Worksheet
    1092        
    1093         EXAMPLES: 
     1089
     1090        EXAMPLES:
    10941091
    10951092        We write a plain text worksheet to a file and import it
    1096         using this function.
    1097        
    1098         ::
    1099        
    1100             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
    1101             sage: name = tmp_filename() + '.txt' 
     1093        using this function.::
     1094
     1095            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
     1096            sage: name = tmp_filename() + '.txt'
    11021097            sage: open(name,'w').write('foo\n{{{\na = 10\n}}}')
    11031098            sage: W = nb._import_worksheet_txt(name, 'admin'); W
    1104             [Cell 0; in=a = 10, out=]
     1099            admin/0: [TextCell 0: foo, Cell 1; in=a = 10, out=]
    11051100        """
    11061101        # Open the worksheet txt file and load it in.
    11071102        worksheet_txt = open(filename).read()
    class Notebook(object): 
    11101105        # Set the new worksheet to have the contents specified by that file.
    11111106        worksheet.edit_save(worksheet_txt)
    11121107        return worksheet
    1113    
    1114     def _import_worksheet_sws(self, filename, username, verbose=True):
     1108
     1109    def _import_worksheet_sws(self, filename, username):
    11151110        r"""
    11161111        Import an sws format worksheet into this notebook as a new
    1117         worksheet.  If the worksheet cannot be read, raise a
    1118         ValueError.
    1119        
     1112        worksheet.
     1113
    11201114        INPUT:
    1121        
     1115
    11221116        - ``filename`` - a string; a filename that ends in .sws;
    11231117           internally it must be a tar'd bz2'd file.
    1124        
     1118
    11251119        - ``username`` - a string
    1126        
    1127         - ``verbose`` - a bool (default: True) if True print some the
    1128            tar command used to extract the sws file.
    1129        
     1120
    11301121        OUTPUT:
    11311122
    11321123        - a new Worksheet instance
    1133        
    1134         EXAMPLES: We create a notebook, then make a worksheet from a plain
    1135         text file first.
    1136        
    1137         ::
    1138        
    1139             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
    1140             sage: name = tmp_filename() + '.txt' 
    1141             sage: open(name,'w').write('foo\n{{{\n2+3\n}}}')
     1124
     1125        EXAMPLES:
     1126
     1127        We create a notebook, then make a worksheet from a plain text
     1128        file first.::
     1129
     1130            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
     1131            sage: name = tmp_filename() + '.txt'
     1132            sage: open(name,'w').write('{{{id=0\n2+3\n}}}')
    11421133            sage: W = nb.import_worksheet(name, 'admin')
    11431134            sage: W.filename()
    11441135            'admin/0'
    1145        
    1146         We then export the worksheet to an sws file.
    1147        
    1148         ::
    1149        
    1150             sage: nb.export_worksheet(W.filename(),  'tmp.sws', verbose=False)
    1151        
    1152         Now we import the sws.
    1153        
    1154         ::
    1155        
    1156             sage: nb._import_worksheet_sws('tmp.sws', 'admin', verbose=False)
    1157             [Cell 0; in=2+3, out=]
    1158        
     1136
     1137        We then export the worksheet to an sws file.::
     1138
     1139            sage: sws = os.path.join(tmp_dir(), 'tmp.sws')
     1140            sage: nb.export_worksheet(W.filename(), sws)
     1141
     1142        Now we import the sws.::
     1143
     1144            sage: W = nb._import_worksheet_sws(sws, 'admin')
     1145            sage: nb._Notebook__worksheets[W.filename()] = W
     1146
    11591147        Yes, it's there now (as admin/2)::
    1160        
     1148
    11611149            sage: nb.worksheet_names()
    1162             ['admin/0', 'admin/2']
     1150            ['admin/0', 'admin/1']
    11631151        """
    11641152        id_number = self.new_id_number(username)
    11651153        worksheet = self.__storage.import_worksheet(username, id_number, filename)
    class Notebook(object): 
    11681156        # support multiple worksheets with the same title very well
    11691157        # already.  So it's commented out.
    11701158        # self.change_worksheet_name_to_avoid_collision(worksheet)
    1171        
     1159
    11721160        return worksheet
    11731161
    11741162    def change_worksheet_name_to_avoid_collision(self, worksheet):
    class Notebook(object): 
    11871175                i += 1
    11881176            name = name + " (%s)"%i
    11891177            worksheet.set_name(name)
    1190            
     1178
    11911179
    11921180    ##########################################################
    11931181    # Importing and exporting worksheets to a plain text format
    class Notebook(object): 
    11981186        Return HTML containing the plain text version of a worksheet.
    11991187
    12001188        INPUT:
    1201        
     1189
    12021190        - ``filename`` - a string; filename of a worksheet
    1203        
     1191
    12041192        - ``prompts`` - a bool (default: True); whether to format the
    12051193          text for inclusion in docstrings
    12061194
    12071195        OUTPUT:
    1208        
     1196
    12091197        - a string - the worksheet's HTML representation
    12101198        """
    12111199        worksheet = self.get_worksheet_with_filename(filename)
    class Notebook(object): 
    12491237            for W in self.__worksheets.itervalues():
    12501238                if W.docbrowser() and W.compute_process_has_been_started():
    12511239                    W.quit_if_idle(DOC_TIMEOUT)
    1252             return 
     1240            return
    12531241
    12541242        for W in self.__worksheets.itervalues():
    12551243            if W.compute_process_has_been_started():
    12561244                W.quit_if_idle(timeout)
    1257            
     1245
    12581246
    12591247    ##########################################################
    12601248    # Worksheet HTML generation
    class Notebook(object): 
    12641252        Return the HTML for a given worksheet.
    12651253
    12661254        INPUT:
    1267        
     1255
    12681256        - ``filename`` - a string; the worksheet's filename
    12691257
    12701258        - ``do_print`` - a bool (default: False); whether this is a
    12711259          printed worksheet
    12721260
    12731261        OUTPUT:
    1274        
     1262
    12751263        - a string - the worksheet rendered as HTML
    12761264
    12771265        EXAMPLES::
    1278        
    1279             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1266
     1267            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12801268            sage: W = nb.create_new_worksheet('Test', 'admin')
    12811269            sage: nb.worksheet_html(W.filename())
    12821270            '...<!D...Test...cell_id_list=[1]...</body>...</html>'
    class Notebook(object): 
    12871275                 worksheet_html = worksheet.html(include_title=False, do_print=do_print),
    12881276                        do_print = do_print)
    12891277
    1290    
     1278
    12911279
    12921280    def worksheet_list_for_public(self, username, sort='last_edited', reverse=False, search=None):
    12931281        W = [x for x in self.__worksheets.itervalues() if x.is_published() and not x.is_trashed(user)]
    class Notebook(object): 
    13191307        Return HTML for the revision list of a worksheet.
    13201308
    13211309        INPUT:
    1322        
     1310
    13231311        - ``username`` - a string
    1324        
     1312
    13251313        - ``worksheet`` - an instance of Worksheet
    13261314
    13271315        OUTPUT:
    class Notebook(object): 
    13291317        - a string - the HTML for the revision list
    13301318
    13311319        EXAMPLES::
    1332        
    1333             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1320
     1321            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13341322            sage: W = nb.create_new_worksheet('Test', 'admin')
     1323            sage: W.body()
     1324            '\n\n{{{id=1|\n\n///\n}}}'
     1325            sage: W.save_snapshot('admin')
    13351326            sage: nb.html_worksheet_revision_list('admin', W)
    13361327            '...Revision...Last Edited...seconds...ago...'
    13371328        """
    class Notebook(object): 
    13491340        Return the HTML for a specific revision of a worksheet.
    13501341
    13511342        INPUT:
    1352        
     1343
    13531344        - ``username`` - a string
    1354        
     1345
    13551346        - ``ws`` - an instance of Worksheet
    1356        
     1347
    13571348        - ``rev`` - a string containing the key of the revision
    13581349
    13591350        OUTPUT:
    1360        
     1351
    13611352        - a string - the revision rendered as HTML
    13621353        """
    13631354        t = time.time() - float(rev[:-4])
    13641355        time_ago = worksheet.convert_seconds_to_meaningful_time_span(t)
    1365        
     1356
    13661357        filename = ws.get_snapshot_text_filename(rev)
    13671358        txt = bz2.decompress(open(filename).read())
    13681359        W = self.scratch_worksheet()
    class Notebook(object): 
    13801371                if i < len(data)-1:
    13811372                    next_rev = data[i+1][1]
    13821373                break
    1383            
     1374
    13841375        return template(os.path.join("html", "notebook", "specific_revision.html"),
    13851376                        worksheet = ws, worksheet_filename = ws.filename(),
    13861377                        username = username, rev = rev, prev_rev = prev_rev,
    class Notebook(object): 
    13931384        Return the HTML for the "share" page of a worksheet.
    13941385
    13951386        INPUT:
    1396        
     1387
    13971388        - ``username`` - a string
    1398        
     1389
    13991390        - ``worksheet`` - an instance of Worksheet
    14001391
    14011392        OUTPUT:
    14021393
    14031394        - string - the share page's HTML representation
    1404        
     1395
    14051396        EXAMPLES::
    1406        
    1407             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1397
     1398            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14081399            sage: W = nb.create_new_worksheet('Test', 'admin')
    14091400            sage: nb.html_share(W, 'admin')
    14101401            '...currently shared...add or remove collaborators...'
    class Notebook(object): 
    14251416        Return the HTML for the download or delete datafile page.
    14261417
    14271418        INPUT:
    1428        
     1419
    14291420        - ``username`` - a string
    1430        
     1421
    14311422        - ``ws`` - an instance of Worksheet
    1432        
     1423
    14331424        - ``filename`` - a string; the name of the file
    14341425
    14351426        OUTPUT:
    1436        
     1427
    14371428        - a string - the page rendered as HTML
    14381429
    14391430        EXAMPLES::
    1440        
    1441             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1431
     1432            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14421433            sage: W = nb.create_new_worksheet('Test', 'admin')
    14431434            sage: nb.html_download_or_delete_datafile(W, 'admin', 'bar')
    14441435            '...Data file: bar...DATA is a special variable...uploaded...'
    class Notebook(object): 
    14481439        worksheets = self.get_worksheets_with_viewer(username)
    14491440        active_worksheets = [worksheet for worksheet in worksheets if worksheet.is_active(username)]
    14501441        sort_worksheet_list(active_worksheets, 'name', False)
    1451        
     1442
    14521443        ext = os.path.splitext(filename)[1].lower()
    14531444        file_is_image, file_is_text = False, False
    14541445        text_file_content = ""
    1455        
     1446
    14561447        if ext in ['.png', '.jpg', '.gif']:
    14571448            file_is_image = True
    14581449        if ext in ['.txt', '.tex', '.sage', '.spyx', '.py', '.f', '.f90', '.c']:
    class Notebook(object): 
    14711462
    14721463
    14731464    ##########################################################
    1474     # Accessing all worksheets with certain properties. 
     1465    # Accessing all worksheets with certain properties.
    14751466    ##########################################################
    14761467    def get_all_worksheets(self):
    14771468        return [x for x in self.__worksheets.itervalues() if not x.owner() in ['_sage_', 'pub']]
    1478    
     1469
    14791470    def get_worksheets_with_collaborator(self, user):
    1480         if self.user_is_admin(user): return self.get_all_worksheets()       
     1471        if self.user_is_admin(user): return self.get_all_worksheets()
    14811472        return [w for w in self.__worksheets.itervalues() if w.is_collaborator(user)]
    14821473
    14831474    def get_worksheet_names_with_collaborator(self, user):
    class Notebook(object): 
    14951486        return [w for w in self.get_worksheets_with_owner(owner) if w.is_viewer(user)]
    14961487
    14971488    def get_worksheet_names_with_viewer(self, user):
    1498         if self.user_is_admin(user): return [W.name() for W in self.get_all_worksheets()]       
     1489        if self.user_is_admin(user): return [W.name() for W in self.get_all_worksheets()]
    14991490        return [W.name() for W in self.get_worksheets_with_viewer(user) if not W.docbrowser()]
    15001491
    15011492    def get_worksheet_with_name(self, name):
    class Notebook(object): 
    15081499        """
    15091500        Get the worksheet with the given filename.  If there is no
    15101501        such worksheet, raise a ``KeyError``.
    1511        
     1502
    15121503        INPUT:
    15131504
    15141505        - ``filename`` - a string
    class Notebook(object): 
    15571548        Return the HTML for the debug window.
    15581549
    15591550        OUTPUT:
    1560        
     1551
    15611552        - a string - the debug window rendered as HTML
    1562    
     1553
    15631554        EXAMPLES::
    15641555
    1565             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1556            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15661557            sage: nb.html_debug_window()
    15671558            "\n<div class='debug_window'>...</div>"
    15681559        """
    15691560        return template(os.path.join("html", "notebook", "debug_window.html"))
    15701561
    1571    
     1562
    15721563    def html_plain_text_window(self, worksheet, username):
    15731564        r"""
    15741565        Return HTML for the window that displays a plain text version
    class Notebook(object): 
    15851576        - a string - the plain text window rendered as HTML
    15861577
    15871578        EXAMPLES::
    1588        
    1589             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1579
     1580            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15901581            sage: W = nb.create_new_worksheet('Test', 'admin')
    15911582            sage: nb.html_plain_text_window(W, 'admin')
    15921583            '...pre class="plaintext"...cell_intext...textfield...'
    15931584        """
    15941585        plain_text = worksheet.plain_text(prompts=True, banner=False)
    15951586        plain_text = escape(plain_text).strip()
    1596          
     1587
    15971588        return template(os.path.join("html", "notebook", "plain_text_window.html"),
    15981589                        worksheet = worksheet,
    15991590                        worksheet_filename = worksheet.filename(),
    16001591                        username = username, plain_text = plain_text,
    16011592                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1602                        
     1593
    16031594    def html_edit_window(self, worksheet, username):
    16041595        r"""
    16051596        Return HTML for a window for editing ``worksheet``.
    1606        
     1597
    16071598        INPUT:
    1608        
     1599
    16091600        - ``username`` - a string containing the username
    1610        
     1601
    16111602        - ``worksheet`` - a Worksheet instance
    16121603
    16131604        OUTPUT:
    1614        
     1605
    16151606        - a string - the editing window's HTML representation
    16161607
    16171608        EXAMPLES::
    1618        
    1619             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1609
     1610            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16201611            sage: W = nb.create_new_worksheet('Test', 'admin')
    16211612            sage: nb.html_edit_window(W, 'admin')
    16221613            '...textarea class="plaintextedit"...{{{id=1|...//...}}}...'
    class Notebook(object): 
    16241615        text = worksheet.edit_text()
    16251616        text = escape(text)
    16261617        n_lines = text.count("\n")+1
    1627          
     1618
    16281619        return template(os.path.join("html", "notebook", "edit_window.html"),
    16291620                        worksheet = worksheet,
    16301621                        worksheet_filename = worksheet.filename(),
    16311622                        username = username, text = text, n_lines = n_lines,
    16321623                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1633    
     1624
    16341625    def html_beforepublish_window(self, worksheet, username):
    16351626        r"""
    16361627        Return HTML for the warning and decision page displayed prior
    16371628        to publishing the given worksheet.
    1638        
     1629
    16391630        INPUT:
    1640        
     1631
    16411632        - ``worksheet`` - an instance of Worksheet
    1642        
     1633
    16431634        - ``username`` - a string
    16441635
    16451636        OUTPUT:
    class Notebook(object): 
    16471638        - a string - the pre-publication page rendered as HTML
    16481639
    16491640        EXAMPLES::
    1650        
    1651             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1641
     1642            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16521643            sage: W = nb.create_new_worksheet('Test', 'admin')
    16531644            sage: nb.html_beforepublish_window(W, 'admin')
    16541645            '...want to publish this worksheet?...re-publish when changes...'
    class Notebook(object): 
    16681659                        worksheet_filename = worksheet.filename(),
    16691660                        username = username,
    16701661                        JSMATH = JSMATH, JEDITABLE_TINYMCE = JEDITABLE_TINYMCE)
    1671        
     1662
    16721663    def html_afterpublish_window(self, worksheet, username, url, dtime):
    16731664        r"""
    16741665        Return HTML for a given worksheet's post-publication page.
    1675        
     1666
    16761667        INPUT:
    1677        
     1668
    16781669        - ``worksheet`` - an instance of Worksheet
    1679        
     1670
    16801671        - ``username`` - a string
    1681        
     1672
    16821673        - ``url`` - a string representing the URL of the published
    16831674          worksheet
    1684        
     1675
    16851676        - ``dtime`` - an instance of time.struct_time representing the
    16861677          publishing time
    16871678
    16881679        OUTPUT:
    16891680
    16901681        - a string - the post-publication page rendered as HTML
    1691 
    16921682        """
    16931683        from time import strftime
    16941684        time = strftime("%B %d, %Y %I:%M %p", dtime)
    1695        
     1685
    16961686        return template(os.path.join("html", "notebook", "afterpublish_window.html"),
    16971687                        worksheet = worksheet,
    16981688                        worksheet_filename = worksheet.filename(),
    class Notebook(object): 
    17041694        Return HTML for the "Upload Data" window.
    17051695
    17061696        INPUT:
    1707        
     1697
    17081698        - ``worksheet`` - an instance of Worksheet
    1709        
     1699
    17101700        - ``username`` - a string
    17111701
    17121702        OUTPUT:
    class Notebook(object): 
    17141704        - a string - the HTML representation of the data upload window
    17151705
    17161706        EXAMPLES::
    1717        
    1718             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1707
     1708            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17191709            sage: W = nb.create_new_worksheet('Test', 'admin')
    17201710            sage: nb.html_upload_data_window(W, 'admin')
    17211711            '...Upload or Create Data File...Browse...url...name of a new...'
    class Notebook(object): 
    17301720        Return the HTML for a worksheet's index page.
    17311721
    17321722        INPUT:
    1733        
     1723
    17341724        - ``worksheet_filename`` - a string (default: None)
    1735        
     1725
    17361726        - ``username`` - a string (default: 'guest')
    17371727
    17381728        - ``show_debug`` - a bool (default: False)
    1739        
     1729
    17401730        - ``admin`` - a bool (default: False)
    17411731
    17421732        OUTPUT:
    class Notebook(object): 
    17441734        - a string - the worksheet rendered as HTML
    17451735
    17461736        EXAMPLES::
    1747        
    1748             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1737
     1738            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17491739            sage: W = nb.create_new_worksheet('Test', 'admin')
    17501740            sage: nb.html(W.filename(), 'admin')
    17511741            '...Test...cell_input...plainclick...state_number...worksheet_locked=false...'
    class Notebook(object): 
    17621752        template_page = os.path.join("html", "notebook", "index.html")
    17631753        if W.docbrowser():
    17641754            template_page = os.path.join("html", "notebook", "doc_page.html")
    1765            
     1755
    17661756        return template(template_page, worksheet = W,
    17671757                        worksheet_filename = W.filename(),
    17681758                        worksheet_html = W.html(), notebook = self,
    def load_notebook(dir, interface=None, p 
    17751765    """
    17761766    Load and return a notebook from a given directory.  Create a new
    17771767    one in that directory, if one isn't already there.
    1778    
     1768
    17791769    INPUT:
    1780    
     1770
    17811771    -  ``dir`` - a string that defines a directory name
    1782    
     1772
    17831773    -  ``interface`` - the address of the interface the server listens at
    1784    
     1774
    17851775    -  ``port`` - the port the server listens on
    1786    
     1776
    17871777    -  ``secure`` - whether the notebook is secure
    17881778
    17891779    OUTPUT:
    def load_notebook(dir, interface=None, p 
    17981788                raise KeyboardInterrupt, "Interrupted notebook migration.  Delete the directory '%s' and try again."%(os.path.abspath(dir+'.sagenb'))
    17991789            return nb
    18001790        dir += '.sagenb'
    1801        
     1791
    18021792    dir = make_path_relative(dir)
    18031793    nb = Notebook(dir)
    18041794    nb.interface = interface
    def migrate_old_notebook_v1(dir): 
    18201810    """
    18211811    nb_sobj = os.path.join(dir, 'nb.sobj')
    18221812    old_nb = cPickle.loads(open(nb_sobj).read())
    1823    
     1813
    18241814    ######################################################################
    18251815    # Tell user what is going on and make a backup
    18261816    ######################################################################
    18271817
    18281818    print ""
    18291819    print "*"*80
    1830     print "*"   
     1820    print "*"
    18311821    print "* The Sage notebook at"
    1832     print "*"   
     1822    print "*"
    18331823    print "*      '%s'"%os.path.abspath(dir)
    1834     print "*"   
     1824    print "*"
    18351825    print "* will be upgraded to a new format and stored in"
    18361826    print "*"
    18371827    print "*      '%s.sagenb'."%os.path.abspath(dir)
    def migrate_old_notebook_v1(dir): 
    18471837    # Create new notebook
    18481838    new_nb = Notebook(dir+'.sagenb')
    18491839
    1850     # Define a function for transfering the attributes of one object to another. 
     1840    # Define a function for transfering the attributes of one object to another.
    18511841    def transfer_attributes(old, new, attributes):
    18521842        for attr_old, attr_new in attributes:
    18531843            if hasattr(old, attr_old):
    18541844                setattr(new, attr_new,  getattr(old, attr_old))
    1855                
     1845
    18561846    # Transfer all the notebook attributes to our new notebook object
    1857    
     1847
    18581848    new_nb.conf().confs = old_nb.conf().confs
    18591849    for t in ['pretty_print', 'server_pool', 'ulimit', 'system']:
    18601850        if hasattr(old_nb, '_Notebook__' + t):
    18611851            new_nb.conf().confs[t] = getattr(old_nb, '_Notebook__' + t)
    1862    
     1852
    18631853    # Now update the user data from the old notebook to the new one:
    18641854    print "Migrating %s user accounts..."%len(old_nb.users())
    18651855    users = new_nb.users()
    def migrate_old_notebook_v1(dir): 
    18741864        # Fix the __conf field, which is also an instance of a class
    18751865        new_user.conf().confs = old_user.conf().confs
    18761866        users[new_user.username()] = new_user
    1877        
     1867
    18781868    ######################################################################
    18791869    # Set the worksheets of the new notebook equal to the ones from
    18801870    # the old one.
    18811871    ######################################################################
    1882    
     1872
    18831873    ######################################################################
    1884    
     1874
    18851875    def migrate_old_worksheet(old_worksheet):
    18861876        """
    1887         Migrates an old worksheet to the new format. 
     1877        Migrates an old worksheet to the new format.
    18881878        """
    18891879        old_ws_dirname = old_ws._Worksheet__filename.partition(os.path.sep)[-1]
    18901880        new_ws = new_nb.worksheet(old_ws.owner(), old_ws_dirname)
    def migrate_old_notebook_v1(dir): 
    18961886                if isinstance(user,str):
    18971887                    # There was a bug in the old notebook where sometimes the
    18981888                    # user was the *module* "user", so we don't include that
    1899                     # invalid data. 
     1889                    # invalid data.
    19001890                    tags[user] = [val]
    19011891        except AttributeError:
    19021892            pass
    def migrate_old_notebook_v1(dir): 
    19091899
    19101900        ws_pub = old_ws.worksheet_that_was_published().filename().split('/')
    19111901        ws_pub = (ws_pub[0],int(ws_pub[1]))
    1912            
     1902
    19131903        obj = {'name':old_ws.name(), 'system':old_ws.system(),
    19141904               'viewers':old_ws.viewers(), 'collaborators':old_ws.collaborators(),
    19151905               'pretty_print':old_ws.pretty_print(), 'ratings':old_ws.ratings(),
    def migrate_old_notebook_v1(dir): 
    19201910               }
    19211911
    19221912        new_ws.reconstruct_from_basic(obj)
    1923        
     1913
    19241914        base = os.path.join(dir, 'worksheets', old_ws.filename())
    19251915        worksheet_file = os.path.join(base, 'worksheet.txt')
    19261916        if os.path.exists(worksheet_file):
    def migrate_old_notebook_v1(dir): 
    19461936                shutil.copytree(old_ws.cells_directory(), dest)
    19471937        except Exception, msg:
    19481938            print msg
    1949                
     1939
    19501940
    19511941        return new_ws
    1952    
     1942
    19531943    worksheets = {}
    19541944    num_worksheets = len(old_nb._Notebook__worksheets)
    19551945    print "Migrating (at most) %s worksheets..."%num_worksheets
    def make_path_relative(dir): 
    19891979
    19901980    INPUT:
    19911981
    1992     - ``dir`` - a string containing, e.g., a directory name 
     1982    - ``dir`` - a string containing, e.g., a directory name
    19931983
    19941984    OUTPUT:
    19951985
    def make_path_relative(dir): 
    20021992
    20031993##########################################################
    20041994# Misc
    2005 ##########################################################   
     1995##########################################################
    20061996
    20071997def clean_name(name):
    20081998    return ''.join([x if (x.isalnum() or x == '_') else '_' for x in name])
    def sort_worksheet_list(v, sort, reverse 
    20122002    Sort a given list on a given key, in a given order.
    20132003
    20142004    INPUT:
    2015    
     2005
    20162006    - ``sort`` - a string; 'last_edited', 'owner', 'rating', or 'name'
    2017    
     2007
    20182008    - ``reverse`` - a bool; if True, reverse the order of the sort.
    20192009
    20202010    OUTPUT:
  • sagenb/notebook/notebook_object.py

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

    diff --git a/sagenb/notebook/twist.py b/sagenb/notebook/twist.py
    a b TESTS: 
    66It is important that this file never be imported by default on
    77startup by Sage, since it is very expensive, since importing Twisted
    88is expensive. This doctest verifies that twist.py isn't imported on
    9 startup.
    10 
    11 ::
     9startup.::
    1210
    1311    sage: os.system("sage -startuptime | grep twisted\.web2 1>/dev/null") != 0  # !=0 means not found
    1412    True
    class Worksheet_do_upload_data(Worksheet 
    594592            if not os.path.isfile(dest):
    595593                return HTMLResponse(stream=message('Suspicious filename "%s" encountered uploading file.%s' % (name, backlinks), worksheet_url))
    596594            os.unlink(dest)
    597            
     595
    598596        response = http.RedirectResponse(worksheet_url + '/datafile?name=%s' % name)
    599597
    600598        if url != '':
    class SettingsPage(resource.PostableReso 
    956954        autosave = int(request.args.get('autosave', [0])[0]) * 60
    957955        if autosave:
    958956            nu['autosave_interval'] = autosave
    959             redirect_to_home = True           
     957            redirect_to_home = True
    960958
    961959        old = request.args.get('old-pass', [None])[0]
    962960        new = request.args.get('new-pass', [None])[0]
    def render_worksheet_list(args, pub, use 
    15261524    -  ``username`` - the user whose worksheets we are
    15271525       listing
    15281526
    1529     OUTPUT: 
     1527    OUTPUT:
    15301528
    15311529    a string
    15321530    """
    class EmptyTrash(resource.Resource): 
    16021600        This twisted resource empties the trash of the current user when it
    16031601        is rendered.
    16041602
    1605         EXAMPLES:
    1606 
    1607         We create an instance of this resource.
    1608 
    1609         ::
     1603        EXAMPLES:
     1604
     1605        We create an instance of this resource.::
    16101606
    16111607            sage: import sagenb.notebook.twist
    16121608            sage: E = sagenb.notebook.twist.EmptyTrash('sage'); E
    class EmptyTrash(resource.Resource): 
    16191615        Rendering this resource (1) empties the trash, and (2) returns a
    16201616        message.
    16211617
    1622         EXAMPLES: 
     1618        EXAMPLES:
    16231619
    16241620        We create a notebook with a worksheet, put it in the
    16251621        trash, then empty the trash by creating and rendering this
    1626         worksheet.
    1627 
    1628         ::
    1629 
    1630             sage: n = sagenb.notebook.notebook.Notebook('notebook-test')
     1622        worksheet.::
     1623
     1624            sage: n = sagenb.notebook.notebook.load_notebook('notebook-test.sagenb')
    16311625            sage: n.add_user('sage','sage','sage@sagemath.org',force=True)
    16321626            sage: W = n.new_worksheet_with_title_from_text('Sage', owner='sage')
    16331627            sage: W.move_to_trash('sage')
    class EmptyTrash(resource.Resource): 
    16361630            sage: sagenb.notebook.twist.notebook = n
    16371631            sage: E = sagenb.notebook.twist.EmptyTrash('sage'); E
    16381632            <sagenb.notebook.twist.EmptyTrash object at ...>
    1639             sage: E.render(None)
    1640             <twisted.web2.http.Response code=200, streamlen=...>
     1633            sage: from sagenb.notebook.twist import HTMLResponse
     1634            sage: ctx = HTMLResponse(stream = 'foo')
     1635            sage: ctx.headers.addRawHeader('referer', 'over there')
     1636            sage: E.render(ctx)
     1637            <RedirectResponse 301 Document moved to over there.>
    16411638
    16421639        Finally we verify that the trashed worksheet is gone::
    16431640
    class JSMath_js(resource.Resource): 
    18441841        s = template(os.path.join('js', 'jsmath.js'),
    18451842                     jsmath_macros = jsmath_macros,
    18461843                     jsmath_image_fonts = jsmath_image_fonts)
    1847        
     1844
    18481845        return http.Response(stream=s)
    18491846
    18501847class Main_js(resource.Resource):
    import re 
    19631960re_valid_username = re.compile('[a-z|A-Z|0-9|_|.|@]*')
    19641961def is_valid_username(username):
    19651962    r"""
    1966     Returns True if and only if ``username`` is valid, i.e., between 3
    1967     and 64 characters long. You may only use letters, numbers,
    1968     underscores, @, and dots.
     1963    Returns whether a candidate username is valid.  It must contain
     1964    between 3 and 65 of these characters: letters, numbers,
     1965    underscores, @, and/or dots ('.').
     1966
     1967    INPUT:
     1968
     1969    - ``username`` - a string; the candidate username
     1970
     1971    OUTPUT:
     1972
     1973    - a boolean
    19691974
    19701975    EXAMPLES::
    19711976
    19721977        sage: from sagenb.notebook.twist import is_valid_username
    1973 
    1974     ``username`` must start with a letter
    1975 
    1976     ::
    1977 
    19781978        sage: is_valid_username('mark10')
    19791979        True
    19801980        sage: is_valid_username('10mark')
    19811981        False
    1982 
    1983     ``username`` must be between 4 and 32 characters long
    1984 
    1985     ::
    1986 
    1987         sage: is_valid_username('bob')
     1982        sage: is_valid_username('me')
    19881983        False
    1989         sage: is_valid_username('I_love_computer_science_and_maths') #33 characters long
     1984        sage: is_valid_username('abcde' * 13)
    19901985        False
    1991 
    1992     ``username`` must not have more than one dot (.)
    1993 
    1994     ::
    1995 
    1996         sage: is_valid_username('david.andrews')
    1997         True
    1998         sage: is_valid_username('david.m.andrews')
    1999         False
    2000         sage: is_valid_username('math125.TA.5')
    2001         False
    2002 
    2003     ``username`` must not have any spaces
    2004 
    2005     ::
    2006 
    20071986        sage: is_valid_username('David Andrews')
    20081987        False
    20091988        sage: is_valid_username('David M. Andrews')
    20101989        False
    2011 
    2012     ::
    2013 
    20141990        sage: is_valid_username('sarah_andrews')
    20151991        True
    2016 
    2017     ::
    2018 
    20191992        sage: is_valid_username('TA-1')
    20201993        False
    20211994        sage: is_valid_username('math125-TA')
    20221995        False
    2023 
    2024     ::
    2025 
    20261996        sage: is_valid_username('dandrews@sagemath.org')
    2027         False
     1997        True
    20281998    """
    20291999    import string
    20302000
    class LoginResourceClass(resource.Resour 
    24132383        template_dict = {'accounts': notebook.get_accounts(),
    24142384                         'default_user': notebook.default_user(),
    24152385                         'recovery': notebook.conf()['email'],
    2416                          'sage_version':SAGE_VERSION}                         
     2386                         'sage_version':SAGE_VERSION}
    24172387        return HTMLResponse(stream=template(os.path.join('html', 'login.html'), **template_dict))
    24182388
    24192389    def childFactory(self, request, name):
    class FailedToplevel(Toplevel): 
    24782448                             'default_user': self.username,
    24792449                             'password_error': True,
    24802450                             'recovery': notebook.conf()['email'],
    2481                              'sage_version':SAGE_VERSION}                             
     2451                             'sage_version':SAGE_VERSION}
    24822452            return HTMLResponse(stream=template(os.path.join('html', 'login.html'), **template_dict))
    24832453        elif self.problem == 'suspended':
    24842454            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 from sagenb.interfaces import (Worksheet 
    3939                               WorksheetProcess_ReferenceImplementation,
    4040                               WorksheetProcess_RemoteExpectImplementation)
    4141
    42                          
     42
    4343import sagenb.misc.support  as support
    4444
    4545# Imports specifically relevant to the sage notebook
    SAGE_END = SC + 'e' 
    7272SAGE_ERROR = SC + 'r'
    7373
    7474# Integers that define which folder this worksheet is in
    75 # relative to a given user. 
     75# relative to a given user.
    7676ARCHIVED = 0
    7777ACTIVE   = 1
    7878TRASH    = 2
    all_worksheet_processes = [] 
    8181
    8282def update_worksheets():
    8383    """
    84     Iterate through and "update" all the worksheets.  This is needed for things like
    85     wall timeouts.
     84    Iterate through and "update" all the worksheets.  This is needed
     85    for things like wall timeouts.
    8686    """
    8787    for S in all_worksheet_processes:
    8888        S.update()
    def worksheet_filename(name, owner): 
    9393    """
    9494    Return the relative directory name of this worksheet with given
    9595    name and owner.
    96    
     96
    9797    INPUT:
    98    
    99    
     98
    10099    -  ``name`` - string, which may have spaces and funny
    101100       characters, which are replaced by underscores.
    102    
     101
    103102    -  ``owner`` - string, with no spaces or funny
    104103       characters
    105    
    106    
     104
    107105    OUTPUT: string
    108    
     106
    109107    EXAMPLES::
    110    
     108
    111109        sage: sagenb.notebook.worksheet.worksheet_filename('Example worksheet 3', 'sage10')
    112110        'sage10/Example_worksheet_3'
    113111        sage: sagenb.notebook.worksheet.worksheet_filename('Example#%&! work\\sheet 3', 'sage10')
    def Worksheet_from_basic(obj, notebook_w 
    127125           stores worksheets, i.e., nb.worksheet_directory().
    128126
    129127    OUTPUT:
    130    
     128
    131129        - a worksheet
    132130
    133131    EXAMPLES::
     132
    134133            sage: import sagenb.notebook.worksheet
    135             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
     134            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
    136135            sage: _=W.new_cell_after(0); B = W.basic()
    137             sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, '')
     136            sage: W0 = sagenb.notebook.worksheet.Worksheet_from_basic(B, tmp_dir())
    138137            sage: W0.basic() == B
    139138            True
    140139    """
    class Worksheet(object): 
    150149                 auto_publish=False, create_directories=True):
    151150        """
    152151        Create and initialize a new worksheet.
    153        
     152
    154153        INPUT:
    155        
    156        
     154
    157155        -  ``name`` - string; the name of this worksheet
    158        
     156
    159157        - ``id_number`` - Integer; name of the directory in which the
    160158           worksheet's data is stored
    161        
     159
    162160        -  ``notebook_worksheet_directory`` - string; the
    163161           directory in which the notebook object that contains this worksheet
    164162           stores worksheets, i.e., nb.worksheet_directory().
    165        
     163
    166164        -  ``system`` - string; 'sage', 'gp', 'singular', etc.
    167165           - the math software system in which all code is evaluated by
    168166           default
    169        
     167
    170168        -  ``owner`` - string; username of the owner of this
    171169           worksheet
    172        
     170
    173171        -  ``docbrowser`` - bool (default: False); whether this
    174172           is a docbrowser worksheet
    175        
     173
    176174        -  ``pretty_print`` - bool (default: False); whether
    177175           all output is pretty printed by default.
    178176
    class Worksheet(object): 
    180178          creates various files and directories where data will be
    181179          stored.  This option is here only for the
    182180          migrate_old_notebook method in notebook.py
    183        
    184        
     181
    185182        EXAMPLES: We test the constructor via an indirect doctest::
    186        
    187             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     183
     184            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    188185            sage: W = nb.create_new_worksheet('Test', 'admin')
    189186            sage: W
    190             admin/0: [Cell 0; in=, out=]
     187            admin/0: [Cell 1; in=, out=]
    191188        """
    192189        if name is None:
    193190            # A fresh worksheet
    class Worksheet(object): 
    205202
    206203        # state sequence number, used for sync
    207204        self.__state_number = 0
    208        
     205
    209206        # Initialize the cell id counter.
    210207        self.__next_id = 0
    211208
    class Worksheet(object): 
    250247        EXAMPLES::
    251248
    252249            sage: from sagenb.notebook.worksheet import Worksheet
    253             sage: W = Worksheet('test', 2, '', owner='sageuser')
     250            sage: W = Worksheet('test', 2, tmp_dir(), owner='sageuser')
    254251            sage: W.id_number()
    255252            2
    256253            sage: type(W.id_number())
    class Worksheet(object): 
    268265        configuration of this worksheet, except the actual cells and
    269266        the data files in the DATA directory and images and other data
    270267        in the individual cell directories.
    271        
     268
    272269        EXAMPLES::
    273270
    274271            sage: import sagenb.notebook.worksheet
    275             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', owner='sage')
     272            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), owner='sage')
    276273            sage: sorted((W.basic().items()))
    277274            [('auto_publish', False),
    278              ('collaborators', []),
    279              ('id_number', 0),
    280              ('last_change', ('sage', ...)),
    281              ('name', 'test'),
    282              ('owner', 'sage'),
    283              ('pretty_print', False),
    284              ('published_id_number', None),
    285              ('ratings', []),
    286              ('system', None),
    287              ('tags', {}),
    288              ('viewers', []),
    289              ('worksheet_that_was_published', None)]
     275              ('collaborators', []),
     276              ('id_number', 0),
     277              ('last_change', ('sage', ...)),
     278              ('name', 'test'),
     279              ('owner', 'sage'),
     280              ('pretty_print', False),
     281              ('published_id_number', None),
     282              ('ratings', []),
     283              ('system', None),
     284              ('tags', {'sage': [1]}),
     285              ('viewers', []),
     286              ('worksheet_that_was_published', ('sage', 0))]
    290287        """
    291288        try:
    292289            published_id_number = int(os.path.split(self.__published_version)[1])
    class Worksheet(object): 
    297294            ws_pub = self.__worksheet_came_from
    298295        except AttributeError:
    299296            ws_pub = (self.owner(), self.id_number())
    300            
     297
    301298        d = {#############
    302299             # basic identification
    303300             'name':self.name(),
    class Worksheet(object): 
    324321             # worksheet.  Otherwise ws_pub is None.
    325322             'worksheet_that_was_published':ws_pub,
    326323             # Whether or not this worksheet should automatically be
    327              # republished when changed. 
     324             # republished when changed.
    328325             'auto_publish':self.is_auto_publish(),
    329326
    330327             # Appearance: e.g., whether to pretty print this
    class Worksheet(object): 
    365362              ``id_number`` is a key of obj; otherwise not.
    366363
    367364        EXAMPLES::
     365
    368366            sage: import sagenb.notebook.worksheet
    369             sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, '', system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
     367            sage: W = sagenb.notebook.worksheet.Worksheet('test', 0, tmp_dir(), system='gap', owner='sageuser', pretty_print=True, auto_publish=True)
    370368            sage: W.new_cell_after(0)
    371369            Cell 1; in=, out=
    372370            sage: b = W.basic()
    373371            sage: W0 = sagenb.notebook.worksheet.Worksheet()
    374             sage: W0.reconstruct_from_basic(b,'')
     372            sage: W0.reconstruct_from_basic(b, tmp_dir())
    375373            sage: W0.basic() == W.basic()
    376374            True
    377375        """
    class Worksheet(object): 
    407405    def __cmp__(self, other):
    408406        """
    409407        We compare two worksheets.
    410        
     408
    411409        INPUT:
    412        
    413        
     410
    414411        -  ``self, other`` - worksheets
    415        
    416        
     412
    417413        OUTPUT:
    418        
    419        
     414
    420415        -  ``-1,0,1`` - comparison is on the underlying
    421416           file names.
    422        
    423        
     417
    424418        EXAMPLES::
    425        
    426             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     419
     420            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    427421            sage: W2 = nb.create_new_worksheet('test2', 'admin')
    428422            sage: W1 = nb.create_new_worksheet('test1', 'admin')
    429423            sage: cmp(W1, W2)
    class Worksheet(object): 
    440434        r"""
    441435        Return string representation of this worksheet, which is simply the
    442436        string representation of the underlying list of cells.
    443        
     437
    444438        OUTPUT: string
    445        
     439
    446440        EXAMPLES::
    447        
    448             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     441
     442            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    449443            sage: W = nb.create_new_worksheet('test1', 'admin')
    450444            sage: W.__repr__()
    451             'admin/0: [Cell 0; in=, out=]'
    452             sage: W.edit_save('Sage\n{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
     445            'admin/0: [Cell 1; in=, out=]'
     446            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
    453447            sage: W.__repr__()
    454448            'admin/0: [Cell 0; in=2+3, out=\n5, Cell 10; in=2+8, out=\n10]'
    455449        """
    class Worksheet(object): 
    457451    def __len__(self):
    458452        r"""
    459453        Return the number of cells in this worksheet.
    460        
     454
    461455        OUTPUT: int
    462        
     456
    463457        EXAMPLES::
    464        
    465             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     458
     459            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    466460            sage: W = nb.create_new_worksheet('test1', 'admin')
    467461            sage: len(W)
    468462            1
    469             sage: W.edit_save('Sage\n{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
     463            sage: W.edit_save('{{{\n2+3\n///\n5\n}}}\n{{{id=10|\n2+8\n///\n10\n}}}')
    470464            sage: len(W)
    471465            2
    472466        """
    class Worksheet(object): 
    488482    def docbrowser(self):
    489483        """
    490484        Return True if this is a docbrowser worksheet.
    491        
     485
    492486        OUTPUT: bool
    493        
     487
    494488        EXAMPLES: We first create a standard worksheet for which docbrowser
    495489        is of course False::
    496        
    497             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     490
     491            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    498492            sage: W = nb.create_new_worksheet('test1', 'admin')
    499493            sage: W.docbrowser()
    500494            False
    501        
     495
    502496        We create a worksheet for which docbrowser is True::
    503        
     497
    504498            sage: W = nb.create_new_worksheet('docs', 'admin', docbrowser=True)
    505499            sage: W.docbrowser()
    506500            True
    class Worksheet(object): 
    520514        """
    521515        Return a (reference to the) list of the collaborators who can also
    522516        view and modify this worksheet.
    523        
     517
    524518        OUTPUT: list
    525        
     519
    526520        EXAMPLES::
    527        
    528             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     521
     522            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    529523            sage: W = nb.create_new_worksheet('test1', 'admin')
    530524            sage: C = W.collaborators(); C
    531525            []
    class Worksheet(object): 
    538532        except AttributeError:
    539533            self.__collaborators = []
    540534            return self.__collaborators
    541        
     535
    542536    def collaborator_names(self, max=None):
    543537        """
    544538        Returns a string of the non-owner collaborators on this worksheet.
    545        
     539
    546540        INPUT:
    547        
    548        
     541
    549542        -  ``max`` - an integer. If this is specified, then
    550543           only max number of collaborators are shown.
    551        
    552        
     544
    553545        EXAMPLES::
    554        
    555             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     546
     547            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    556548            sage: W = nb.create_new_worksheet('test1', 'admin')
    557549            sage: C = W.collaborators(); C
    558550            []
    class Worksheet(object): 
    572564        """
    573565        Set the list of collaborators to those listed in the list v of
    574566        strings.
    575        
     567
    576568        INPUT:
    577        
    578        
     569
    579570        -  ``v`` - a list of strings
    580        
    581        
     571
    582572        EXAMPLES::
    583        
    584             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     573
     574            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    585575            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    586576            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    587577            sage: W = nb.create_new_worksheet('test1', 'admin')
    588578            sage: W.set_collaborators(['sage', 'admin', 'hilbert', 'sage'])
    589        
     579
    590580        Note that repeats are not added multiple times and admin - the
    591581        owner - isn't added::
    592        
     582
    593583            sage: W.collaborators()
    594584            ['hilbert', 'sage']
    595585        """
    class Worksheet(object): 
    612602    def viewers(self):
    613603        """
    614604        Return list of viewers of this worksheet.
    615        
     605
    616606        OUTPUT:
    617        
    618        
     607
    619608        -  ``list`` - of string
    620        
    621        
     609
    622610        EXAMPLES::
    623        
    624             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     611
     612            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    625613            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    626614            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    627615            sage: W = nb.create_new_worksheet('test1', 'admin')
    class Worksheet(object): 
    641629    def viewer_names(self, max=None):
    642630        """
    643631        Returns a string of the non-owner viewers on this worksheet.
    644        
     632
    645633        INPUT:
    646        
    647        
     634
    648635        -  ``max`` - an integer. If this is specified, then
    649636           only max number of viewers are shown.
    650        
    651        
     637
    652638        EXAMPLES::
    653        
    654             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     639
     640            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    655641            sage: W = nb.create_new_worksheet('test1', 'admin')
    656642            sage: C = W.viewers(); C
    657643            []
    class Worksheet(object): 
    672658        Delete data from this worksheet this is specific to a certain
    673659        notebook. This means deleting the attached files, collaborators,
    674660        and viewers.
    675        
     661
    676662        EXAMPLES::
    677        
    678             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     663
     664            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    679665            sage: nb.add_user('hilbert','sage','sage@sagemath.org',force=True)
    680666            sage: W = nb.create_new_worksheet('test1', 'admin')
    681667            sage: W.add_viewer('hilbert')
    class Worksheet(object): 
    692678        self.__attached = {}
    693679        self.__collaborators = [self.owner()]
    694680        self.__viewers = []
    695    
     681
    696682    def name(self):
    697683        """
    698684        Return the name of this worksheet.
    699        
     685
    700686        OUTPUT: string
    701        
     687
    702688        EXAMPLES::
    703        
    704             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     689
     690            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    705691            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    706692            sage: W.name()
    707693            'A Test Worksheet'
    class Worksheet(object): 
    715701    def set_name(self, name):
    716702        """
    717703        Set the name of this worksheet.
    718        
     704
    719705        INPUT:
    720        
    721        
     706
    722707        -  ``name`` - string
    723        
    724        
     708
    725709        EXAMPLES: We create a worksheet and change the name::
    726        
    727             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     710
     711            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    728712            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    729713            sage: W.set_name('A renamed worksheet')
    730714            sage: W.name()
    class Worksheet(object): 
    738722        r"""
    739723        Set this worksheet filename (actually directory) by getting the
    740724        owner from the pre-stored owner via ``self.owner()``.
    741        
     725
    742726        INPUT:
    743        
    744        
     727
    745728        -  ``nm`` - string
    746        
    747        
     729
    748730        EXAMPLES::
    749        
    750             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     731
     732            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    751733            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    752734            sage: W.filename()
    753735            'admin/0'
    class Worksheet(object): 
    761743    def set_filename(self, filename):
    762744        """
    763745        Set the worksheet filename (actually directory).
    764        
     746
    765747        INPUT:
    766        
    767        
     748
    768749        -  ``filename`` - string
    769        
    770        
     750
    771751        EXAMPLES::
    772        
    773             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     752
     753            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    774754            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    775755            sage: W.filename()
    776756            'admin/0'
    class Worksheet(object): 
    780760        """
    781761        old_filename = self.__filename
    782762        self.__filename = filename
    783         self.__dir = os.path.join(self.notebook().worksheet_directory(), filename)
     763        self.__dir = os.path.join(self.notebook()._dir, filename)
    784764        self.notebook().change_worksheet_key(old_filename, filename)
    785765
    786766    def filename(self):
    787767        """
    788768        Return the filename (really directory) where the files associated
    789769        to this worksheet are stored.
    790        
     770
    791771        EXAMPLES::
    792        
    793             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     772
     773            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    794774            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    795775            sage: W.filename()
    796776            'admin/0'
    797             sage: sorted(os.listdir(nb.directory() + '/worksheets/' + W.filename()))
    798             ['cells', 'snapshots']
     777            sage: os.path.isdir(os.path.join(nb._dir, 'home', W.filename()))
     778            True
    799779        """
    800780        return self.__filename
    801781
    class Worksheet(object): 
    803783        """
    804784        Return the part of the worksheet filename after the last /, i.e.,
    805785        without any information about the owner of this worksheet.
    806        
     786
    807787        EXAMPLES::
    808        
    809             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     788
     789            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    810790            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    811791            sage: W.filename_without_owner()
    812792            '0'
    class Worksheet(object): 
    819799        """
    820800        Return the full path to the directory where this worksheet is
    821801        stored.
    822        
     802
    823803        OUTPUT: string
    824        
     804
    825805        EXAMPLES::
    826        
    827             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     806
     807            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    828808            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    829809            sage: W.directory()
    830             '.../worksheets/admin/0'
     810            '.../home/admin/0'
    831811        """
    832812        return self.__dir
    833813
    834814    def data_directory(self):
    835815        """
    836816        Return path to directory where worksheet data is stored.
    837        
     817
    838818        OUTPUT: string
    839        
     819
    840820        EXAMPLES::
    841        
    842             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     821
     822            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    843823            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    844824            sage: W.data_directory()
    845             '.../worksheets/admin/0/data'
     825            '.../home/admin/0/data'
    846826        """
    847827        d = os.path.join(self.directory(), 'data')
    848828        if not os.path.exists(d):
    class Worksheet(object): 
    853833        """
    854834        Return a list of the file names of files in the worksheet data
    855835        directory.
    856        
     836
    857837        OUTPUT: list of strings
    858        
     838
    859839        EXAMPLES::
    860        
    861             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     840
     841            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    862842            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    863843            sage: W.attached_data_files()
    864844            []
    class Worksheet(object): 
    875855        """
    876856        Return the directory in which the cells of this worksheet are
    877857        evaluated.
    878        
     858
    879859        OUTPUT: string
    880        
     860
    881861        EXAMPLES::
    882        
    883             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     862
     863            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    884864            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    885865            sage: W.cells_directory()
    886             '.../worksheets/admin/0/cells'
     866            '.../home/admin/0/cells'
    887867        """
    888868        path = os.path.join(self.directory(), 'cells')
    889869        if not os.path.exists(path):
    class Worksheet(object): 
    893873    def notebook(self):
    894874        """
    895875        Return the notebook that contains this worksheet.
    896        
     876
    897877        OUTPUT: a Notebook object.
    898        
     878
    899879        EXAMPLES: This really returns the Notebook object that is set as a
    900         global variable of the twist module.
    901        
    902         ::
    903        
    904             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     880        global variable of the twist module.::
     881
     882            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    905883            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    906884            sage: W.notebook()
    907885            <...sagenb.notebook.notebook.Notebook...>
    class Worksheet(object): 
    918896        """
    919897        Return the math software system in which by default all input to
    920898        the notebook is evaluated.
    921        
     899
    922900        OUTPUT: string
    923        
     901
    924902        EXAMPLES::
    925        
    926             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     903
     904            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    927905            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    928906            sage: W.system()
    929907            'sage'
    class Worksheet(object): 
    946924        Sage installed to running a server from the same directory
    947925        without Sage installed.   We might as well support this.
    948926
    949         OUTPUT:
    950 
    951             - integer
     927        OUTPUT: integer
    952928        """
    953929        S = self.system()
    954930        names = self.notebook().system_names()
    class Worksheet(object): 
    963939        """
    964940        Set the math software system in which input is evaluated by
    965941        default.
    966        
     942
    967943        INPUT:
    968        
    969        
     944
    970945        -  ``system`` - string (default: 'sage')
    971        
    972        
     946
    973947        EXAMPLES::
    974        
    975             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     948
     949            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    976950            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    977951            sage: W.set_system('magma')
    978952            sage: W.system()
    class Worksheet(object): 
    983957    def pretty_print(self):
    984958        """
    985959        Return True if output should be pretty printed by default.
    986        
     960
    987961        OUTPUT:
    988        
    989        
     962
    990963        -  ``bool`` - True of False
    991        
    992        
     964
    993965        EXAMPLES::
    994        
    995             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     966
     967            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    996968            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    997969            sage: W.pretty_print()
    998970            False
    999971            sage: W.set_pretty_print('true')
    1000972            sage: W.pretty_print()
    1001973            True
     974            sage: W.quit()
     975            sage: nb.delete()
    1002976        """
    1003977        try:
    1004978            return self.__pretty_print
    class Worksheet(object): 
    1009983    def set_pretty_print(self, check='false'):
    1010984        """
    1011985        Set whether or not output should be pretty printed by default.
    1012        
     986
    1013987        INPUT:
    1014        
    1015        
     988
    1016989        -  ``check`` - string (default: 'false'); either 'true'
    1017990           or 'false'.
    1018        
    1019        
     991
    1020992        .. note::
    1021993
    1022994           The reason the input is a string and lower case instead of
    class Worksheet(object): 
    1024996           JavaScript. (And, Jason Grout wrote this and didn't realize
    1025997           how unpythonic this design is - it should be redone to use
    1026998           True/False.)
    1027        
     999
    10281000        EXAMPLES::
    1029        
    1030             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1001
     1002            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10311003            sage: W = nb.create_new_worksheet('A Test Worksheet', 'admin')
    10321004            sage: W.set_pretty_print('false')
    10331005            sage: W.pretty_print()
    class Worksheet(object): 
    10351007            sage: W.set_pretty_print('true')
    10361008            sage: W.pretty_print()
    10371009            True
     1010            sage: W.quit()
     1011            sage: nb.delete()
    10381012        """
    10391013        if check == 'false':
    10401014            check=False
    class Worksheet(object): 
    10421016            check=True
    10431017        self.__pretty_print = check
    10441018        self.eval_asap_no_output("pretty_print_default(%r)"%(check))
    1045        
     1019
    10461020    ##########################################################
    10471021    # Publication
    10481022    ##########################################################
    10491023    def is_auto_publish(self):
    10501024        """
    1051         Returns True if this worksheet should be automatically published. 
     1025        Returns True if this worksheet should be automatically published.
    10521026        """
    1053         try: 
     1027        try:
    10541028            return self.__autopublish
    10551029        except AttributeError:
    10561030            self.__autopublish = False
    10571031            return False
    1058    
     1032
    10591033    def set_auto_publish(self, x):
    10601034        self.__autopublish = x
    1061    
     1035
    10621036    def is_published(self):
    10631037        """
    10641038        Return True if this worksheet is a published worksheet.
    1065        
     1039
    10661040        OUTPUT:
    1067        
    1068        
     1041
    10691042        -  ``bool`` - whether or not owner is 'pub'
    1070        
    1071        
     1043
    10721044        EXAMPLES::
    1073        
    1074             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1045
     1046            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    10751047            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    10761048            sage: W.is_published()
    10771049            False
    class Worksheet(object): 
    10861058        Return owner and id_number of the worksheet that was published
    10871059        to get this worksheet, if this worksheet was
    10881060        published. Otherwise just return this worksheet.
    1089        
     1061
    10901062        OUTPUT: Worksheet
    1091        
     1063
    10921064        EXAMPLES::
    1093        
    1094             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1065
     1066            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    10951067            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    10961068            sage: W.worksheet_that_was_published() is W
    10971069            True
    1098        
    1099         ::
    1100        
    11011070            sage: S = nb.publish_worksheet(W, 'admin')
    11021071            sage: S.worksheet_that_was_published() is S
    11031072            False
    class Worksheet(object): 
    11081077            return self.notebook().get_worksheet_with_filename('%s/%s'%self.__worksheet_came_from)
    11091078        except Exception:  # things can go wrong (especially with old migrated
    11101079                           # Sage notebook servers!), but we don't want such
    1111                            # problems to crash the notebook server. 
     1080                           # problems to crash the notebook server.
    11121081            return self
    11131082
    11141083    def publisher(self):
    11151084        """
    11161085        Return username of user that published this worksheet.
    1117        
     1086
    11181087        OUTPUT: string
    1119        
     1088
    11201089        EXAMPLES::
    1121        
    1122             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1090
     1091            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11231092            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11241093            sage: S = nb.publish_worksheet(W, 'admin')
    11251094            sage: S.publisher()
    class Worksheet(object): 
    11311100        """
    11321101        Return True if username is the username of the publisher of this
    11331102        worksheet, assuming this worksheet was published.
    1134        
     1103
    11351104        INPUT:
    1136        
    1137        
     1105
    11381106        -  ``username`` - string
    1139        
    1140        
     1107
    11411108        EXAMPLES::
    1142        
    1143             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1109
     1110            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    11441111            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11451112            sage: P = nb.publish_worksheet(W, 'admin')
    11461113            sage: P.is_publisher('hearst')
    class Worksheet(object): 
    11531120    def has_published_version(self):
    11541121        """
    11551122        Return True if there is a published version of this worksheet.
    1156        
     1123
    11571124        OUTPUT: bool
    1158        
     1125
    11591126        EXAMPLES::
    1160        
    1161             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1127
     1128            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11621129            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11631130            sage: P = nb.publish_worksheet(W, 'admin')
    11641131            sage: P.has_published_version()
    class Worksheet(object): 
    11761143        """
    11771144        Set the published version of this worksheet to be the worksheet
    11781145        with given filename.
    1179        
     1146
    11801147        INPUT:
    1181        
    1182        
     1148
    11831149        -  ``filename`` - string
    1184        
    1185        
     1150
    11861151        EXAMPLES::
    1187        
    1188             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1152
     1153            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    11891154            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    11901155            sage: P = nb.publish_worksheet(W, 'admin')  # indirect test
    11911156            sage: W._Worksheet__published_version
     1157            'pub/1'
     1158            sage: W.set_published_version('pub/0')
     1159            sage: W._Worksheet__published_version
    11921160            'pub/0'
    1193             sage: W.set_published_version('pub/0')
    11941161        """
    11951162        self.__published_version = filename
    11961163
    class Worksheet(object): 
    11981165        """
    11991166        If this worksheet was published, return the published version of
    12001167        this worksheet. Otherwise, raise a ValueError.
    1201        
     1168
    12021169        OUTPUT: a worksheet (or raise a ValueError)
    1203        
     1170
    12041171        EXAMPLES::
    1205        
    1206             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1172
     1173            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12071174            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12081175            sage: P = nb.publish_worksheet(W, 'admin')
    12091176            sage: W.published_version() is P
    12101177            True
    1211         """       
     1178        """
    12121179        try:
    12131180            filename =self.__published_version
    12141181            try:
    class Worksheet(object): 
    12191186                raise ValueError
    12201187        except AttributeError:
    12211188            raise ValueError, "no published version"
    1222                              
     1189
    12231190    def set_worksheet_that_was_published(self, W):
    12241191        """
    12251192        Set the owner and id_number of the worksheet that was
    12261193        published to get self.
    1227        
     1194
    12281195        INPUT:
    12291196
    12301197            - ``W`` -- worksheet or 2-tuple ('owner', id_number)
    12311198
    1232        
    12331199        EXAMPLES::
    1234        
    1235             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1200
     1201            sage: nb = sagenb.notebook.notebook.load_notebook(tmp_dir()+'.sagenb')
    12361202            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12371203            sage: P = nb.publish_worksheet(W, 'admin')
    12381204            sage: P.worksheet_that_was_published() is W
    12391205            True
    1240        
     1206
    12411207        We fake things and make it look like P published itself::
    1242        
     1208
    12431209            sage: P.set_worksheet_that_was_published(P)
    12441210            sage: P.worksheet_that_was_published() is P
    12451211            True
    class Worksheet(object): 
    12531219        """
    12541220        Set the rating on this worksheet by the given user to x and also
    12551221        set the given comment.
    1256        
     1222
    12571223        INPUT:
    1258        
    1259        
     1224
    12601225        -  ``x`` - integer
    1261        
     1226
    12621227        -  ``comment`` - string
    1263        
     1228
    12641229        -  ``username`` - string
    1265        
    1266        
     1230
    12671231        EXAMPLES: We create a worksheet and rate it, then look at the
    1268         ratings.
    1269        
    1270         ::
    1271        
    1272             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1232        ratings.::
     1233
     1234            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    12731235            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    12741236            sage: W.rate(3, 'this is great', 'hilbert')
    12751237            sage: W.ratings()
    12761238            [('hilbert', 3, 'this is great')]
    1277        
     1239
    12781240        Note that only the last rating by a user counts::
    1279        
     1241
    12801242            sage: W.rate(1, 'this lacks content', 'riemann')
    12811243            sage: W.rate(0, 'this lacks content', 'riemann')
    12821244            sage: W.ratings()
    class Worksheet(object): 
    12941256        """
    12951257        Return True is the user with given username has rated this
    12961258        worksheet.
    1297        
     1259
    12981260        INPUT:
    1299        
    1300        
     1261
    13011262        -  ``username`` - string
    1302        
    1303        
     1263
    13041264        OUTPUT: bool
    1305        
     1265
    13061266        EXAMPLES::
    1307        
    1308             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1267
     1268            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13091269            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13101270            sage: W.rate(0, 'this lacks content', 'riemann')
    13111271            sage: W.is_rater('admin')
    class Worksheet(object): 
    13211281    def ratings(self):
    13221282        """
    13231283        Return all the ratings of this worksheet.
    1324        
     1284
    13251285        OUTPUT:
    1326        
    1327        
     1286
    13281287        -  ``list`` - a reference to the list of ratings.
    1329        
    1330        
     1288
    13311289        EXAMPLES::
    1332        
    1333             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1290
     1291            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13341292            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13351293            sage: W.ratings()
    13361294            []
    class Worksheet(object): 
    13501308        r"""
    13511309        Return html that renders to give a summary of how this worksheet
    13521310        has been rated.
    1353        
     1311
    13541312        OUTPUT:
    1355        
    1356        
    1357         -  ``string`` -- a string of HTML as a bunch of table
    1358            rows.
    1359        
    1360        
     1313
     1314        - ``string`` -- a string of HTML as a bunch of table rows.
     1315
    13611316        EXAMPLES::
    1362        
    1363             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1317
     1318            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13641319            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13651320            sage: W.rate(0, 'this lacks content', 'riemann')
    13661321            sage: W.rate(3, 'this is great', 'hilbert')
    class Worksheet(object): 
    13821337    def rating(self):
    13831338        """
    13841339        Return overall average rating of self.
    1385        
     1340
    13861341        OUTPUT: float or the int -1 to mean "not rated"
    1387        
     1342
    13881343        EXAMPLES::
    1389        
    1390             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1344
     1345            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    13911346            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    13921347            sage: W.rating()
    13931348            -1
    class Worksheet(object): 
    14021357        else:
    14031358            rating = float(sum(r))/float(len(r))
    14041359        return rating
    1405        
     1360
    14061361    ##########################################################
    14071362    # Active, trash can and archive
    14081363    ##########################################################
    class Worksheet(object): 
    14101365        """
    14111366        Return True if all users have deleted this worksheet, so we know we
    14121367        can safely purge it from disk.
    1413        
     1368
    14141369        OUTPUT: bool
    1415        
     1370
    14161371        EXAMPLES::
    1417        
    1418             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1372
     1373            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14191374            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    14201375            sage: W.everyone_has_deleted_this_worksheet()
    14211376            False
    class Worksheet(object): 
    14231378            sage: W.everyone_has_deleted_this_worksheet()
    14241379            True
    14251380        """
    1426         for user in self.__collaborators + [self.owner()]:
     1381        for user in self.collaborators() + [self.owner()]:
    14271382            # When the worksheet has been deleted by the owner,
    14281383            # self.owner() returns None, so we have to be careful
    14291384            # about that case.
    14301385            if user is not None and not self.is_trashed(user):
    14311386                return False
    14321387        return True
    1433        
     1388
    14341389    def user_view(self, user):
    14351390        """
    14361391        Return the view that the given user has of this worksheet. If the
    14371392        user currently doesn't have a view set it to ACTIVE and return
    14381393        ACTIVE.
    1439        
     1394
    14401395        INPUT:
    1441        
    1442        
     1396
    14431397        -  ``user`` - a string
    1444        
    1445        
     1398
    14461399        OUTPUT:
    1447        
    1448        
     1400
    14491401        -  ``Python int`` - one of ACTIVE, ARCHIVED, TRASH,
    14501402           which are defined in worksheet.py
    1451        
    1452        
     1403
    14531404        EXAMPLES: We create a new worksheet and get the view, which is
    14541405        ACTIVE::
    1455        
    1456             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1406
     1407            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    14571408            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    14581409            sage: W.user_view('admin')
    14591410            1
    14601411            sage: sagenb.notebook.worksheet.ACTIVE
    14611412            1
    1462        
     1413
    14631414        Now for the admin user we move W to the archive::
    1464        
     1415
    14651416            sage: W.move_to_archive('admin')
    1466        
    1467         The view is now archive.
    1468        
    1469         ::
    1470        
     1417
     1418        The view is now archive.::
     1419
    14711420            sage: W.user_view('admin')
    14721421            0
    14731422            sage: sagenb.notebook.worksheet.ARCHIVED
    14741423            0
    1475        
    1476         For any other random viewer the view is set by default to ACTIVE.
    1477        
    1478         ::
    1479        
     1424
     1425        For any other random viewer the view is set by default to ACTIVE.::
     1426
    14801427            sage: W.user_view('foo')
    14811428            1
    14821429        """
    class Worksheet(object): 
    14971444            d = dict(self.__user_view)
    14981445        except AttributeError:
    14991446            self.user_view(self.owner())
    1500             d = self.__user_view
     1447            d = copy.copy(self.__user_view)
    15011448        for user, val in d.iteritems():
    1502             d[user] = [val]
     1449            if not isinstance(val, list):
     1450                d[user] = [val]
    15031451        return d
    15041452
    15051453    def set_tags(self, tags):
    15061454        """
    1507         Set the tags -- for now we ignore everything except ACTIVE, ARCHIVED, TRASH.
     1455        Set the tags -- for now we ignore everything except ACTIVE,
     1456        ARCHIVED, TRASH.
    15081457
    15091458        INPUT:
    15101459
    class Worksheet(object): 
    15211470    def set_user_view(self, user, x):
    15221471        """
    15231472        Set the view on this worksheet for the given user.
    1524        
     1473
    15251474        INPUT:
    1526        
    1527        
     1475
    15281476        -  ``user`` - a string
    1529        
     1477
    15301478        -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
    15311479           TRASH in worksheet.py
    1532        
    1533        
     1480
    15341481        EXAMPLES::
    1535        
    1536             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1482
     1483            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15371484            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    15381485            sage: W.set_user_view('admin', sagenb.notebook.worksheet.ARCHIVED)
    15391486            sage: W.user_view('admin') == sagenb.notebook.worksheet.ARCHIVED
    class Worksheet(object): 
    15551502    def user_view_is(self, user, x):
    15561503        """
    15571504        Return True if the user view of user is x.
    1558        
     1505
    15591506        INPUT:
    1560        
    1561        
     1507
    15621508        -  ``user`` - a string
    1563        
     1509
    15641510        -  ``x`` - int, one of the variables ACTIVE, ARCHIVED,
    15651511           TRASH in worksheet.py
    1566        
    1567        
     1512
    15681513        EXAMPLES::
    1569        
    1570             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1514
     1515            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15711516            sage: W = nb.create_new_worksheet('Publish Test', 'admin')
    15721517            sage: W.user_view_is('admin', sagenb.notebook.worksheet.ARCHIVED)
    15731518            False
    class Worksheet(object): 
    15751520            True
    15761521        """
    15771522        return self.user_view(user) == x
    1578                
     1523
    15791524    def is_archived(self, user):
    15801525        """
    15811526        Return True if this worksheet is archived for the given user.
    1582        
     1527
    15831528        INPUT:
    1584        
    1585        
     1529
    15861530        -  ``user`` - string
    1587        
    1588        
     1531
    15891532        OUTPUT: bool
    1590        
     1533
    15911534        EXAMPLES::
    1592        
    1593             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1535
     1536            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    15941537            sage: W = nb.create_new_worksheet('Archived Test', 'admin')
    15951538            sage: W.is_archived('admin')
    15961539            False
    class Worksheet(object): 
    16031546    def is_active(self, user):
    16041547        """
    16051548        Return True if this worksheet is active for the given user.
    1606        
     1549
    16071550        INPUT:
    1608        
    1609        
     1551
    16101552        -  ``user`` - string
    1611        
    1612        
     1553
    16131554        OUTPUT: bool
    1614        
     1555
    16151556        EXAMPLES::
    1616        
    1617             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1557
     1558            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16181559            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    16191560            sage: W.is_active('admin')
    16201561            True
    class Worksheet(object): 
    16271568    def is_trashed(self, user):
    16281569        """
    16291570        Return True if this worksheet is in the trash for the given user.
    1630        
     1571
    16311572        INPUT:
    1632        
    1633        
     1573
    16341574        -  ``user`` - string
    1635        
    1636        
     1575
    16371576        OUTPUT: bool
    1638        
     1577
    16391578        EXAMPLES::
    1640        
    1641             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1579
     1580            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16421581            sage: W = nb.create_new_worksheet('Trash Test', 'admin')
    16431582            sage: W.is_trashed('admin')
    16441583            False
    class Worksheet(object): 
    16511590    def move_to_archive(self, user):
    16521591        """
    16531592        Move this worksheet to be archived for the given user.
    1654        
     1593
    16551594        INPUT:
    1656        
    1657        
     1595
    16581596        -  ``user`` - string
    1659        
    1660        
     1597
    16611598        EXAMPLES::
    1662        
    1663             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1599
     1600            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16641601            sage: W = nb.create_new_worksheet('Archive Test', 'admin')
    16651602            sage: W.move_to_archive('admin')
    16661603            sage: W.is_archived('admin')
    class Worksheet(object): 
    16711608    def set_active(self, user):
    16721609        """
    16731610        Set his worksheet to be active for the given user.
    1674        
     1611
    16751612        INPUT:
    1676        
    1677        
     1613
    16781614        -  ``user`` - string
    1679        
    1680        
     1615
    16811616        EXAMPLES::
    1682        
    1683             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1617
     1618            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    16841619            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    16851620            sage: W.move_to_archive('admin')
    16861621            sage: W.is_active('admin')
    class Worksheet(object): 
    16941629    def move_to_trash(self, user):
    16951630        """
    16961631        Move this worksheet to the trash for the given user.
    1697        
     1632
    16981633        INPUT:
    1699        
    1700        
     1634
    17011635        -  ``user`` - string
    1702        
    1703        
     1636
    17041637        EXAMPLES::
    1705        
    1706             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1638
     1639            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17071640            sage: W = nb.create_new_worksheet('Trash Test', 'admin')
    17081641            sage: W.move_to_trash('admin')
    17091642            sage: W.is_trashed('admin')
    class Worksheet(object): 
    17141647    def move_out_of_trash(self, user):
    17151648        """
    17161649        Exactly the same as set_active(user).
    1717        
     1650
    17181651        INPUT:
    1719        
    1720        
     1652
    17211653        -  ``user`` - string
    1722        
    1723        
     1654
    17241655        EXAMPLES::
    1725        
    1726             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1656
     1657            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17271658            sage: W = nb.create_new_worksheet('Active Test', 'admin')
    17281659            sage: W.move_to_trash('admin')
    17291660            sage: W.is_active('admin')
    class Worksheet(object): 
    17331664            True
    17341665        """
    17351666        self.set_active(user)
    1736        
     1667
    17371668    #############
    17381669
    17391670    def delete_cells_directory(self):
    17401671        r"""
    17411672        Delete the directory in which all the cell computations occur.
    1742        
     1673
    17431674        EXAMPLES::
    1744        
    1745             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1675
     1676            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    17461677            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    17471678            sage: W = nb.create_new_worksheet('Test', 'sage')
    1748             sage: W.edit_save('Sage\n{{{\n3^20\n}}}')
     1679            sage: W.edit_save('{{{\n3^20\n}}}')
     1680            sage: W.cell_list()[0].evaluate()
     1681            sage: W.check_comp()    # random output -- depends on computer speed
    17491682            sage: sorted(os.listdir(W.directory()))
    1750             ['cells', 'snapshots']
    1751             sage: W.cell_list()[0].evaluate()
     1683            ['cells', 'data']
     1684            sage: W.save_snapshot('admin')
    17521685            sage: sorted(os.listdir(W.directory()))
    1753             ['cells', 'data', 'snapshots']
     1686            ['cells', 'data', 'snapshots', 'worksheet.html']
    17541687            sage: W.delete_cells_directory()
    17551688            sage: sorted(os.listdir(W.directory()))
    1756             ['data', 'snapshots']
     1689            ['data', 'snapshots', 'worksheet.html']
     1690            sage: W.quit()
     1691            sage: nb.delete()
    17571692        """
    17581693        dir = self.cells_directory()
    17591694        if os.path.exists(dir):
    class Worksheet(object): 
    17761711
    17771712    def set_owner(self, owner):
    17781713        self.__owner = owner
    1779         if not owner in self.__collaborators:
     1714        if not owner in self.collaborators():
    17801715            self.__collaborators.append(owner)
    17811716
    17821717    def is_only_viewer(self, user):
    class Worksheet(object): 
    17921727            return True
    17931728
    17941729    def is_collaborator(self, user):
    1795         try:
    1796             return user in self.__collaborators
    1797         except AttributeError:
    1798             return True
     1730        return user in self.collaborators()
    17991731
    18001732    def user_can_edit(self, user):
    18011733        """
    18021734        Return True if the user with given name is allowed to edit this
    18031735        worksheet.
    1804        
     1736
    18051737        INPUT:
    1806        
    1807        
     1738
    18081739        -  ``user`` - string
    1809        
    1810        
     1740
    18111741        OUTPUT: bool
    1812        
    1813         EXAMPLES: We create a notebook with one worksheet and two users.
    1814        
    1815         ::
    1816        
    1817             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1742
     1743        EXAMPLES: We create a notebook with one worksheet and two users.::
     1744
     1745            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    18181746            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    18191747            sage: nb.add_user('william', 'william', 'wstein@sagemath.org', force=True)
    18201748            sage: W = nb.create_new_worksheet('Test', 'sage')
    18211749            sage: W.user_can_edit('sage')
    18221750            True
    1823        
     1751
    18241752        At first the user 'william' can't edit this worksheet::
    1825        
     1753
    18261754            sage: W.user_can_edit('william')
    18271755            False
    1828        
     1756
    18291757        After adding 'william' as a collaborator he can edit the
    1830         worksheet.
    1831        
    1832         ::
    1833        
     1758        worksheet.::
     1759
    18341760            sage: W.add_collaborator('william')
    18351761            sage: W.user_can_edit('william')
    18361762            True
    1837        
     1763
    18381764        Clean up::
    1839        
     1765
    18401766            sage: nb.delete()
    18411767        """
    18421768        return self.is_collaborator(user) or self.is_owner(user)
    1843        
     1769
    18441770    def delete_user(self, user):
    18451771        """
    18461772        Delete a user from having any view or ownership of this worksheet.
    1847        
     1773
    18481774        INPUT:
    1849        
    1850        
     1775
    18511776        -  ``user`` - string; the name of a user
    1852        
    1853        
     1777
    18541778        EXAMPLES: We create a notebook with 2 users and 1 worksheet that
    1855         both view.
    1856        
    1857         ::
    1858        
    1859             sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir())
     1779        both view.::
     1780
     1781            sage: nb = sagenb.notebook.notebook.Notebook(tmp_dir()+'.sagenb')
    18601782            sage: nb.add_user('wstein','sage','wstein@sagemath.org',force=True)
    18611783            sage: nb.add_user('sage','sage','sage@sagemath.org',force=True)
    18621784            sage: W = nb.new_worksheet_with_title_from_text('Sage', owner='sage')
    class Worksheet(object): 
    18651787            'sage'
    18661788            sage: W.viewers()
    18671789            ['wstein']
    1868        
     1790
    18691791        We delete the sage user from the worksheet W. This makes wstein the
    1870         new owner.
    1871        
    1872         ::
    1873        
     1792        new owner.::
     1793
    18741794            sage: W.delete_user('sage')
    18751795            sage: W.viewers()
    18761796            ['wstein']
    18771797            sage: W.owner()
    18781798            'wstein'
    1879        
     1799