o rZhJX@spddlZddlmZmZddlmZddlmZGdddeedZGdd d eZ Gd d d eZ d d gZ dS) N)ABCMetaabstractmethod)Tree) slice_boundscseZdZdZd"fdd Zed#ddZedd Zfd d Zfd d Z fddZ fddZ fddZ d$fdd Z fddZeedrVddZddZddZd d!ZZS)%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. Ncsrt|||dur5t|D]\}}t|tr |j||ddqt|D]\}}t|tr4|||q%dSdS)NTdry_run)super__init__ enumerate isinstancer _setparentselfnodechildrenichild __class__A/var/www/auris/lib/python3.10/site-packages/nltk/tree/parented.pyr .s   zAbstractParentedTree.__init__FcCdS)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. Nrrrindexrrrrr @zAbstractParentedTree._setparentcCr)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``. Nrrrrrrr _delparentVrzAbstractParentedTree._delparentcs,t|tr/t||dd\}}}t|||D]}t||tr&||||qt|dSt|tr]|dkr>|t |7}|dkrFt dt||trU||||t|dSt|t t frt |dkrnt dt |dkr{||d=dS||d|dd=dSt dt|jt|jf)NTZ allow_steprindex out of rangez(The tree position () may not be deleted.#%s indices must be integers, not %s)r slicerrangerrr __delitem__intlen IndexErrorlisttuple TypeErrortype__name__)rrstartstopsteprrrrr$js4     z AbstractParentedTree.__delitem__cst|trmt||dd\}}}t|ttfst|}t|D]\}}t|tr3|j||||ddqt|||D]}t||trK| |||q:t|D]\}}t|trc|||||qPt ||dSt|t r|dkr||t |7}|dkrtd|||urdSt|tr|||t||tr| |||t ||dSt|ttfrt |dkrtdt |dkr|||d<dS|||d|dd<dStdt|jt|jf) NTrrrrz,The tree position () may not be assigned to.r r!)r r"rr(r)r rr r#rr __setitem__r%r&r'r*r+r,)rrvaluer-r.r/rrrrrr0sP          z AbstractParentedTree.__setitem__cs*t|tr ||t|t|dSNr rr r&r append)rrrrrr4s zAbstractParentedTree.appendcs4|D]}t|tr||t|t|qdSr2r3)rrrrrrextends  zAbstractParentedTree.extendcsH|dkr |t|7}|dkrd}t|tr|||t||dSNr)r&r rr r insert)rrrrrrr7s   zAbstractParentedTree.insertcsN|dkr |t|7}|dkrtdt||tr!||||t|S)Nrr)r&r'r rrr pop)rrrrrr9s  zAbstractParentedTree.popcs8||}t||tr||||t|dSr2)rr rrr removerrrrr:s zAbstractParentedTree.remove __getslice__cC|ttd|td|Sr6) __getitem__r"maxrr-r.rrrr;z!AbstractParentedTree.__getslice__cCr<r6)r$r"r>r?rrr __delslice__r@z!AbstractParentedTree.__delslice__cCs|ttd|td||Sr6)r0r"r>)rr-r.r1rrr __setslice__sz!AbstractParentedTree.__setslice__cCs|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]] )Z_labelr(rrrr__getnewargs__s z#AbstractParentedTree.__getnewargs__r2F)r8)r, __module__ __qualname____doc__r rr rr$r0r4r5r7r9r:hasattrr(r;rArBrD __classcell__rrrrrs&    ( <   r) metaclasscszeZdZdZdfdd ZddZdfdd Zd d Zd d ZddZ ddZ ddZ ddZ ddZ dddZZS) 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. NcsTd|_ t|||dur&t|D]\}}t|tr%d|_|||qdSdSr2)_parentr r r r rr rrrrr 's  zParentedTree.__init__cCddlm}|S)Nr)ImmutableParentedTree)nltk.tree.immutablerO)rrOrrr _frozen_class5 zParentedTree._frozen_classFcs&|s t|jjdtjddS)NzB objects do not support shallow copies. Defaulting to a deep copy.T)deep)warningswarnrr,r copy)rrSrrrrV:s  zParentedTree.copycCs|jS)z5The parent of this tree, or None if it has no parent.)rMrCrrrparentEszParentedTree.parentcCs:|jdurdSt|jD] \}}||ur|Sq Jd)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!)rMr )rrrrrr parent_indexIs zParentedTree.parent_indexcCs(|}|jr|dkr|j|dSdS)z6The left sibling of this tree, or None if it has none.rr N)rXrMrrXrrr left_siblingXszParentedTree.left_siblingcCs2|}|jr|t|jdkr|j|dSdS)z7The right sibling of this tree, or None if it has none.r N)rXrMr&rYrrr right_sibling_szParentedTree.right_siblingcCs(|}|dur|}|dus|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. N)rWrrootrrrr]fs   zParentedTree.rootcCs&|durdS||fS)z The tree position of this tree, relative to the root of the tree. I.e., ``ptree.root[ptree.treeposition] is ptree``. Nr)rW treepositionrXrCrrrr^qs zParentedTree.treepositioncCs6t|tsJ|||usJ|j|usJd|_dSr2)r rLrMrrrrrs zParentedTree._delparentcCs@t|ts tdt|dr|jdurtd|s||_dSdS)Nz5Can not insert a non-ParentedTree into a ParentedTreerMz3Can not insert a subtree that already has a parent.)r rLr*rIrM ValueErrorrrrrr s  zParentedTree._setparentr2rE)r,rFrGrHr rQrVrWrXrZr[r]r^rr rJrrrrrLs   rLcs|eZdZdZdfdd ZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZdddZZS)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. NcsTg|_ t|||dur&t|D]\}}t|tr%g|_|||qdSdSr2)_parentsr r r r rr rrrrr s  zMultiParentedTree.__init__cCrN)Nr)ImmutableMultiParentedTree)rPrb)rrbrrrrQrRzMultiParentedTree._frozen_classcCs 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(rarCrrrparentss zMultiParentedTree.parentscCdd|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) cSs$g|]\}}|dkr||dqS)rr r.0rWrrrr s  z3MultiParentedTree.left_siblings.._get_parent_indicesrCrrr left_siblings zMultiParentedTree.left_siblingscCrd)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) cSs,g|]\}}|t|dkr||dqS)r )r&rerrrrgs  z4MultiParentedTree.right_siblings..rhrCrrrright_siblingsrkz MultiParentedTree.right_siblingscsfddjDS)Ncs.g|]}t|D] \}}|ur||fqqSr)r )rfrWrrrCrrrgsz9MultiParentedTree._get_parent_indices..rarCrrCrris z%MultiParentedTree._get_parent_indicescCst|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_helpervaluesrCrrrrootsszMultiParentedTree.rootscCs0|jr|jD]}||q|S||t|<|Sr2)rarnid)rresultrWrrrrns    z#MultiParentedTree._get_roots_helpercs$|jvrgSfddt|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 csg|] \}}|ur|qSrr)rfrrrCrrrgsz4MultiParentedTree.parent_indices..)rar )rrWrrCrparent_indicess z MultiParentedTree.parent_indicescs$urdgSfddjDS)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 rcs@g|]}|D]}t|D] \}}|ur||fqq qSr) treepositionsr )rfrWZtreeposrrr]rrrrg!s z3MultiParentedTree.treepositions..rmr\rrurrts   zMultiParentedTree.treepositionscsvt|tsJ||usJtfdd|jDdksJtD]\}}||ur2||kr2dSq#|jdS)Ncsg|]}|ur|qSrr)rfprCrrrg1sz0MultiParentedTree._delparent..r )r r`r&rar r:)rrrrcrrCrr-s zMultiParentedTree._delparentFcCsDt|ts td|s |jD] }||urdSq|j|dSdS)Nz?Can not insert a non-MultiParentedTree into a MultiParentedTree)r r`r*rar4)rrrrrWrrrr ;s  zMultiParentedTree._setparentr2rE)r,rFrGrHr rQrcrjrlrirprnrsrtrr rJrrrrr`s   r`) rTabcrrZnltk.tree.treerZ nltk.utilrrrLr`__all__rrrrs   7