'[fdZddlZddlmZmZmZmZmZGddeZGddZ dZ e d kr e dSdS) zC Tkinter widgets for displaying multi-column listboxes and tables. N)FrameLabelListbox ScrollbarTkc eZdZdZedddZeddddd Zedd d d dd d ZdifdZdZ dZ dZ e dZ e dZe dZdZdZdZd9dZifdZdZifdZifdZd:dZd Zd:d!Zd"Zd#Zd$Zd;d%Zd;d&Zd;d'Z d(Z!d)Z"d*Z#d+Z$d,Z%d-Z&d.Z'd/Z(d0Z)d1Z*d2Z+d3Z,d4Z-d5Z.d6Z/d7Z0d8Z1eZ2eZ3eZ4e,Z5e-Z6e"Z7e.Z8dS)< MultiListboxa A multi-column listbox, where the current selection applies to an entire row. Based on the MultiListbox Tkinter widget recipe from the Python Cookbook (https://code.activestate.com/recipes/52266/) For the most part, ``MultiListbox`` methods delegate to its contained listboxes. For any methods that do not have docstrings, see ``Tkinter.Listbox`` for a description of what that method does. z#888T) background takefocushighlightthicknessraisedzhelvetica -16 boldz#444white) borderwidthrelieffontr foregroundrFnone)rselectborderwidthr exportselectionselectbackground activestyler Nc t|trtt|}d}nd}t |dkrt dt |_g_g_ |dgt |z}n/t |t |krt d|_ tj |fij ddtjD]\}}||||rOt#fd |ij} j | | |dd dd || _t-fij} j| | |dd dd || _| d j| d j| dfd| dfd| dfd| dfd| dfd| dd| d jd jdfddfddfdd fd!j|fi|dS)"a Construct a new multi-column listbox widget. :param master: The widget that should contain the new multi-column listbox. :param columns: Specifies what columns should be included in the new multi-column listbox. If ``columns`` is an integer, then it is the number of columns to include. If it is a list, then its length indicates the number of columns to include; and each element of the list will be used as a label for the corresponding column. :param cnf, kw: Configuration parameters for this widget. Use ``label_*`` to configure all labels; and ``listbox_*`` to configure all listboxes. E.g.: >>> root = Tk() # doctest: +SKIP >>> MultiListbox(root, ["Subject", "Sender", "Date"], label_foreground='red').pack() # doctest: +SKIP FTrzExpected at least one columnNr z*Expected one column_weight for each columnweighttextnewscolumnrowstickypadxpady z z c.dS)N_scrolleselfs C/var/www/piapp/venv/lib/python3.11/site-packages/nltk/draw/table.pyz'MultiListbox.__init__..DLL,<,<z c.dS)Nr r'r)s r,r-z'MultiListbox.__init__..r.r/z c8|jSN)r(deltar)s r,r-z'MultiListbox.__init__..sdll17.C.Cr/z cD|j|jSr2) scan_markxyr)s r,r-z'MultiListbox.__init__..sDNN13,D,Dr/z cD|j|jSr2) scan_dragtor6r7r)s r,r-z'MultiListbox.__init__..sT-=-=ac13-G-Gr/z cdS)Nbreak)r*s r,r-z'MultiListbox.__init__..sGr/zc0dS)Nr&r3selectr)s r,r-z'MultiListbox.__init__..sDKKbK$9$9r/zc0dS)Nr r>r?r)s r,r-z'MultiListbox.__init__..sdkkk&:&:r/zcV SNr>r@ _pagesizer)s r,r-z'MultiListbox.__init__..s"t{{$..:J:J9J{'K'Kr/zcTSrCrDr)s r,r-z'MultiListbox.__init__..sdkk8H8Hk&I&Ir/) isinstanceintlistrangelen ValueErrortuple _column_names _listboxes_labels_column_weightsr__init__ FRAME_CONFIGgrid_rowconfigure enumerategrid_columnconfigurer LABEL_CONFIGappendgrid column_indexrLISTBOX_CONFIGbind_select_resize_column configure) r+mastercolumnscolumn_weightscnfkwinclude_labelsilabelllbs ` r,rRzMultiListbox.__init__>s* gs # # "5>>**G"NN!N w<<1  ;<< <#7^^   !S3w<</NN  CLL 0 0IJJ J- tV99t'8999 q+++!$"455 7 7HAu  % %aq0A % B B B #$@@U@d.?@@ ##A&&&aQvAAFFF!"55!455B O " "2 & & & GG1!FG C C CBO GGL$, / / / GGM4< 0 0 0 GGL"<"<"<"< = = = GGL"<"<"<"< = = = GGN$C$C$C$C D D D GGL"D"D"D"D E E E GGM#G#G#G#G H H H GGL"3"3 4 4 4 GGL$"5 6 6 6 6 , 3444 &9999::: (::::;;; )KKKKLLL (IIIIJJJ s!!b!!!!!r/c|jdrdSd|_|j|urdt|jD]N\}}t |j||zz dkr||_Onf|j|jdz kr|jj |_n/|jdkr$|jj dkr|jj dz |_|jJ|jd|j |jd |j z|j d SdS) z Callback used to resize a column of the table. Return ``True`` if the column is actually getting resized (if the user clicked on the far left or far right 5 pixels of a label); and ``False`` otherwies. zFN rr T) widgetr\_resize_column_indexrUrOabsr6winfo_x winfo_widthrZ_resize_column_motion_cbnum_resize_column_buttonrelease_cb)r+eventrfris r,r^zMultiListbox._resize_columnsN <  . / / 5%)! <4  "4?33 2 22uw"**,,1A1A"ABCCbHH01D- 2W 0022Q6 7 7(- (AD % % Wq[[U\6!;;(- (AA(ED %  $ 0 L  j$*G H H H L  $uy0$2V   45r/c<|j|j}||dz }|j|jz}||z}t d|d||z |zz|d<dS)Nwidth)rOrprsr6rorrmax)r+rwri charwidthx1x2s r,rtz%MultiListbox._resize_column_motion_cbs _T6 7NN$$r'{2 Wu|++-- - ZZ\\BNN,, ,!R[BG +AABB7 r/c~|jd|jz|jddS)Nrnrm)rounbindru)r+rws r,rvz,MultiListbox._resize_column_buttonrelease_cbs< 059<=== J'''''r/c|jS)zh A tuple containing the names of the columns used by this multi-column listbox. )rNr+s r, column_nameszMultiListbox.column_namess !!r/c*t|jS)a A tuple containing the ``Tkinter.Label`` widgets used to display the label of each column. If this multi-column listbox was created without labels, then this will be an empty tuple. These widgets will all be augmented with a ``column_index`` attribute, which can be used to determine which column they correspond to. This can be convenient, e.g., when defining callbacks for bound events. )rMrPrs r, column_labelszMultiListbox.column_labelssT\"""r/c*t|jS)aY A tuple containing the ``Tkinter.Listbox`` widgets used to display individual columns. These widgets will all be augmented with a ``column_index`` attribute, which can be used to determine which column they correspond to. This can be convenient, e.g., when defining callbacks for bound events. )rMrOrs r, listboxeszMultiListbox.listboxessT_%%%r/c|j|j}|dd|||||dS)Nrend)ronearestr7selection_clear selection_setactivatefocus)r+r*rfs r,r]zMultiListbox._selectsf H  QS ! ! Q&&& 1 a r/cF|jD]}||ddS)Nunitr;rO yview_scroll)r+r3ris r,r(zMultiListbox._scrolls// + +B OOE6 * * * *wr/ct|dt|dz S)z2:return: The number of rows that makes up one pagez @0,1000000z@0,0)rHindexrs r,rEzMultiListbox._pagesizes54::l++,,s4::f3E3E/F/FFFr/c||td|Ut|dkrd|z}n*t|d|z}|dd|at t |d|dz }|||r| |dSdSdS)a Set the selected row. If ``index`` is specified, then select row ``index``. Otherwise, if ``delta`` is specified, then move the current selection by ``delta`` (negative numbers for up, positive numbers for down). This will not move the selection past the top or the bottom of the list. :param see: If true, then call ``self.see()`` with the newly selected index, to ensure that it is visible. Nz$specify index or delta, but not bothrr&rr ) rLrK curselectionrHrminr{sizerseer+rr3rs r,r@zMultiListbox.selects  E$5CDD D  4$$&&''1,,U D--//233e; Q&&&  E1 tyy{{Q77E   u % % %     r/c rtt|t|z}t|D]\}}|ds|dr*|jD]!}||dd|i"Y|ds|dr*|jD]!}||dd|i"tj|||idS)a Configure this widget. Use ``label_*`` to configure all labels; and ``listbox_*`` to configure all listboxes. E.g.: >>> master = Tk() # doctest: +SKIP >>> mlb = MultiListbox(master, 5) # doctest: +SKIP >>> mlb.configure(label_foreground='red') # doctest: +SKIP >>> mlb.configure(listbox_foreground='red') # doctest: +SKIP label_zlabel-Nlistbox_zlistbox-)dictrIitems startswithrPr_rOr)r+rcrdkeyvalrglistboxs r,r_zMultiListbox.configure*s<4 $$tBHHJJ'7'7788syy{{++ 2 2JS#~~h'' 23>>(+C+C 2!\44EOOSWcN33334 ++ 2s~~j/I/I 2#66G%%s122wn55556sCj1111 2 2r/c4|||idS)z| Configure this widget. This is equivalent to ``self.configure({key,val``)}. See ``configure()``. N)r_)r+rrs r, __setitem__zMultiListbox.__setitem__?s Sz"""""r/c 8|jD]}|j||fi|dS)z Configure all table cells in the given row. Valid keyword arguments are: ``background``, ``bg``, ``foreground``, ``fg``, ``selectbackground``, ``selectforeground``. NrO itemconfigure)r+ row_indexrcrdris r, rowconfigurezMultiListbox.rowconfigureFs? / 3 3B B Y 2 2r 2 2 2 2 3 3r/c |j|}tt|t|z}t|D]]\}}|dvr=t |D]}||||iF|||i^dS)z Configure all table cells in the given column. Valid keyword arguments are: ``background``, ``bg``, ``foreground``, ``fg``, ``selectbackground``, ``selectforeground``. )r bgrfgrselectforegroundN)rOrrIrrJrrr_)r+ col_indexrcrdrirrrfs r,columnconfigurezMultiListbox.columnconfigureOs _Y '4 $$tBHHJJ'7'7788syy{{++ ) )JS#rwwyy))44A$$Qc 33334 c3Z(((( ) )r/c :|j|}|j||fi|S)z Configure the table cell at the given row and column. Valid keyword arguments are: ``background``, ``bg``, ``foreground``, ``fg``, ``selectbackground``, ``selectforeground``. r)r+rrrcrdris r,rzMultiListbox.itemconfigurefs- _Y 'r 355"555r/c|D]6}t|t|jkrtd7t|jt t|D]\}}|j|g|RdS)a0 Insert the given row or rows into the table, at the given index. Each row value should be a tuple of cell values, one for each column in the row. Index may be an integer or any of the special strings (such as ``'end'``) accepted by ``Tkinter.Listbox``. zDrows should be tuples whose length is equal to the number of columnsN)rKrNrLziprOrIinsert)r+rrowseltrieltss r,rzMultiListbox.insertss  C3xx3t12222 83 dotCJ/?/?@@ $ $JR BIe #d # # # # # $ $r/cvfd|jD}rdt|DSt|S)a Return the value(s) of the specified row(s). If ``last`` is not specified, then return a single row value; otherwise, return a list of row values. Each row value is a tuple of cell values, one for each column in the row. c<g|]}|Sr<)get).0rifirstlasts r, z$MultiListbox.get..s'@@@""&&%%@@@r/c,g|]}t|Sr<)rMrr s r,rz$MultiListbox.get..s7773E#JJ777r/)rOrrM)r+rrvaluess `` r,rzMultiListbox.getsQA@@@@@@@  !77#v,777 7== r/c8|d|\}}}}|j||\}}}} t|t|zt|t|zt|t| fS)z Return the bounding box for the given table cell, relative to this widget's top-left corner. The bounding box is a tuple of integers ``(left, top, width, height)``. r)r r) grid_bboxrObboxrH) r+r coldxdy_r6r7whs r,rzMultiListbox.bboxs ~~!C~88 B1_S)..s33 1a1vvBQ#b''!13q663q66AAr/c|jr|j||j|||ddS)a1 Hide the given column. The column's state is still maintained: its values will still be returned by ``get()``, and you must supply its values when calling ``insert()``. It is safe to call this on a column that is already hidden. :see: ``show_column()`` rrN)rP grid_forgetrrV)r+rs r, hide_columnzMultiListbox.hide_columns_ < 2 L # / / 1 1 1 y!--/// !!)A!66666r/c|j|}|jr%|j||dddd|j||dddd|||dS)z Display a column that has been hidden using ``hide_column()``. It is safe to call this on a column that is not hidden. rrrr rN)rQrPrYrOrV)r+rrs r, show_columnzMultiListbox.show_columns %i0 <  L # ( ( aQQ )     "''!F (    !!)F!;;;;;r/c2fd|jDS)aK Add a binding to each ``Tkinter.Label`` widget in this mult-column listbox that will call ``func`` in response to the event sequence. :return: A list of the identifiers of replaced binding functions (if any), allowing for their deletion (to prevent a memory leak). c>g|]}|Sr<)r\)rrgaddfuncsequences r,rz/MultiListbox.bind_to_labels..s)PPPE 8T3//PPPr/)rr+rrrs ```r,bind_to_labelszMultiListbox.bind_to_labelss+QPPPPPT=OPPPPr/cH|jD]}||||dS)aM Add a binding to each ``Tkinter.Listbox`` widget in this mult-column listbox that will call ``func`` in response to the event sequence. :return: A list of the identifiers of replaced binding functions (if any), allowing for their deletion (to prevent a memory leak). N)rr\)r+rrrrs r,bind_to_listboxeszMultiListbox.bind_to_listboxess8~ . .G LL4 - - - - . .r/c`||||||||zS)ac Add a binding to each ``Tkinter.Label`` and ``Tkinter.Listbox`` widget in this mult-column listbox that will call ``func`` in response to the event sequence. :return: A list of the identifiers of replaced binding functions (if any), allowing for their deletion (to prevent a memory leak). )rrrs r,bind_to_columnszMultiListbox.bind_to_columnss<""8T377$:P:P dC; ;   r/c2|jdj|i|SNr)rOrr+argskwargss r,rzMultiListbox.curselections!.tq!.????r/c2|jdj|i|Sr)rOselection_includesrs r,rzMultiListbox.selection_includess!4tq!4dEfEEEr/c2|jdj|i|Sr)rOitemcgetrs r,rzMultiListbox.itemcgets!*tq!*D;F;;;r/c2|jdj|i|Sr)rOrrs r,rzMultiListbox.sizes!&tq!&7777r/c2|jdj|i|Sr)rOrrs r,rzMultiListbox.indexs!'tq!'8888r/c2|jdj|i|Sr)rOrrs r,rzMultiListbox.nearests!)tq!)4:6:::r/c4|jD]}|j|i|dSr2)rOrr+rrris r,rzMultiListbox.activates7/ ) )B BK ( ( ( ( ( ) )r/c4|jD]}|j|i|dSr2)rOdeleters r,rzMultiListbox.deletes7/ ' 'B BIt &v & & & & ' 'r/c4|jD]}|j|i|dSr2)rOr5rs r,r5zMultiListbox.scan_marks7/ * *B BL$ )& ) ) ) ) * *r/c4|jD]}|j|i|dSr2)rOr9rs r,r9zMultiListbox.scan_dragto s7/ , ,B BND +F + + + + , ,r/c4|jD]}|j|i|dSr2)rOrrs r,rzMultiListbox.sees7/ $ $B BFD #F # # # # $ $r/c4|jD]}|j|i|dSr2)rOselection_anchorrs r,rzMultiListbox.selection_anchors8/ 1 1B B  0 0 0 0 0 1 1r/c4|jD]}|j|i|dSr2)rOrrs r,rzMultiListbox.selection_clears8/ 0 0B B  / / / / / 0 0r/c4|jD]}|j|i|dSr2)rOrrs r,rzMultiListbox.selection_sets8/ . .B B d -f - - - - . .r/c4|jD]}|j|i|}|Sr2)rOyview)r+rrrivs r,rzMultiListbox.yviews0/ * *B$)&))AAr/c4|jD]}|j|i|dSr2)rO yview_movetors r,rzMultiListbox.yview_moveto$7/ - -B BOT ,V , , , , - -r/c4|jD]}|j|i|dSr2rrs r,rzMultiListbox.yview_scroll(rr/NNTr2NNN)9__name__ __module__ __qualname____doc__rrSrWr[rRr^rtrvpropertyrrrr]r(rEr@r_rrrrrrrrrrrrrrrrrrrrr5r9rrrrrrr itemconfig rowconfig columnconfig select_anchor select_clearselect_includes select_setr<r/r,r r s46TaPPPL4 ! LTN8<X"X"X"X"|BCCC(((""X" # #X #&&X& GGG    H2222*###+-3333.0)))).6666$$$" ! ! ! !BBB 7 7 7 < < <& Q Q Q Q . . . .     &@@@FFF<<<888999;;;)))'''***,,,$$$111000... ------JI"L$M"L(OJJJr/r c$eZdZdZdddddifdZdZdZdZd'dZifd Z ifd Z d(d Z d'd Z d'd Z d'dZe Ze Ze ZdZdZdZdZdZdZdZdZdZedZdZdZdZdZ d)dZ!d*dZ"d Z#d+d!Z$d"Z%d,d$Z&d-d%Z'd#Z( d&Z)dS).Tablea A display widget for a table of values, based on a ``MultiListbox`` widget. For many purposes, ``Table`` can be treated as a list-of-lists. E.g., table[i] is a list of the values for row i; and table.append(row) adds a new row with the given list of values. Individual cells can be accessed using table[i,j], which refers to the j-th column of the i-th row. This can be used to both read and write values from the table. E.g.: >>> table[i,j] = 'hello' # doctest: +SKIP The column (j) can be given either as an index number, or as a column name. E.g., the following prints the value in the 3rd row for the 'First Name' column: >>> print(table[3, 'First Name']) # doctest: +SKIP John You can configure the colors for individual rows, columns, or cells using ``rowconfig()``, ``columnconfig()``, and ``itemconfig()``. The color configuration for each row will be preserved if the table is modified; however, when new rows are added, any color configurations that have been made for *columns* will not be applied to the new row. Note: Although ``Table`` acts like a widget in some ways (e.g., it defines ``grid()``, ``pack()``, and ``bind()``), it is not itself a widget; it just contains one. This is because widgets need to define ``__getitem__()``, ``__setitem__()``, and ``__nonzero__()`` in a way that's incompatible with the fact that ``Table`` behaves as a list-of-lists. :ivar _mlb: The multi-column listbox used to display this table's data. :ivar _rows: A list-of-lists used to hold the cell values of this table. Each element of _rows is a row value, i.e., a list of cell values, one for each column in the row. NTc  t||_||_t||_dt |D|_|g|_nd|D|_|jD]} || t|j|||fi| |_ |j ddd|rYt|jd|j j } | j|j jd d <| d d | |_d|_|r:t |j jD] \} } | d|j!|dS)a Construct a new Table widget. :type master: Tkinter.Widget :param master: The widget that should contain the new table. :type column_names: list(str) :param column_names: A list of names for the columns; these names will be used to create labels for each column; and can be used as an index when reading or writing cell values from the table. :type rows: list(list) :param rows: A list of row values used to initialize the table. Each row value should be a tuple of cell values, one for each column in the row. :type scrollbar: bool :param scrollbar: If true, then create a scrollbar for the new table widget. :type click_to_sort: bool :param click_to_sort: If true, then create bindings that will sort the table's rows by a given column's values if the user clicks on that colum's label. :type reprfunc: function :param reprfunc: If specified, then use this function to convert each table cell value to a string suitable for display. ``reprfunc`` has the following signature: reprfunc(row_index, col_index, cell_value) -> str (Note that the column is specified by index, not by name.) :param cnf, kw: Configuration parameters for this widget's contained ``MultiListbox``. See ``MultiListbox.__init__()`` for details. ci|]\}}|| Sr<r<)rrfcs r, z"Table.__init__..s%Q%Q%Qv1a%Q%Q%Qr/Nc&g|]}d|DS)cg|]}|Sr<r<)rrs r,rz-Table.__init__...s***1***r/r<rs r,rz"Table.__init__..s';;;s**c***;;;r/leftTboth)sideexpandfillvertical)orientcommandryscrollcommandrightr7)rrr$)rK _num_columns _reprfuncr_framerU_column_name_to_index_rows _checkrowr _mlbpackrrsetr _scrollbar_sortkeyrr\_sort _fill_table)r+r`rrrb scrollbar click_to_sortreprfuncrcrdr sbrfrhs r,rRzTable.__init__lsV --!Fmm %Q%Q<9P9P%Q%Q%Q" <DJJ;;d;;;DJ:  C NN3    !lNCVVSUVV  F4f===  !4;z49?SSSB79vDI  "#3 4 GGsG + + + DO  1!$)"9:: 1 11|TZ0000 r/c*|jj|i|dS)zrPosition this table's main frame widget in its parent widget. See ``Tkinter.Frame.pack()`` for more info.N)rr"rs r,r"z Table.pack$  $)&)))))r/c*|jj|i|dS)zrPosition this table's main frame widget in its parent widget. See ``Tkinter.Frame.grid()`` for more info.N)rrYrs r,rYz Table.gridr-r/c8|jdS)z-Direct (keyboard) input foxus to this widget.N)r!rrs r,rz Table.focuss r/c>|j|||dS)zkAdd a binding to this table's main frame that will call ``func`` in response to the event sequence.N)r!r\rs r,r\z Table.binds" xs+++++r/c .|jj||fi|dS)z%:see: ``MultiListbox.rowconfigure()``N)r!r)r+rrcrds r,rzTable.rowconfigures' y#4444444r/c X||}|jj||fi|dS)z(:see: ``MultiListbox.columnconfigure()``N)rZr!r)r+rrcrds r,rzTable.columnconfigures:%%i00 ! !)S77B77777r/c V||}|jj|||fi|S)z&:see: ``MultiListbox.itemconfigure()``)rZr!r)r+rrrcrds r,rzTable.itemconfigures6%%i00 &ty&y)SGGBGGGr/c:|j|||S)z':see: ``MultiListbox.bind_to_labels()``)r!rrs r,rzTable.bind_to_labelssy''$<<.s:4:Qy!Q//r/)r rrrrUr!_DEBUG_check_table_vs_mlb)r+rrowvalues`` r,rz Table.inserts x    )X... > %>G>Q>QH H--- ; '  $ $ & & & & & ' 'r/ct|D]}|||jr|dSdS)z Add new rows at the end of the table. :param rowvalues: A list of row values used to initialize the table. Each row value should be a tuple of cell values, one for each column in the row. N)rXr;r<)r+ rowvaluesr=s r,extendz Table.extend sT" " "H KK ! ! ! ! ; '  $ $ & & & & & ' 'r/c|t|j||jr|dSdS)z Add a new row to the end of the table. :param rowvalue: A tuple of cell values, one for each column in the new row. N)rrKrr;r<r+r=s r,rXz Table.appendsL C OOX... ; '  $ $ & & & & & ' 'r/cg|_|jdd|jr|dSdS)z0 Delete all rows in this table. rrN)rr!rr;r<rs r,clearz Table.clear!sO  E""" ; '  $ $ & & & & & ' 'r/c2t|trtdt|trEt |dkr2|j|d||dSt|j|S)a Return the value of a row or a cell in this table. If ``index`` is an integer, then the row value for the ``index``th row. This row value consists of a tuple of cell values, one for each column in the row. If ``index`` is a tuple of two integers, ``(i,j)``, then return the value of the cell in the ``i``th row and the ``j``th column. Slicing not supportedrr )rGslicerLrMrKrrZ)r+rs r, __getitem__zTable.__getitem__*s eU # # ,455 5 u % % ,#e**//:eAh'(9(9%((C(CD DE*++ +r/cttrtdttrt dkr̉dd}}|g}|j||<j|||}j j | ||j j | |dz |dSg}|t|j<jfdt!|D}j |j dz |dS)a Replace the value of a row or a cell in this table with ``val``. If ``index`` is an integer, then ``val`` should be a row value (i.e., a tuple of cell values, one for each column). In this case, the values of the ``index``th row of the table will be replaced with the values in ``val``. If ``index`` is a tuple of integers, ``(i,j)``, then replace the value of the cell in the ``i``th row and ``j``th column with ``val``. rFrGrr NcDg|]\}}||Sr<r9)rr:rrr+s r,rz%Table.__setitem__..\s-PPPv1t~~eQ22PPPr/)rGrHrLrMrKrZ_save_config_inforrr!rrr_restore_config_infor rIrU)r+rrrfr: config_cookies`` r,rzTable.__setitem__:s eU # # 5455 5u % % 5#e**//8T..uQx88qA 22A377M"DJqM! ~)nnQ3// I  " ) )!S 1 1 1 I  " ) )!a% 0 0 0  % %m 4 4 4 4 4!22E7;;M NN3    $S DJu ~)PPPPP3PPP I  UC ( ( ( I  UQY ' ' '  % %m 4 4 4 4 4r/c:t|trtdt|tr"t |dkrtd|j|=|j||jr| dSdS)zA Delete the ``row_index``th row from this table. rFrGzCannot delete a single cell!N) rGrHrLrMrKrr!rr;r<)r+rs r, __delitem__zTable.__delitem__as i ' ' 6455 5 i ' ' =C NNa,?,?;<< < Jy ! ### ; '  $ $ & & & & & ' 'r/c*t|jS)z< :return: the number of rows in this table. )rKrrs r,__len__z Table.__len__ns4:r/ct||jkr'td|t||jfzdS)z Helper function: check that a given row value has the correct number of elements; and if not, raise an exception. z"Row %r has %d columns; expected %dN)rKrrLrBs r,r zTable._checkrowtsM x==D- - -4S]]D,=>?  . -r/c|jjS)z1A list of the names of the columns in this table.)r!rrs r,rzTable.column_namessy%%r/ctt|trd|cxkr |jkrnn|S|j|S)z If ``i`` is a valid column index integer, then return it as is. Otherwise, check if ``i`` is used as the name for any column; if so, return that column's index. Otherwise, raise a ``KeyError`` exception. r)rGrHrr)r+rfs r,rZzTable.column_indexsO a   1!q"<"<"<"<4+<"<"<"<"<"<H-a0 0r/c`|j||dS)z$:see: ``MultiListbox.hide_column()``N)r!rrZr+rZs r,rzTable.hide_column, d// ==>>>>>r/c`|j||dS)z$:see: ``MultiListbox.show_column()``N)r!rrZrWs r,rzTable.show_columnrXr/cf|j}|rt|dSdS)z Return the index of the currently selected row, or None if no row is selected. To get the row value itself, use ``table[table.selected_row()]``. rN)r!rrH)r+sels r, selected_rowzTable.selected_rows4 i$$&&  s1v;; 4r/c>|j|||dS)z:see: ``MultiListbox.select()``N)r!r@rs r,r@z Table.selects" s+++++r/togglec|dvrtd||}|d}|dkr%||jkr|jn9|jtj||dk||_| | |dd|j r| d Sd S) a Sort the rows in this table, using the specified column's values as a sort key. :param column_index: Specifies which column to sort, using either a column index (int) or a column's label name (str). :param order: Specifies whether to sort the values in ascending or descending order: - ``'ascending'``: Sort from least to greatest. - ``'descending'``: Sort from greatest to least. - ``'toggle'``: If the most recent call to ``sort_by()`` sorted the table by the same column (``column_index``), then reverse the rows; otherwise sort in ascending order. ) ascending descendingr^zBsort_by(): order should be "ascending", "descending", or "toggle".T) index_by_idr^ra)rreverse)rbrN) rLrZrLr%rrcsortoperator itemgetterr'rMr;r<)r+rZorderrNs r,sort_byz Table.sort_bys& = = =W ((66 ..4.@@  H  !>!> J   JOO' 55@U    )DM  !!-Tt!LLL ; '  $ $ & & & & & ' 'r/c|jj}|j|rdS||dS)zLEvent handler for clicking on a column label -- sort by that column.continue)rorZr!r^rh)r+rwrZs r,r&z Table._sortsF|0  9 # #E * * : LL & & &:r/cjddtjD]C\}jfdt|D}jd|DdS)a Re-draw the table from scratch, by clearing out the table's multi-column listbox; and then filling it in with values from ``self._rows``. Note that any cell-, row-, or column-specific color configuration that has been done will be lost. The selection will also be lost -- i.e., no row will be selected after this call completes. rrNcDg|]\}}||Sr<r9)rr:rrfr+s r,rz%Table._fill_table..s-LLL6Aqt~~aA..LLLr/)r!rrUrrr)r+ save_configr rfs` @r,r'zTable._fill_tables E""" ++ ) )FAs~)LLLLLYs^^LLL I  UC ( ( ( ( ) )r/c(fddDS)NcVi|]%}|j|d&S)r&)r!r)rkr rr+s r,rz)Table._get_itemconfig..sD    ty##Aq!,,R0   r/)rrr rr<)r+rqr s```r,_get_itemconfigzTable._get_itemconfigs<          r/Fc|.tttj}}|r|t j|}|rfd|D}nfd|D}||fS)a* Return a 'cookie' containing information about which row is selected, and what color configurations have been applied. this information can the be re-applied to the table (after making modifications) using ``_restore_config_info()``. Color configuration information will be saved for any rows in ``row_indices``, or in the entire table, if ``row_indices=None``. If ``index_by_id=True``, the the cookie will associate rows with their configuration information based on the rows' python id. This is useful when performing operations that re-arrange the rows (e.g. ``sort``). If ``index_by_id=False``, then it is assumed that all rows will be in the same order when ``_restore_config_info()`` is called. Nci|]<tjfdtjD=S)c<g|]}|Sr<rrrr rqr+s r,rz6Table._save_config_info...&s6$$$34D((A..$$$r/)idrrJrrrqr+s @r,rz+Table._save_config_info..%sp4:a=!!$$$$$8=d>O8P8P$$$r/cVi|]$fdtjD%S)c<g|]}|Sr<rvrws r,rz6Table._save_config_info...-s)QQQ1D((A..QQQr/)rJrrys @r,rz+Table._save_config_info..,sOQQQQQd>O8P8PQQQr/)rIrJrKrr\rx)r+ row_indicesrb selectionconfigs` r,rLzTable._save_config_info s  uS__5566K%%''  2904:i011I  % FF$F &  r/c b|\}}||jdd|rt|jD]\}}t ||vrLt |jD]7}|j|||t ||8t ||kr|j||dS||j|||D]A}t |jD]*}|j|||||+BdS)zy Restore selection & color configuration information that was saved using ``_save_config_info``. Nrr)r) r!rrUrrxrJrrr@) r+cookierbrr}r~rqr r s r,rMzTable._restore_config_info3sm # 6   I % %a / / /  @#DJ// 1 13c77f$$"4#455JJ //1fRWWoa6HIIIIc77i''I$$QC$000  1 1$    444 @ @t011@@AI++Aq&)A,????@ @ @r/c|jjD])}t||ksJ*|D]}t||jksJ|jt|jjksJt |D]^\}}t |D]I\}}|j||||}|j|||ksJJ_dS)a Verify that the contents of the table's ``_rows`` variable match the contents of its multi-listbox (``_mlb``). This is just included for debugging purposes, to make sure that the list-modifying operations are working correctly. N) r!rrKrrrrUrr)r+rr rfr:cells r,r<zTable._check_table_vs_mlbUs 9& + +Ct99 ***** 1 1Cs88t000000 C (>$?$?????oo 3 3FAs$S>> 3 34>->>!Q55Dy}}Q''*d22222 3 3 3r/rr2r)r^)T)NF)FF)*rrrrrRr"rYrr\rrrrrrrrrrr@rXrDrIrrPrRr rrrZrrr\r@rhr&r'rrrLrMr;r<r<r/r,r r Es$$T MMMMh*** *** ,,,, +-5555.08888 HHHH ====@@@@>>>>I"LJ '''( ' ' ' ' ' '''',,, %5%5%5N ' ' '   &&X& 1 1 1??????   ,,,,''''''''R   & ) ) ) )    &!&!&!&!P@@@@<F#33333r/r cv t d fdt dgdd}|dd d d lm}m}tt| dd D]\}}|d d kr| }| |D]} | d }n #d}YnxYw | d }n #d}YnxYw|||||g|dd|dd|dd|ddt#t%|D].}dD])} ||| fdkr||| dd*/ dS)Nz c,Sr2)destroy)r*roots r,r-zdemo..pst||~~r/zWord Synset Hypernym Hyponym)rr r r c d|zS)Nz %sr<)rfr:ss r,r-zdemo..vs &1*r/)rbr*Tr)rrr)brownwordnetiNz*none*Wordz#afa)r Synsetz#efeHypernymz#feeHyponymz#ffe)rrz#666)rr)rr\r splitr" nltk.corpusrrsortedr# tagged_wordslowersynsets hypernyms definitionrXrrJrKrmainloop) tablerrwordpossynset hyper_defhypo_defr rrs @r,demorns 44DIIm5555666  &,,..#||,,    E  JJdJ(((********C 2 2 4 4TcT :;;<< K K c q6S== zz||ood++ K KF %",,..q1<<>>  %$  $!++--a0;;== $# LL$ 1 1 3 3YI J J J J K v&111 xF333 zf555 yV444SZZ  -  FS&[!X--  FV!   MMOOOOOs$,DD,EE__main__) rretkinterrrrrrr r rrr<r/r,rs88888888888888bbbbb5bbbba3a3a3a3a3a3a3a3R'''T zDFFFFFr/