'[fZddlZddlmZmZddlmZddlmZGddeeZGdd eZ Gd d eZ d d gZ dS) N)ABCMetaabstractmethod)Tree) slice_boundsceZdZdZdfd ZeddZedZfdZfdZ fd Z fd Z fd Z dfd Z fdZeedr dZdZdZdZxZS)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. NcXt|||t|D]2\}}t|tr|||d3t|D]2\}}t|tr|||1dSdS)NTdry_run)super__init__ enumerate isinstancer _setparentselfnodechildrenichild __class__s F/var/www/piapp/venv/lib/python3.11/site-packages/nltk/tree/parented.pyr zAbstractParentedTree.__init__.s x(((  &dOO < <5eT**<OOE1dO;;;%dOO . .5eT**.OOE1---  . .FcdS)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 rrzAbstractParentedTree._setparent@rcdS)a 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 _delparentzAbstractParentedTree._delparentVrrct|trt||d\}}}t|||D]9}t||tr||||:t |dSt|tr|dkr|t|z }|dkrtdt||tr||||t |dSt|ttfrYt|dkrtdt|dkr ||d=dS||d|dd=dStt|jdt|j)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*z AbstractParentedTree.__delitem__js eU # #$  ,T5T J J J E45$-- 0 0d1gt,,0OODGQ/// GG   & & & & &s # # qyyT"qyy !5666$u+t,, 4U U333 GG   & & & & & e} - - 5zzQ !KLLLUqqNNNqN59---::&&&U (<(<> rct|tr>t||d\}}}t|ttfst|}t |D]8\}}t|t r|||||zzd9t|||D]9}t||t r| |||:t |D]6\}}t|t r|||||zz7t ||dSt|tr|dkr|t|z }|dkrtd|||urdSt|t r|||t||t r| |||t ||dSt|ttfr]t|dkrtdt|dkr |||d<dS|||d|dd<dStt!|jdt!|j) NTr#r rr%z,The tree position () may not be assigned to.r&r')rr(rr.r/rrrr)r!r __setitem__r+r,r-r0r1r2) rrvaluer3r4r5rrrs rr7z AbstractParentedTree.__setitem__s eU # #8  ,T5T J J J E4edE]33 $U &e,, K K5eT**KOOE51t8+;TOJJJ5$-- 0 0d1gt,,0OODGQ///&e,, = =5eT**=OOE51t8+;<<< GG  u - - - - -s # # qyyT"qyy !5666U ##%&& .u---$u+t,, 4U U333 GG  u - - - - - e} - - 5zzQ !OPPPUq!&U1X-2U1XuQRRy)))::&&&U (<(<> rct|tr#||t|t |dSNrrrr,r append)rrrs rr<zAbstractParentedTree.appendsK eT " " . OOE3t99 - - - urc|D][}t|tr#||t|t |\dSr:r;)rrrrs rextendzAbstractParentedTree.extendsa " "E%&& 2s4yy111 GGNN5 ! ! ! ! " "rc|dkr|t|z }|dkrd}t|tr|||t ||dSNr)r,rrrr insert)rrrrs rrAzAbstractParentedTree.insertsp 199 SYY E 199E eT " " * OOE5 ) ) ) ue$$$$$rc|dkr|t|z }|dkrtdt||tr||||t |S)Nrr%)r,r-rrr!r pop)rrrs rrDzAbstractParentedTree.popsx 199 SYY E 199122 2 d5k4 ( ( 0 OODK / / /ww{{5!!!rc||}t||tr||||t |dSr:)rrrr!r remove)rrrrs rrFzAbstractParentedTree.removes^ 5!! d5k4 ( ( 0 OODK / / / ur __getslice__c |ttd|td|Sr@) __getitem__r(maxrr3r4s rrGz!AbstractParentedTree.__getslice__0##E#a--Q$F$FGG Grc |ttd|td|Sr@)r*r(rJrKs r __delslice__z!AbstractParentedTree.__delslice__rLrc |ttd|td||Sr@)r7r(rJ)rr3r4r8s r __setslice__z!AbstractParentedTree.__setslice__s2##E#a--Q$F$FNN Nrc.|jt|fS)aMethod 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]] )_labelr.rs r__getnewargs__z#AbstractParentedTree.__getnewargs__s T$ZZ((rr:F)rB)r2 __module__ __qualname____doc__r rrr!r*r7r<r>rArDrFhasattrr.rGrNrPrT __classcell__rs@rrrs0 . . . . . .$   ^ *   ^  &&&&&&P:::::x """"" % % % % %""""""wt^$$ O H H H H H H O O O ) ) ) ) ) ) )rr) metaclasscheZdZdZdfd ZdZdfd ZdZdZd Z d Z d Z d Z d Z ddZxZS) ParentedTreea  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. Ncd|_ t|||Gt|D]9\}}t |t rd|_|||8dSdSr:)_parentr r rrrrrs rr zParentedTree.__init__'s C x(((   &dOO . .5eT**.$(EMOOE1---    . .rcddlm}|S)Nr)ImmutableParentedTree)nltk.tree.immutablerb)rrbs r _frozen_classzParentedTree._frozen_class5s======$$rFc|s!tj|jjdt dS)NzB objects do not support shallow copies. Defaulting to a deep copy.T)deep)warningswarnrr2r copy)rrfrs rrizParentedTree.copy:sJ  M>*nnn   ww|||&&&rc|jS)z5The parent of this tree, or None if it has no parent.)r`rSs rparentzParentedTree.parentEs |rcl|jdSt|jD] \}}||ur|cSJd)aD 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. NFz&expected to find self in self._parent!)r`r)rrrs r parent_indexzParentedTree.parent_indexIsT < 4!$,//  HAu}}>>>>>rch|}|jr|dkr|j|dz SdS)z6The left sibling of this tree, or None if it has none.rr&N)rmr`rrms r left_siblingzParentedTree.left_siblingXs>((** < 2L1,,< q 01 1trc|}|jr+|t|jdz kr|j|dzSdS)z7The right sibling of this tree, or None if it has none.r&N)rmr`r,ros r right_siblingzParentedTree.right_sibling_sM((** < 2LC ,=,=,ABB< q 01 1trc|}|(|}|(|S)z The root of this tree. I.e., the unique ancestor of this tree whose parent is None. If ``ptree.parent()`` is None, then ``ptree`` is its own root. )rkrroots rruzParentedTree.rootfs9 kkmm';;==Dkkmm' rc|dS||fzS)z The tree position of this tree, relative to the root of the tree. I.e., ``ptree.root[ptree.treeposition] is ptree``. Nr)rk treepositionrmrSs rrwzParentedTree.treepositionqsE ;;== 2;;==--//43D3D3F3F2HH Hrcpt|tsJ|||usJ|j|usJd|_dSr:)rr^r`r s rr!zParentedTree._delparentsM%.....E{e####}$$$$ rct|tstdt|dr|jt d|s ||_dSdS)Nz5Can not insert a non-ParentedTree into a ParentedTreer`z3Can not insert a subtree that already has a parent.)rr^r0rYr` ValueErrorrs rrzParentedTree._setparentsn%.. USTT T 5) $ $ T)BRSS S ! EMMM ! !rr:rU)r2rVrWrXr rdrirkrmrprrrurwr!rrZr[s@rr^r^s" . . . . . .%%% '''''' ? ? ?   III ! ! ! ! ! ! ! !rr^cheZdZdZdfd ZdZdZdZdZdZ d Z d Z d Z d Z d ZddZxZS)MultiParentedTreea  A ``Tree`` that automatically maintains parent pointers for multi-parented trees. The following are methods for querying the structure of a multi-parented tree: ``parents()``, ``parent_indices()``, ``left_siblings()``, ``right_siblings()``, ``roots``, ``treepositions``. Each ``MultiParentedTree`` may have zero or more parents. In particular, subtrees may be shared. If a single ``MultiParentedTree`` is used as multiple children of the same parent, then that parent will appear multiple times in its ``parents()`` method. ``MultiParentedTrees`` should never be used in the same tree as ``Trees`` or ``ParentedTrees``. Mixing tree implementations may result in incorrect parent pointers and in ``TypeError`` exceptions. Ncg|_ t|||Gt|D]9\}}t |t rg|_|||8dSdSr:)_parentsr r rrrrrs rr zMultiParentedTree.__init__s   x(((   &dOO . .5eT**.%'ENOOE1---    . .rcddlm}|S)Nr)ImmutableMultiParentedTree)rcr)rrs rrdzMultiParentedTree._frozen_classsBBBBBB))rc*t|jS)a 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) )r.r~rSs rparentszMultiParentedTree.parentssDM"""rc>d|DS)a} 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) c6g|]\}}|dk ||dz S)rr&r.0rkrs r z3MultiParentedTree.left_siblings..s6   qyy 519 yyr_get_parent_indicesrSs r left_siblingszMultiParentedTree.left_siblings/  #'#;#;#=#=    rc>d|DS)a 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) cVg|]&\}}|t|dz k||dz'S)r&)r,rs rrz4MultiParentedTree.right_siblings..sD   F a(( 519 (((rrrSs rright_siblingsz MultiParentedTree.right_siblingsrrc*fdjDS)NcJg|]}t|D] \}}|u ||f Sr)r)rrkrrrs rrz9MultiParentedTree._get_parent_indices..sP    )& 1 1  u}}UO}}}rr~rSs`rrz%MultiParentedTree._get_parent_indicess0    -    rcjt|iS)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) )r._get_roots_helpervaluesrSs rrootszMultiParentedTree.rootss,D**2..5577888rcx|jr |jD]}||n||t|<|Sr:)r~rid)rresultrks rrz#MultiParentedTree._get_roots_helpersP = $- 1 1((0000 1 $F2d88  rcP|jvrgSfdt|DS)aY 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 c"g|] \}}|u | Srr)rrrrs rrz4MultiParentedTree.parent_indices..s"SSSnueUd]]E]]]r)r~r)rrks` rparent_indicesz MultiParentedTree.parent_indicess9  & &ISSSS &0A0ASSS Src<urdgSfdjDS)a 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 rc~g|]9}|D]!}t|D]\}}|u ||fz":Sr) treepositionsr)rrktreeposrrrurs rrz3MultiParentedTree.treepositions..!su%33D99&/&7&7 #UED== 5("!====rrrts``rrzMultiParentedTree.treepositionssH 4<<4K"m rct|tsJ||usJtfd|jDdksJt D]\}}||ur ||krdS|jdS)Ncg|]}|u| Srr)rprs rrz0MultiParentedTree._delparent..1s;;;!dArr&)rr|r,r~rrF)rrrrcs` rr!zMultiParentedTree._delparent-s%!233333E{e####;;;;u~;;;<<AAAAdOO ( (DAqEzza5jj N ! !$ ' ' ' ' 'rFct|tstd|s-|jD] }||urdS |j|dSdS)Nz?Can not insert a non-MultiParentedTree into a MultiParentedTree)rr|r0r~r<)rrrr rks rrzMultiParentedTree._setparent;s%!233 Q   ,. , ,T>>EE"%%d+++++  , ,rr:rU)r2rVrWrXr rdrrrrrrrrr!rrZr[s@rr|r|s"...... *** # # #         999 T T T0 ( ( ( , , , , , , , ,rr|) rgabcrrnltk.tree.treer nltk.utilrrr^r|__all__rrrrs''''''''"""""" })})})})})47})})})})@~!~!~!~!~!'~!~!~!Br,r,r,r,r,,r,r,r,l r