/hJX|SSKrSSKJrJr SSKJr SSKJr "SS\\S9r"SS \5r "S S \5r S S /r g) N)ABCMetaabstractmethod)Tree) slice_boundsc^\rSrSrSrSU4Sjjr\SSj5r\S5rU4Sjr U4Sjr U4Sjr U4S jr U4S jr SU4S jjrU4S jr\"\S 5(a SrSrSrSrSrU=r$)AbstractParentedTreea{ An abstract base class for a ``Tree`` that automatically maintains pointers to parent nodes. These parent pointers are updated whenever any change is made to a tree's structure. Two subclasses are currently defined: - ``ParentedTree`` is used for tree structures where each subtree has at most one parent. This class should be used in cases where there is no"sharing" of subtrees. - ``MultiParentedTree`` is used for tree structures where a subtree may have zero or more parents. This class should be used in cases where subtrees may be shared. Subclassing =========== The ``AbstractParentedTree`` class redefines all operations that modify a tree's structure to call two methods, which are used by subclasses to update parent information: - ``_setparent()`` is called whenever a new child is added. - ``_delparent()`` is called whenever a child is removed. c>[TU]X5 Ubx[U5H,up4[U[5(dMUR XCSS9 M. [U5H-up4[U[5(dMUR XC5 M/ gg)NTdry_run)super__init__ enumerate isinstancer _setparentselfnodechildrenichild __class__s J/var/www/auris/envauris/lib/python3.13/site-packages/nltk/tree/parented.pyrAbstractParentedTree.__init__.sw (  &dOeT**OOEdO;,&dOeT**OOE-, cg)a Update the parent pointer of ``child`` to point to ``self``. This method is only called if the type of ``child`` is ``Tree``; i.e., it is not called when adding a leaf to a tree. This method is always called before the child is actually added to the child list of ``self``. :type child: Tree :type index: int :param index: The index of ``child`` in ``self``. :raise TypeError: If ``child`` is a tree with an impropriate type. Typically, if ``child`` is a tree, then its type needs to match the type of ``self``. This prevents mixing of different tree types (single-parented, multi-parented, and non-parented). :param dry_run: If true, the don't actually set the child's parent pointer; just check for any error conditions, and raise an exception if one is found. Nrrindexr s rrAbstractParentedTree._setparent@rcg)as Update the parent pointer of ``child`` to not point to self. This method is only called if the type of ``child`` is ``Tree``; i.e., it is not called when removing a leaf from a tree. This method is always called before the child is actually removed from the child list of ``self``. :type child: Tree :type index: int :param index: The index of ``child`` in ``self``. Nrrrrs r _delparentAbstractParentedTree._delparentVr!rc>[U[5(a][XSS9up#n[X#U5H0n[X[5(dMUR XU5 M2 [ TU]U5 g[U[5(a`US:aU[U5- nUS:a [S5e[X[5(aUR XU5 [ TU]U5 g[U[[45(a;[U5S:Xa [S5e[U5S:XaXS gXSUSS g[[U5R<S[U5R<35e)NT allow_steprindex out of rangez(The tree position () may not be deleted. indices must be integers, not )rslicerrangerr$r __delitem__intlen IndexErrorlisttuple TypeErrortype__name__)rrstartstopsteprrs rr. AbstractParentedTree.__delitem__jsB eU # # ,TT J E5-dgt,,OODGQ/. G  &s # #qyT"qy !566$+t,, U3 G  & e} - -5zQ !KLLUqqNqN59-:&&U (<(<> rc>[U[5(Ga[XSS9up4n[U[[45(d [U5n[ U5H1upg[U[ 5(dMURXsXe--SS9 M3 [X4U5H0n[X[ 5(dMURXU5 M2 [ U5H2upg[U[ 5(dMURXsXe--5 M4 [TU]-X5 g[U[5(aUS:aU[U5- nUS:a [S5eX ULag[U[ 5(aURX!5 [X[ 5(aURXU5 [TU]-X5 g[U[[45(a?[U5S:Xa [S5e[U5S:XaX US'gX USUSS'g[[!U5R"<S[!U5R"<35e) NTr'r rr)z,The tree position () may not be assigned to.r*r+)rr,rr2r3rrrr-r$r __setitem__r/r0r1r4r5r6) rrvaluer7r8r9rrrs rr< AbstractParentedTree.__setitem__s eU # # ,TT J EedE]33U &e,eT**OOE18+;TOJ-5-dgt,,OODGQ/. &e,eT**OOE18+;<- G  -s # #qyT"qy !566U #%&&-$+t,, U3 G  - e} - -5zQ !OPPUq!&U1X-2U1XuQRy):&&U (<(<> rc>[U[5(aURU[U55 [TU]U5 gNrrrr0r append)rrrs rrBAbstractParentedTree.appends. eT " " OOE3t9 - urc>UHBn[U[5(aURU[U55 [TU]U5 MD gr@rA)rrrrs rextendAbstractParentedTree.extends8E%&&s4y1 GN5 !rc>US:aU[U5- nUS:aSn[U[5(aURX!5 [TU]X5 gNr)r0rrrr insert)rrrrs rrIAbstractParentedTree.insertsK 19 SY E 19E eT " " OOE ) u$rc>US:aU[U5- nUS:a [S5e[X[5(aUR XU5 [ TU]U5$)Nrr))r0r1rrr$r pop)rrrs rrLAbstractParentedTree.popsY 19 SY E 1912 2 dk4 ( ( OODK /w{5!!rc>URU5n[X[5(aURXU5 [TU]U5 gr@)rrrr$r remove)rrrrs rrOAbstractParentedTree.removes< 5! dk4 ( ( OODK / ur __getslice__c `UR[[SU5[SU555$rH) __getitem__r,maxrr7r8s rrQ!AbstractParentedTree.__getslice__&##E#a-Q$FG Grc `UR[[SU5[SU555$rH)r.r,rTrUs r __delslice__!AbstractParentedTree.__delslice__rWrc bUR[[SU5[SU55U5$rH)r<r,rT)rr7r8r=s r __setslice__!AbstractParentedTree.__setslice__s(##E#a-Q$FN Nrc0UR[U54$)aqMethod used by the pickle module when un-pickling. This method provides the arguments passed to ``__new__`` upon un-pickling. Without this method, ParentedTree instances cannot be pickled and unpickled in Python 3.7+ onwards. :return: Tuple of arguments for ``__new__``, i.e. the label and the children of this node. :rtype: Tuple[Any, List[AbstractParentedTree]] )_labelr2rs r__getnewargs__#AbstractParentedTree.__getnewargs__s T$Z((rrr@F))r6 __module__ __qualname____firstlineno____doc__rrrr$r.r<rBrErIrLrOhasattrr2rQrYr\ra__static_attributes__ __classcell__rs@rrrs0 .$  *    &&P:x " %"t^$$ H H O ) )rr) metaclasscz^\rSrSrSrSU4SjjrSrSU4SjjrSrSr Sr S r S r S r S rSS jrSrU=r$) ParentedTreeia A ``Tree`` that automatically maintains parent pointers for single-parented trees. The following are methods for querying the structure of a parented tree: ``parent``, ``parent_index``, ``left_sibling``, ``right_sibling``, ``root``, ``treeposition``. Each ``ParentedTree`` may have at most one parent. In particular, subtrees may not be shared. Any attempt to reuse a single ``ParentedTree`` as a child of more than one parent (or as multiple children of the same parent) will cause a ``ValueError`` exception to be raised. ``ParentedTrees`` should never be used in the same tree as ``Trees`` or ``MultiParentedTrees``. Mixing tree implementations may result in incorrect parent pointers and in ``TypeError`` exceptions. c>SUl[TU] X5 UcD[U5H4up4[ U[ 5(dMSUlUR XC5 M6 ggr@)_parentr rrrrrrs rrParentedTree.__init__'sW C (   &dOeT**$(EMOOE-, rcSSKJn U$)Nr)ImmutableParentedTree)nltk.tree.immutablert)rrts r _frozen_classParentedTree._frozen_class5s =$$rc>U(d-[R"URRS35 [TU]SS9$)NzB objects do not support shallow copies. Defaulting to a deep copy.T)deep)warningswarnrr6r copy)rryrs rr|ParentedTree.copy:s; MM>>**++mn w||&&rcUR$)z5The parent of this tree, or None if it has no parent.rqr`s rparentParentedTree.parentEs ||rcxURcg[UR5H upX LdM Us $ S5e)a The index of this tree in its parent. I.e., ``ptree.parent()[ptree.parent_index()] is ptree``. Note that ``ptree.parent_index()`` is not necessarily equal to ``ptree.parent.index(ptree)``, since the ``index()`` method returns the first child that is equal to its argument. Nz&expected to find self in self._parent!)rqr)rrrs r parent_indexParentedTree.parent_indexIs= << !$,,/HA}0 ?>>urcvUR5nUR(aUS:aURUS- $g)z6The left sibling of this tree, or None if it has none.rr*N)rrqrrs r left_siblingParentedTree.left_siblingXs5((* </Ul[TU] X5 UcD[U5H4up4[ U[ 5(dM/UlUR XC5 M6 ggr@)_parentsr rrrrrrs rrMultiParentedTree.__init__s[   (   &dOeT**%'ENOOE-, rcSSKJn U$)Nr)ImmutableMultiParentedTree)rur)rrs rrvMultiParentedTree._frozen_classs B))rc,[UR5$)z The set of parents of this tree. If this tree has no parents, then ``parents`` is the empty set. To check if a tree is used as multiple children of the same parent, use the ``parent_indices()`` method. :type: list(MultiParentedTree) )r2rr`s rparentsMultiParentedTree.parentssDMM""rcrUR5VVs/sHupUS:dM XS- PM snn$s snnf)aE A list of all left siblings of this tree, in any of its parent trees. A tree may be its own left sibling if it is used as multiple contiguous children of the same parent. A tree may appear multiple times in this list if it is the left sibling of this tree with respect to multiple parents. :type: list(MultiParentedTree) rr*)_get_parent_indicesrrrs r left_siblingsMultiParentedTree.left_siblingssD$(#;#;#= #=qy F19 #=   s 3 3cUR5VVs/sH upU[U5S- :dMXS-PM" snn$s snnf)aH A list of all right siblings of this tree, in any of its parent trees. A tree may be its own right sibling if it is used as multiple contiguous children of the same parent. A tree may appear multiple times in this list if it is the right sibling of this tree with respect to multiple parents. :type: list(MultiParentedTree) r*)rr0rs rright_siblings MultiParentedTree.right_siblingssM$(#;#;#= #=F a( F19 #=   s? ?cURVVVs/sH!n[U5Hup#X0LdM X4PM M# snnn$s snnnfr@rrrrrrs rr%MultiParentedTree._get_parent_indicessJ-- ' )& 1 } VO 1 '   s> >cR[UR05R55$)z The set of all roots of this tree. This set is formed by tracing all possible parent paths until trees with no parents are found. :type: list(MultiParentedTree) )r2_get_roots_helpervaluesr`s rrootsMultiParentedTree.rootss#D**2.55788rcUR(a&URHnURU5 M U$X[U5'U$r@)rrid)rresultrs rr#MultiParentedTree._get_roots_helpers? ==--((0(  $2d8  rc|XR;a/$[U5VVs/sH up#X0LdM UPM snn$s snnf)a! Return a list of the indices where this tree occurs as a child of ``parent``. If this child does not occur as a child of ``parent``, then the empty list is returned. The following is always true:: for parent_index in ptree.parent_indices(parent): parent[parent_index] is ptree rrs rparent_indices MultiParentedTree.parent_indicess8  &I09&0AS0AnuU]E0AS SSs 88c XLaS/$URVVVVs/sH<nURU5H#n[U5HupEXPLdM X44-PM M% M> snnnn$s snnnnf)z Return a list of all tree positions that can be used to reach this multi-parented tree starting from ``root``. I.e., the following is always true:: for treepos in ptree.treepositions(root): root[treepos] is ptree r)r treepositionsr)rrrtreeposrrs rrMultiParentedTree.treepositionssu <4K#mm+F%33D9G&/&7NU= #("'8#9#+ s .A" A" c*[U[5(deXULde[URVs/sH o3ULdM UPM sn5S:Xde[ U5HupEXQLdM XB:wdM g URR U5 gs snf)Nr*)rrr0rrrO)rrrprcs rr$MultiParentedTree._delparent-s%!23333{e###u~~;~!dA~;<AAAdODAzaj$ NN ! !$ ')%%d+ r)rr@rc)r6rerfrgrhrrvrrrrrrrrr$rrjrkrls@rrrsJ". * #   9 T0 ( , ,rr) rzabcrrnltk.tree.treer nltk.utilrrror__all__rrrrsS'" })47})@~!'~!Br,,r,l r