3 dZ@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 fddZeedrddZddZddZd 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. Ncsvtj|||dk rrx.t|D]"\}}t|tr |j||ddq Wx*t|D]\}}t|trP|j||qPWdS)NT)dry_run)super__init__ enumerate isinstancer _setparent)selfnodechildrenichild) __class__2/tmp/pip-build-v9q4h5k9/nltk/nltk/tree/parented.pyr .s  zAbstractParentedTree.__init__FcCsdS)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. Nr)r rindexrrrrr @szAbstractParentedTree._setparentcCsdS)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``. Nr)r rrrrr _delparentVszAbstractParentedTree._delparentcs0t|tr`t||dd\}}}x2t|||D]"}t||tr,|j|||q,Wtj|nt|tr|dkr~|t |7}|dkrt dt||tr|j|||tj|nrt|t t frt |dkrt dn.t |dkr||d=n||d|dd=nt dt|jt|jfdS)NT) allow_steprzindex out of rangez(The tree position () may not be deleted.z#%s indices must be integers, not %s)r slicerrangerrr __delitem__intlen IndexErrorlisttuple TypeErrortype__name__)r rstartstopstepr)rrrrjs.       z AbstractParentedTree.__delitem__cst|trt||dd\}}}t|ttfs4t|}x6t|D]*\}}t|tr>|j||||ddq>Wx2t|||D]"}t||trz|j |||qzWx2t|D]&\}}t|tr|j||||qWt j ||nt|t rt|dkr|t |7}|dkrtd|||kr,dSt|trD|j||t||trd|j |||t j ||nzt|ttfrt |dkrtdn4t |dkr|||d<n|||d|dd<ntdt|jt|jfdS) NT)r)rrzindex out of rangez,The tree position () may not be assigned to.rz#%s indices must be integers, not %s)r rrrr r rr rrr __setitem__rrrr!r"r#)r rvaluer$r%r&rr)rrrr'sF          z AbstractParentedTree.__setitem__cs*t|tr|j|t|tj|dS)N)r rr rrappend)r r)rrrr)s zAbstractParentedTree.appendcs8x2|D]*}t|tr$|j|t|tj|qWdS)N)r rr rrr))r rr)rrrextends  zAbstractParentedTree.extendcsH|dkr|t|7}|dkr d}t|tr6|j||tj||dS)Nr)rr rr rinsert)r rr)rrrr+s   zAbstractParentedTree.insertrcsN|dkr|t|7}|dkr$tdt||trB|j|||tj|S)Nrzindex out of range)rrr rrrpop)r r)rrrr,s zAbstractParentedTree.popcs8|j|}t||tr(|j|||tj|dS)N)rr rrrremove)r rr)rrrr-s zAbstractParentedTree.remove __getslice__cCs|jttd|td|S)Nr) __getitem__rmax)r r$r%rrrr.sz!AbstractParentedTree.__getslice__cCs|jttd|td|S)Nr)rrr0)r r$r%rrr __delslice__sz!AbstractParentedTree.__delslice__cCs|jttd|td||S)Nr)r'rr0)r r$r%r(rrr __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)r rrr__getnewargs__s z#AbstractParentedTree.__getnewargs__)N)F)r4)r# __module__ __qualname____doc__r rr rrr'r)r*r+r,r-hasattrrr.r1r2r3 __classcell__rr)rrrs"   ( <    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. NcsRd|_tj|||dkrNx0t|D]$\}}t|tr&d|_|j||q&WdS)N)_parentrr r r rr )r rrrr)rrrr 's zParentedTree.__init__cCsddlm}|S)Nr)ImmutableParentedTree)nltk.tree.immutabler=)r r=rrr _frozen_class5s zParentedTree._frozen_classFcs&|stj|jjdtjddS)NzB objects do not support shallow copies. Defaulting to a deep copy.T)deep)warningswarnrr#rcopy)r r@)rrrrC:szParentedTree.copycCs|jS)z5The parent of this tree, or None if it has no parent.)r<)r rrrparentEszParentedTree.parentcCsB|jdkrdSx"t|jD]\}}||kr|SqWds>tddS)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 AssertionError)r rrrrr parent_indexIs  zParentedTree.parent_indexcCs(|j}|jr$|dkr$|j|dSdS)z6The left sibling of this tree, or None if it has none.rrN)rFr<)r rFrrr left_siblingXszParentedTree.left_siblingcCs2|j}|jr.|t|jdkr.|j|dSdS)z7The right sibling of this tree, or None if it has none.rN)rFr<r)r rFrrr right_sibling_szParentedTree.right_siblingcCs"|}x|jdk r|j}qW|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)rD)r rootrrrrIfs zParentedTree.rootcCs*|jdkrfS|jj|jfSdS)z The tree position of this tree, relative to the root of the tree. I.e., ``ptree.root[ptree.treeposition] is ptree``. N)rD treepositionrF)r rrrrJqs zParentedTree.treepositioncCs6t|tst|||kst|j|ks,td|_dS)N)r r;rEr<)r rrrrrrszParentedTree._delparentcCs<t|tstdt|dr.|jdk r.td|s8||_dS)Nz5Can not insert a non-ParentedTree into a ParentedTreer<z3Can not insert a subtree that already has a parent.)r r;r!r8r< ValueError)r rrrrrrr s  zParentedTree._setparent)N)F)F)r#r5r6r7r r?rCrDrFrGrHrIrJrr r9rr)rrr;s   r;cs|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. NcsRg|_tj|||dkrNx0t|D]$\}}t|tr&g|_|j||q&WdS)N)_parentsrr r r rr )r rrrr)rrrr s zMultiParentedTree.__init__cCsddlm}|S)Nr)ImmutableMultiParentedTree)r>rN)r rNrrrr?s zMultiParentedTree._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) )rrM)r rrrparentss zMultiParentedTree.parentscCsdd|jDS)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)rrr).0rDrrrr sz3MultiParentedTree.left_siblings..)_get_parent_indices)r rrr left_siblingss zMultiParentedTree.left_siblingscCsdd|jDS)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)rPrDrrrrrQsz4MultiParentedTree.right_siblings..)rR)r rrrright_siblingss z MultiParentedTree.right_siblingscsfddjDS)Ncs.g|]&}t|D]\}}|kr||fqqSr)r )rPrDrr)r rrrQsz9MultiParentedTree._get_parent_indices..)rM)r r)r rrRs z%MultiParentedTree._get_parent_indicescCst|jijS)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_helpervalues)r rrrrootsszMultiParentedTree.rootscCs2|jr"x&|jD]}|j|qWn ||t|<|S)N)rMrUid)r resultrDrrrrUs   z#MultiParentedTree._get_roots_helpercs(|jkrgSfddt|DSdS)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|]\}}|kr|qSrr)rPrr)r rrrQsz4MultiParentedTree.parent_indices..N)rMr )r rDr)r rparent_indicess z MultiParentedTree.parent_indicescs(krfgSfddjDSdS)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 cs@g|]8}|jD](}t|D]\}}|kr||fqqqSr) treepositionsr )rPrDZtreeposrr)rIr rrrQ"sz3MultiParentedTree.treepositions..N)rM)r rIr)rIr rr[s  zMultiParentedTree.treepositionscsvt|tst||ksttfdd|jDdks>tx2tD]\}}||krH||krHPqHW|jjdS)Ncsg|]}|kr|qSrr)rPp)r rrrQ1sz0MultiParentedTree._delparent..r)r rLrErrMr r-)r rrrcr)r rr-s zMultiParentedTree._delparentFcCs@t|tstd|s s  7