+ hJX^RIt^RIHtHt^RIHt^RIHt!RR]]R7t!RR ]4t !R R ]4t R R .t R#) N)ABCMetaabstractmethod)Tree) slice_boundscaa]tRt^toRtRV3Rllt]RRl4t]R4tV3Rlt V3Rlt V3Rlt V3Rlt V3R lt RV3R lltV3R lt]!]R 4'd R tRtRtRtRtVtV;t#)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*<\SV`W4Ve\V4F0wr4\V\4'gKVP WCRR7K2 \V4F.wr4\V\4'gKVP WC4K0 R#R#)NTdry_run)super__init__ enumerate isinstancer _setparentselfnodechildrenichild __class__s&&& 4/usr/lib/python3/dist-packages/nltk/tree/parented.pyr AbstractParentedTree.__init__.sw (  &dOeT**OOEdO;,&dOeT**OOE-, c R#)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@rc R#)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 rcV<\V\4'dk\WRR7wr#p\W#V4F9p\W,\4'gK!VP W,V4K; \ SV`V4R#\V\4'dqV^8dV\V4, pV^8d \R4h\W,\4'dVP W,V4\ SV`V4R#\V\\34'dP\V4^8Xd \R4h\V4^8Xd W^,R#W^,,VR,R#\\V4P: R\V4P: 24h)T allow_stepindex out of rangez(The tree position () may not be deleted.NN indices must be integers, not N)rslicerrangerr#r __delitem__intlen IndexErrorlisttuple TypeErrortype__name__)rrstartstopsteprrs&& rr. AbstractParentedTree.__delitem__js@ eU # # ,TT J E5-dgt,,OODGQ/. G  &s # #qyT"qy !566$+t,, U3 G  & e} - -5zQ !KLLUqqNqN59-:&&U (<(<> rcD<\V\4'Ed(\WRR7wr4p\V\\34'g \V4p\ V4F=wrg\V\ 4'gKVPWsWe,,RR7K? \W4V4F9p\W,\ 4'gK!VPW,V4K; \ V4F;wrg\V\ 4'gKVPWsWe,,4K= \SV`-W4R#\V\4'dV^8dV\V4, pV^8d \R4hW V,JdR#\V\ 4'dVPW!4\W,\ 4'dVPW,V4\SV`-W4R#\V\\34'dT\V4^8Xd \R4h\V4^8XdW V^,&R#W V^,,VR,&R#\\!V4P": R\!V4P": 24h)Tr&r r(Nz,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-2U1XuRy):&&U (<(<> rc<\V\4'dVPV\V44\SV`V4R#Nrrrr0r append)rrrs&&rrBAbstractParentedTree.appends. eT " " OOE3t9 - urc<VFCp\V\4'dVPV\V44\SV`V4KE R#r@rA)rrrrs&& rextendAbstractParentedTree.extends8E%&&s4y1 GN5 !rc<V^8dV\V4, pV^8d^p\V\4'dVPW!4\SV`W4R#)rN)r0rrrr insert)rrrrs&&&rrHAbstractParentedTree.insertsK 19 SY E 19E eT " " OOE ) u$rc<V^8dV\V4, pV^8d \R4h\W,\4'dVP W,V4\ SV`V4#)rr()r0r1rrr#r pop)rrrs&&rrKAbstractParentedTree.popsY 19 SY E 1912 2 dk4 ( ( OODK /w{5!!rc<VPV4p\W,\4'dVPW,V4\SV`V4R#r@)rrrr#r remove)rrrrs&& rrNAbstractParentedTree.removes< 5! dk4 ( ( OODK / ur __getslice__c `VP\\^V4\^V444#r) __getitem__r,maxrr7r8s&&&rrP!AbstractParentedTree.__getslice__&##E#a-Q$FG Grc `VP\\^V4\^V444#rR)r.r,rTrUs&&&r __delslice__!AbstractParentedTree.__delslice__rWrc bVP\\^V4\^V44V4#rR)r<r,rT)rr7r8r=s&&&&r __setslice__!AbstractParentedTree.__setslice__s(##E#a-Q$FN Nrc 0VP\V43#)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__r rrr#r.r<rBrErHrKrNhasattrr2rPrYr\ra__static_attributes____classdictcell__ __classcell__r __classdict__s@@rrrs0 .$  *    &&P:x " %"t^$$ H H O ) )rr) metaclasscaa]tRtRtoRtRV3RlltRtRV3RlltRtRt Rt R t R t R t R tRR ltRtVtV;t#) 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<RVn\SV` W4VfG\V4F5wr4\ V\ 4'gKRVnVP WC4K7 R#R#r@)_parentr r rrrrrs&&& rr ParentedTree.__init__'sW C (   &dOeT**$(EMOOE-, rc^RIHpV#)r)ImmutableParentedTree)nltk.tree.immutablerv)rrvs& r _frozen_classParentedTree._frozen_class5s =$$rc<V'g.\P!VPP R24\SV`RR7#)zB objects do not support shallow copies. Defaulting to a deep copy.T)deep)warningswarnrr6r copy)rr{rs&&rr~ParentedTree.copy:s; MM>>**++mn w||&&rc VP#)z5The parent of this tree, or None if it has no parent.rsr`s&rparentParentedTree.parentEs ||rc ~VPfR#\VP4FwrW JgK Vu# QR4h)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!)rsr)rrrs& r parent_indexParentedTree.parent_indexIs= << !$,,/HA}0 ?>>urc VP4pVP'd"V^8dVPV^, ,#R#)z6The left sibling of this tree, or None if it has none.N)rrsrrs& r left_siblingParentedTree.left_siblingXs7((* <<)%%d+ r)rr@rc)r6rerfrgrhr rxrrrrrrrrr#rrjrkrlrms@@rrrsL". * #   9 T0 ( , ,rr) r|abcrrnltk.tree.treer nltk.utilrrrqr__all__rrrrsS'" })47})@~!'~!Br,,r,l r