dӹdZddlZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z m Z mZmZdd lmZdd l mZdd lmZmZmZdd lmZmZdd lmZddlmZmZddlm Z m!Z!m"Z"dZ#GddeZ$Gddej%eZ%Gdde%Z&Gddee%Z'Gddee%Z(Gddee%Z)dS)z Here is defined the Group class.N) ProxyDict) hdf5extension)utilsextension) class_id_dict) NodeErrorNoSuchNodeErrorNaturalNameWarningPerformanceWarning)Filters)get_class_by_name)check_name_validity join_path isvisiblename)NodeNotLoggedMixin)Leaf) UnImplementedUnknown)LinkSoftLink ExternalLinkz1.0ceZdZdZdS) _ChildrenDictc,||SN) _f_get_child)self containerkeys ,lib/python3.11/site-packages/tables/group.py_get_value_from_containerz'_ChildrenDict._get_value_from_containers%%c***N)__name__ __module__ __qualname__r"r#r!rrs#+++++r#rceZdZdZdZdZdZeeZdZ dZ dZ ee e e dZ d0fd Z dZfdZdZd1dZdZdZdZdZdZd2dZdZdZd1dZdZfdZd1dZdZdZd2d Z d2d!Z!d"Z"fd#Z#fd$Z$d%Z%fd&Z&d'Z'd(Z(fd)Z)d*Z*d3fd+ Z+ d4fd, Z, d5d-Z-d.Z.d/Z/xZ0S)6Groupa2Basic PyTables grouping structure. Instances of this class are grouping structures containing *child* instances of zero or more groups or leaves, together with supporting metadata. Each group has exactly one *parent* group. Working with groups and leaves is similar in many ways to working with directories and files, respectively, in a Unix filesystem. As with Unix directories and files, objects in the object tree are often described by giving their full (or absolute) path names. This full path can be specified either as a string (like in '/group1/group2') or as a complete object path written in *natural naming* schema (like in file.root.group1.group2). A collateral effect of the *natural naming* schema is that the names of members in the Group class and its instances must be carefully chosen to avoid colliding with existing children node names. For this reason and to avoid polluting the children namespace all members in a Group start with some reserved prefix, like _f_ (for public methods), _g_ (for private ones), _v_ (for instance variables) or _c_ (for class variables). Any attempt to create a new child node whose name starts with one of these prefixes will raise a ValueError exception. Another effect of natural naming is that children named after Python keywords or having names not valid as Python identifiers (e.g. class, $a or 44) can not be accessed using the node.child syntax. You will be forced to use node._f_get_child(child) to access them (which is recommended for programmatic accesses). You will also need to use _f_get_child() to access an existing child node if you set a Python attribute in the Group with the same name as that node (you will get a NaturalNameWarning when doing this). Parameters ---------- parentnode The parent :class:`Group` object. name : str The name of this node in its parent group. title The title for this group new If this group is new or has to be read from disk filters : Filters A Filters instance .. versionchanged:: 3.0 *parentNode* renamed into *parentnode* Notes ----- The following documentation includes methods that are automatically called when a Group instance is accessed in a special way. For instance, this class defines the __setattr__, __getattr__, __delattr__ and __dir__ methods, and they set, get and delete *ordinary Python attributes* as normally intended. In addition to that, __getattr__ allows getting *child nodes* by their name for the sake of easy interaction on the command line, as long as there is no Python attribute with the same name. Groups also allow the interactive completion (when using readline) of the names of child nodes. For instance:: # get a Python attribute nchild = group._v_nchildren # Add a Table child called 'table' under 'group'. h5file.create_table(group, 'table', myDescription) table = group.table # get the table child instance group.table = 'foo' # set a Python attribute # (PyTables warns you here about using the name of a child node.) foo = group.table # get a Python attribute del group.table # delete a Python attribute table = group.table # get the table child instance again Additionally, on interactive python sessions you may get autocompletions of children named as *valid python identifiers* by pressing the `[Tab]` key, or to use the dir() global function. .. rubric:: Group attributes The following instance variables are provided in addition to those in Node (see :ref:`NodeClassDescr`): .. attribute:: _v_children Dictionary with all nodes hanging from this group. .. attribute:: _v_groups Dictionary with all groups hanging from this group. .. attribute:: _v_hidden Dictionary with all hidden nodes hanging from this group. .. attribute:: _v_leaves Dictionary with all leaves hanging from this group. .. attribute:: _v_links Dictionary with all links hanging from this group. .. attribute:: _v_unknown Dictionary with all unknown nodes hanging from this group. GROUP) __members__ _v_children _v_groups _v_leaves_v_links _v_unknown _v_hiddenc*t|jS)z/The number of children hanging from this group.)lenr,rs r!_g_getnchildrenzGroup._g_getnchildrens4#$$$r#cRt|jdd}|t}|S)NFILTERS)getattr_v_attrsr )rfilterss r! _g_getfilterszGroup._g_getfilterss($-D99 ?iiGr#clt|tstd|||j_dS)Nz'value is not an instance of `Filters`: ) isinstancer TypeErrorr9r7)rvalues r! _g_setfilterszGroup._g_setfilterssE%)) EC%CCEE E % r#c|j`dSr)r9r7r4s r! _g_delfilterszGroup._g_delfilterss M ! ! !r#aPDefault filter properties for child nodes. You can (and are encouraged to) use this property to get, set and delete the FILTERS HDF5 attribute of the group, which stores a Filters instance (see :ref:`FiltersClassDescr`). When the group has no such attribute, a default Filters instance is used. FNTct|_ ||_ ||_ ||_ |jjd|_ t |||dS)NMAX_GROUP_WIDTH) obversion _v_version_v_new _v_new_title_v_new_filters_v_fileparams_v_max_group_widthsuper__init__)r parentnodenametitlenewr:_log __class__s r!rOzGroup.__init__sl$/ ?!&%<","4";>   8S(A(A w//H } $ $ * *Lr#c|jjdrC||d}|*t|ts|d}nd}|t vr t |Stj|j |}|dkrd|r[|+tj d| |zn.tj d| |d|d tS|t vsJt |S) a.Get the class of a not-yet-loaded leaf child. `childname` must be the name of a *leaf* child. If the child belongs to an unknown kind of leaf, or if its kind can not be guessed, `UnImplemented` will be returned and a warning will be issued if `warn` is true. rWrYNrn UNSUPPORTEDzOleaf ``%s`` is of an unsupported type; it will become an ``UnImplemented`` nodezleaf ``z`` has an unknown class ID ``z,``; it will become an ``UnImplemented`` node)rKrL_g_get_lchild_attrr=rprqrr which_class _v_objectidwarningswarn_g_joinr)rrrr{rs childCID2s r!_g_get_child_leaf_classzGroup._g_get_child_leaf_classs4 < 3 4 ..y'BBH#Jx,E,E##??733H } $ $ * *'243CYOOIM)) C' G"ll95567777 !  $||I6666BCCC%$ ---- + +r#c|j}gx|d<} t|x|d<} t|x|d<} t|x|d<} t|x|d<} t|x|d<} t|x|d<} ||j\} } } } | |f| |f| |f| |ffD]?\} }| D]7}t |r!|d|d ||<d ||<2d ||<8@d S) zWAdd children names to this group taking into account their visibility and kind.r+r,r-r.r/r0r1rN)rgr _g_list_groupr]rinsert)rmydictmemberschildrengroupsleaveslinksunknownhidden group_names leaf_names link_names unknown_names childnames childdictrrs r!_g_add_children_nameszGroup._g_add_children_namesCs+-,} +8+>+>>}='4T':'::{fA'4T':'::{fA%24%8%88zU@)6t)<)<<|wH'4T':'::{fG   t~ . . =j*m *5f(=)3V(<)3U(;)6(@(B - - #Z ( - - !++-NN1i000*.HY'+/Ii(()-F9%% -  - -r#cr||}|dkrtd|jd|d|S)zACheck whether 'name' is a children of 'self' and return its type. NoSuchNodegroup ``z!`` does not have a child named ````)_g_get_objinfor rd)rrQ node_types r!_g_check_has_childzGroup._g_check_has_childqsU''--  $ $!/###TTT+,, ,r#c*|S)agIterate over the child nodes hanging directly from the group. This iterator is *not* recursive. Examples -------- :: # Non-recursively list all the nodes hanging from '/detector' print("Nodes in '/detector' group:") for node in h5file.root.detector: print(node) ) _f_iter_nodesr4s r!__iter__zGroup.__iter__|s"!!###r#c~| ||n#t$rYdSwxYwdS)zIs there a child with that `name`? Returns a true value if the group has a child node (visible or hidden) with the given `name` (a string), false otherwise. FT) _g_check_openrr rrQs r! __contains__zGroup.__contains__sY    # #D ) ) ) )   55 ts , ::ch ||S#t$rt|wxYw)zyReturn the (visible or hidden) child with that `name` ( a string). Raise IndexError if child not exist. )rr IndexError)rrrs r! __getitem__zGroup.__getitem__sD  ($$Y// / ( ( (Y'' ' (s1c#K||dkrd}|dkr|Ed{VdS|D]}||Ed{VdS)aIterate over descendant nodes. This method recursively walks *self* top to bottom (preorder), iterating over child groups in alphanumerical order, and yielding nodes. If classname is supplied, only instances of the named class are yielded. If *classname* is Group, it behaves like :meth:`Group._f_walk_groups`, yielding only groups. If you don't want a recursive behavior, use :meth:`Group._f_iter_nodes` instead. Examples -------- :: # Recursively print all the arrays hanging from '/' print("Arrays in the object tree '/':") for array in h5file.root._f_walknodes('Array', recursive=True): print(array) rCNr))r_f_walk_groupsr)r classnamegroups r! _f_walknodeszGroup._f_walknodess0  ??I   **,, , , , , , , , , ,,,.. : : ..y9999999999 : :r#cF|dkr|jSt|j|S)zcHelper method to correctly concatenate a name child object with the pathname of this group./)rdrrs r!r|z Group._g_joins) 3;;# #)4000r#cXtjd|j|jfztdS)z7Issue a :exc:`PerformanceWarning` on too many children.zgroup ``%s`` is exceeding the recommended maximum number of children (%d); be ready to see PyTables asking for *lots* of memory and possibly slow I/O.Nrzr{rdrMr r4s r!_g_width_warningzGroup._g_width_warningsC  O)4+BCD)  * * * * *r#c,|r$t|||t|ts||vrt d|jd|d||jvr&tjd|jd|dtt|j t|j z|j kr|t|r|jd|d|j |<t|t$r d|j|<dSt|tr d|j|<dSt|t*r d|j|<dSt|t.r d|j|<dSdSd|j |<dS)a|Insert references to a `childnode` via a `childname`. Checks that the `childname` is valid and does not exist, then creates references to the given `childnode` by that `childname`. The validation of the name can be omitted by setting `validate` to a false value (this may be useful for adding already existing nodes to the tree). r$`` already has a child node named ``rz$`` already has an attribute named ``G``; you will not be able to use natural naming to access the child noderN)r _g_check_namer=rrrdrgrzr{r r3r,r1rMrrr+rrr0r/rr.r)r-)r childnoderrvalidates r! _g_refnodezGroup._g_refnodes  /  * * *  # #I . . .9d++ 1d1B1B)###YYY011 1  % % MM###YYY02D  E E E  ! !C$7$7 7' ( (  ! ! # # #  # # -   # #Ay 1 1 1*.D Y ')W-- 1-1 ***It,, 1+/ i(((It,, 1,0y)))Iu-- 1,0y))) 1 1)-DN9 % % %r#c||vsJd|jd|dd|jvr||jvr|j}||}||=|j|=|j|d|j|d|j|d|j |ddS|j |=dSdS)zYRemove references to a node. Removes all references to the named node. rz&`` does not have a child node named ``rr,N) rdrgr,r+indexr0popr/r.r-r1)rrrr member_indexs r! _g_unrefnodezGroup._g_unrefnodesD    ###YYY0!  DM ) )D,,,*&}}Y77 L)$Y/##It444 !!)T222""9d333""9d33333N9--- * )r#c|j}t|||j}|j||dSr)rdrN_g_moverK_update_node_locations)r newparentnewnameoldpathnewpathrUs r!rz Group._g_move6sK"  7+++" ++GW=====r#c |d|j}|dd}|dd}||j}|t|jdd}t |||d||} |ddr!|j| jd||d xxd z cc<|r8|}|dd|j| fi|| S) NrRr:statsr7T)rSr:rT copyuserattrs) copyclassrr) get_v_titler8r9r)_g_copycopyr_g_copy_children) rrr recursiverTkwargsrRr:rnew_nodes r!rz Group._g_copy@s+ 7DM22**Y-- 7D)) =ME ?dmY==GGD'FFF ::ot , , E M ! !("3t ! D D D   (OOOq OOO  6[[]]F JJw % % % !D !( 5 5f 5 5 5r#c |dd}|r|di}||fg}|r|\}}|r4|jD]}|\} } | dkr| |vr|| d\} } t j| | } |j ||j | ||  |j |j f|dd}||dxxdz cc<|j|fi|}t|t r| ||f| dkr|j |j fg|| <nV|jD]<}|j|fi|}t|t r| ||f=|dSdS) aBCopy child nodes. Copies all nodes descending from this one into the specified `newparent`. If the new parent has a child node with the same name as one of the nodes in this group, the copy fails with a `NodeError`, maybe resulting in a partial copy. Nothing is logged. use_hardlinksF address_maprrrN hardlinks)r setdefaultrr,values _get_obj_infoospathjoinrKcreate_hard_linkrQappendrd_g_copy_as_childr=r))rrrrr parentstack srcparent dstparentsrcchildaddrrcwhererQlocalsrcrdstchilds r!rzGroup._g_copy_childrencsi  ?E::  ? ++M2>>Ki() " A%0__%6%6 "Y  A ) 5 < < > >H'5577HD"Avv$+"5"5&1$&7&: t#%7<<t#<#<!)::9;C=;CEEE$D)00&2HMB !' 7D 9 9 ,!+...!3...#<8# >AAH8x8MMfMMH!(E22A#**Hh+?@@@E" A" A" A" A" Ar#c|||t|j|}|j|S)atGet the child called childname of this group. If the child exists (be it visible or not), it is returned. Else, a NoSuchNodeError is raised. Using this method is recommended over getattr() when doing programmatic accesses to children if childname is unknown beforehand or when its name is not a valid Python identifier. )rrrrdrK _get_node)rrr childpaths r!rzGroup._f_get_childsR   ***d. :: |%%i000r#cFt||S)zzReturn a *list* with children nodes. This is a list-returning version of :meth:`Group._f_iter_nodes()`. )listr)rrs r! _f_list_nodeszGroup._f_list_nodess D&&y11222r#c#bK||s(t|jD]}|j|VdS|dkr(t|jD]}|j|VdS|dkr(t|jD]}|j|VdS|dkr(t|jD]}|j|VdS|dkrt dt|}t|jD]\}}t||r|VdS)a}Iterate over children nodes. Child nodes are yielded alphanumerically sorted by node name. If the name of a class derived from Node (see :ref:`NodeClassDescr`) is supplied in the classname parameter, only instances of that class (or subclasses of it) will be returned. This is an iterator version of :meth:`Group._f_list_nodes`. r)rr IndexArrayz+listing ``IndexArray`` nodes is not allowedN) rsortedr,r-r.r/r>r itemsr=)rrrQclass_rrrs r!rzGroup._f_iter_nodess  $t/00 - -&t,,,,, - - ' ! !t~.. + +nT***** + + & t~.. + +nT***** + + & t}-- * *mD))))) * * , & &=?? ?'y11F(.t/?/E/E/G/G(H(H $ $$ 9i00$#OOO $ $r#c#K||g}|V|r`|}t|j}|D]1}||j||j|V2|^dSdS)aRecursively iterate over descendent groups (not leaves). This method starts by yielding *self*, and then it goes on to recursively iterate over all child groups in alphanumerical order, top to bottom (preorder), following the same procedure. N)rrrr-r)rstackobjgroup groupnames groupnames r!rzGroup._f_walk_groupss   4yy{{H 233J( 4 4  X/ :;;;(33333 4 4 4 4 4r#c t|dS#t$r,}d}|t ||zd}~wwxYw)a9Delete a Python attribute called name. This method only provides a extra warning in case the user tries to delete a children node using __delattr__. To remove a children node from this group use :meth:`File.remove_node` or :meth:`Node._f_remove`. To delete a PyTables node attribute use :meth:`File.del_node_attr`, :meth:`Node._f_delattr` or :attr:`Node._v_attrs``. If there is an attribute and a child node with the same name, the child node will be made accessible again via natural naming. z8 (use ``node._f_remove()`` if you want to remove a node)N)rN __delattr__AttributeErrorrUrp)rrQaehintrUs r!rzGroup.__delattr__sf  / GG   % % % % % / / /MD,,s2ww~.. . /s!& A'AAcld|jD}t|zS)zvAutocomplete only children named as valid python identifiers. Only PY3 supports this special method. c:g|]}||Sr') isidentifier).0cs r! z!Group.__dir__..s'CCC!..2B2BC1CCCr#)r,rN__dir__)rsubnodsrUs r!rz Group.__dir__ s5 DCd.CCCww  7**r#c||jvr!||j|S||S)zGet a Python attribute or child node called name. If the node has a child node called name it is returned, else an AttributeError is raised. )_c_lazy_children_attrsrrgrrs r! __getattr__zGroup.__getattr__sE 4. . .  & & ( ( (=& &  &&&r#c|j}d|vr/||jvr&tjd|jd|dt t ||dS)a0Set a Python attribute called name with the given value. This method stores an *ordinary Python attribute* in the object. It does *not* store new children nodes under this group; for that, use the File.create*() methods (see the File class in :ref:`FileClassDescr`). It does *neither* store a PyTables node attribute; for that, use :meth:`File.set_node_attr`, :meth`:Node._f_setattr` or :attr:`Node._v_attrs`. If there is already a child node with the same name, a NaturalNameWarning will be issued and the child node will not be accessible via natural naming nor getattr(). It will still be available via :meth:`File.get_node`, :meth:`Group._f_get_child` and children dictionaries in the group (if visible). r+rrrN)rgr+rzr{rdr rN __setattr__)rrQr?rrUs r!rzGroup.__setattr__ s~N F " "tt/?'?'? MM###TTT+-?  @ @ @ D%(((((r#cV||dS)zFlush this Group.N)r_g_flush_groupr4s r!_f_flushzGroup._f_flushQs.  r#cR|jj}||jdS)z6Close all the *loaded* descendent nodes of this group.N)rKre close_subtreerd)r node_managers r!_g_close_descendentszGroup._g_close_descendentsWs+|1 ""4#344444r#c~|jr|tdS)zClose this (open) group.N)rc_g_close_grouprN_f_close)rrUs r!_g_closezGroup._g_close]sA > "    ! ! ! r#c|jsdS|js|j||dS)aClose this group and all its descendents. This method has the behavior described in :meth:`Node._f_close`. It should be noted that this operation closes all the nodes descending from this group. You should not need to close nodes manually because they are automatically opened/closed when they are loaded/evicted from the integrated LRU cache. N)rc _v__deletingryr r r4s r!r zGroup._f_closehsM~  F ! (T%5%=  % % ' ' ' r#c|jdkr0|s|std|jd|t ||dS)zzRemove (recursively if needed) the Group. This version correctly handles both visible and hidden nodes. rrzJ`` has child nodes; please set `recursive` or `force` to true to remove itN) _v_nchildrenrrdr rN _g_remove)rrforcerUs r!rzGroup._g_removes  q  7 7i$(#3#3#3!6777  % % ' ' ' )U+++++r#c @tj|||||fi|S)aCopy this node and return the new one. This method has the behavior described in :meth:`Node._f_copy`. In addition, it recognizes the following keyword arguments: Parameters ---------- title The new title for the destination. If omitted or None, the original title is used. This only applies to the topmost node in recursive copies. filters : Filters Specifying this parameter overrides the original filter properties in the source node. If specified, it must be an instance of the Filters class (see :ref:`FiltersClassDescr`). The default is to copy the filter properties from the source node. copyuserattrs You can prevent the user attributes from being copied by setting thisparameter to False. The default is to copy them. stats This argument may be used to collect statistics on the copy process. When used, it should be a dictionary with keys 'groups', 'leaves', 'links' and 'bytes' having a numeric value. Their values willbe incremented to reflect the number of groups, leaves and bytes, respectively, that have been copied during the operation. )rN_f_copy)rrr overwriter createparentsrrUs r!rz Group._f_copys9@uww w y-;;39;; ;r#c ||j||}|||s)|jD]!}||vrt d|jd|d"|dd}|r |di} |j D]} | \} } | dkr| | vr| | d\} }tj | |}|j|| j|| | |j| jf|d d }||d xxdz cc<| j|d ||fi|| dkr|j| jfg| | <d S|j D]} | j|d ||fi|d S) aCopy the children of this group into another group. Children hanging directly from this group are copied into dstgroup, which can be a Group (see :ref:`GroupClassDescr`) object or its pathname in string form. If createparents is true, the needed groups for the given destination group path to exist will be created. The operation will fail with a NodeError if there is a child node in the destination group with the same name as one of the copied children from this one, unless overwrite is true; in this case, the former child node is recursively removed before copying the later. By default, nodes descending from children groups of this node are not copied. If the recursive argument is true, all descendant nodes of this node are recursively copied. Additional keyword arguments may be passed to customize the copying process. For instance, title and filters may be changed, user attributes may be or may not be copied, data may be sub-sampled, stats may be collected, etc. Arguments unknown to nodes are simply ignored. Check the documentation for copying operations of nodes to see which options they support. zdestination group ``z`` already has a node named ``z2``; you may want to use the ``overwrite`` argumentrFrrrrNr)rrK_get_or_create_path_g_check_groupr,rrdrrrrrrrrrQrrr)rdstgrouprrrrrrrrrchildrrrrQrrs r!_f_copy_childrenzGroup._f_copy_childrenso8  L44X}MM  I&&& >"- > >  ))#)%000)))=>>>* ?E::  O ++M2>>K)0022   ..00b66dk11"-d"3A"6KE4!w||E488H%66y%*7?AAA%,,". ; #JJw55E(k***a/***!EM)T9i,,$*,,,Avv&2EJ?- D)'  .)0022 O O iy)NNvNNNN O Or#c>|jd|jjd|jS)a,Return a short string representation of the group. Examples -------- :: >>> import tables >>> f = tables.open_file('tables/tests/Tables_lzo2.h5') >>> print(f.root.group0) /group0 (Group) '' >>> f.close()  (z) )rdrUr$rr4s r!__str__z Group.__str__ s9 #%%t~'>%%=%% &r#c~d|jD}|dd|dS)agReturn a detailed string representation of the group. Examples -------- :: >>> import tables >>> f = tables.open_file('tables/tests/Tables_lzo2.h5') >>> f.root.group0 /group0 (Group) '' children := ['group1' (Group), 'tuple1' (Table)] >>> f.close() c8g|]\}}|d|jjdS)r))rUr$)rrrrs r!rz"Group.__repr__..1sB   "E 9 9eo6 9 9 9   r#z children := [z, ])r,rr)rreps r!__repr__zGroup.__repr__ sR"  &*&6&<&<&>&>   <<499S>><<<>>>>!!!!F7A7A7Ar111&3333%$%$%$%$N4440/////,+++++ ' ' '/)/)/)/)/)b 555     <,,,,,,*/3@E";";";";";";HEJ',LOLOLOLO\&&&&=======r#r)c0eZdZdZdZdZddZd dZdS) RootGroupc|j}t|_||_|r||_||_nd|_d|_||_d|_d|_d|_ d|_ |j d|_ d|_ d|_||d<|j|d|||d||_dS)NTrrrEFr])init)rgrFrGrHrIrJrKrcrd_v_name_v_depthrLrMrryre register_node_g_new_g_open)rptfilerQrRrSr:rs r!rOzRootGroup.__init__;s$  ' %D ")D   $D "&D    "(-0A"B!%{**4555 FDt ,,,<<>>r#c|jjdkrt|jj|}||}|dkrt ||S|dkr=|jjdr||}nt}|||dS|dkry||d } |||S#t$rH}tj d | |d |d t||cYd }~Sd }~wwxYw|dkrt||S|dkrt||St||S)zLoad a child node from disk. The child node `childname` is loaded from disk and an adequate `Node` object is created and returned. If there is no such child, a `NoSuchNodeError` is raised. rrr)rWF)rSrT)r{zproblems loading leaf ``z``:: z1 The leaf will become an ``UnImplemented`` node.Nrr)rKroot_ueprrrrLrtr)r~ Exceptionrzr{r|rrr)rrrr ChildClassexcs r! _g_load_childzRootGroup._g_load_childes < C ' '!$,"7CCI++I66   ! !4++ +   |"#78 #!::9EE # :dI5999 9 & 55id5KKJ 6!z$ 222 6 6 6 ||I....5666 %T955555555 6* $ $D),, , . ( (i00 0 y11 1s7 C D =D DDc td)Nz the root node can not be renamedr)rrs r! _f_renamezRootGroup._f_rename:;;;r#NFc td)Nzthe root node can not be movedr<)rrrrs r!_f_movezRootGroup._f_moves8999r#c td)Nz the root node can not be removedr<)rrs r! _f_removezRootGroup._f_remover>r#)NNF)F)r$r%r&rOr:r=r@rBr'r#r!r,r,9sk * * *T/2/2/2b<<<::::<<<<<rbs~&& %%%%%%######------------''''''??????????&&&&&&&&11111111..........  +++++I+++ V=V=V=V=V=M V=V=V=t d<d<d<d<d<d<d<d5***,,,,,NE,,,,,r#