/hSrSSKrSSKrSSKJr SSKJrJr SSKJ r J r J r J r J r \"SS\ 55rSrS rSOS jr"S S \\5r"S S\\5rSPSjrSrSPSjrSrSPSjrSrSQSjrSrSrSPSjrSr "SS5r!\!"5r"SRSjr#"SS\$5r%S r&S!r'S"r(S#r)S$r*S%r+S&r,S'r-S(r.S)r/S*r0S+r1SSS,jr2S-r3S.r4S/r5"S0S1\ 5r6"S2S3\6\75r8"S4S5\6\95r:"S6S7\6\95r;"S8S9\6\75r"S=S>\>5r?"S?S@\>5r@\?"SASSASB9rA\>"SCSDSE9rB\"SFSG55rC"SHSI5rDSTSJjrESUSKjrFSUSLjrG\HSM:Xa\G"5 /SNQrIg)VaY Basic data classes for representing feature structures, and for performing basic operations on those feature structures. A feature structure is a mapping from feature identifiers to feature values, where each feature value is either a basic value (such as a string or an integer), or a nested feature structure. There are two types of feature structure, implemented by two subclasses of ``FeatStruct``: - feature dictionaries, implemented by ``FeatDict``, act like Python dictionaries. Feature identifiers may be strings or instances of the ``Feature`` class. - feature lists, implemented by ``FeatList``, act like Python lists. Feature identifiers are integers. Feature structures are typically used to represent partial information about objects. A feature identifier that is not mapped to a value stands for a feature whose value is unknown (*not* a feature without a value). Two feature structures that represent (potentially overlapping) information about the same object can be combined by unification. When two inconsistent feature structures are unified, the unification fails and returns None. Features can be specified using "feature paths", or tuples of feature identifiers that specify path through the nested feature structures to a value. Feature structures may contain reentrant feature values. A "reentrant feature value" is a single feature value that can be accessed via multiple feature paths. Unification preserves the reentrance relations imposed by both of the unified feature structures. In the feature structure resulting from unification, any modifications to a reentrant feature value will be visible using any of its feature paths. Feature structure variables are encoded using the ``nltk.sem.Variable`` class. The variables' values are tracked using a bindings dictionary, which maps variables to their values. When two feature structures are unified, a fresh bindings dictionary is created to track their values; and before unification completes, all bound variables are replaced by their values. Thus, the bindings dictionaries are usually strictly internal to the unification process. However, it is possible to track the bindings of variables if you choose to, by supplying your own initial bindings dictionary to the ``unify()`` function. When unbound variables are unified with one another, they become aliased. This is encoded by binding one variable to the other. Lightweight Feature Structures ============================== Many of the functions defined by ``nltk.featstruct`` can be applied directly to simple Python dictionaries and lists, rather than to full-fledged ``FeatDict`` and ``FeatList`` objects. In other words, Python ``dicts`` and ``lists`` can be used as "light-weight" feature structures. >>> from nltk.featstruct import unify >>> unify(dict(x=1, y=dict()), dict(a='a', y=dict(b='b'))) # doctest: +SKIP {'y': {'b': 'b'}, 'x': 1, 'a': 'a'} However, you should keep in mind the following caveats: - Python dictionaries & lists ignore reentrance when checking for equality between values. But two FeatStructs with different reentrances are considered nonequal, even if all their base values are equal. - FeatStructs can be easily frozen, allowing them to be used as keys in hash tables. Python dictionaries and lists can not. - FeatStructs display reentrance in their string representations; Python dictionaries and lists do not. - FeatStructs may *not* be mixed with Python dictionaries and lists (e.g., when performing unification). - FeatStructs provide a number of useful methods, such as ``walk()`` and ``cyclic()``, which are not available for Python dicts and lists. In general, if your feature structures will contain any reentrances, or if you plan to use them as dictionary keys, it is strongly recommended that you use full-fledged ``FeatStruct`` objects. N)total_ordering)raise_unorderable_typesread_str) ExpressionLogicalExpressionException LogicParserSubstituteBindingsIVariablec^\rSrSrSrSrS$U4SjjrSrSrSr S%Sjr S r S r S r S rS rSrSrSrSrSrS&SjrSrSrSrSrSrSrSrSrSrS'SjrSrS(Sjr S r!S!r"S"r#S#r$U=r%$)) FeatStructna A mapping from feature identifiers to feature values, where each feature value is either a basic value (such as a string or an integer), or a nested feature structure. There are two types of feature structure: - feature dictionaries, implemented by ``FeatDict``, act like Python dictionaries. Feature identifiers may be strings or instances of the ``Feature`` class. - feature lists, implemented by ``FeatList``, act like Python lists. Feature identifiers are integers. Feature structures may be indexed using either simple feature identifiers or 'feature paths.' A feature path is a sequence of feature identifiers that stand for a corresponding sequence of indexing operations. In particular, ``fstruct[(f1,f2,...,fn)]`` is equivalent to ``fstruct[f1][f2]...[fn]``. Feature structures may contain reentrant feature structures. A "reentrant feature structure" is a single feature structure object that can be accessed via multiple feature paths. Feature structures may also be cyclic. A feature structure is "cyclic" if there is any feature path from the feature structure to itself. Two feature structures are considered equal if they assign the same values to all features, and have the same reentrancies. By default, feature structures are mutable. They may be made immutable with the ``freeze()`` method. Once they have been frozen, they may be hashed, and thus used as dictionary keys. Fc >>U[LGaUc[R"[40UD6$[U5(a[R"[U40UD6$U(a [ S5e[ U[ 5(a\[RRU5(a[R"[U40UD6$[R"[U40UD6$[U5(a[R[U5$[ S5e[TU]"X40UD6$)ao Construct and return a new feature structure. If this constructor is called directly, then the returned feature structure will be an instance of either the ``FeatDict`` class or the ``FeatList`` class. :param features: The initial feature values for this feature structure: - FeatStruct(string) -> FeatStructReader().read(string) - FeatStruct(mapping) -> FeatDict(mapping) - FeatStruct(sequence) -> FeatList(sequence) - FeatStruct() -> FeatDict() :param morefeatures: If ``features`` is a mapping or None, then ``morefeatures`` provides additional features for the ``FeatDict`` constructor. zLKeyword arguments may only be specified if features is None or is a mapping.z&Expected string or mapping or sequence) r FeatDict__new__ _is_mapping TypeError isinstancestrFeatStructReader_START_FDICT_REmatchFeatList _is_sequencesuper)clsfeatures morefeatures __class__s G/var/www/auris/envauris/lib/python3.13/site-packages/nltk/featstruct.pyrFeatStruct.__new__s* * ''ALAAX&&''(KlKK;(C((#3399(CC#++HhO,OO#++HhO,OOh''''(;; HII7?3ALA Ac[5e)zFReturn an iterable of the feature identifiers used by this FeatStruct.NotImplementedErrorselfs r_keysFeatStruct._keys "##r!c[5e)zMReturn an iterable of the feature values directly defined by this FeatStruct.r#r%s r_valuesFeatStruct._valuesr)r!c[5e)zReturn an iterable of (fid,fval) pairs, where fid is a feature identifier and fval is the corresponding feature value, for all features defined by this FeatStruct.r#r%s r_itemsFeatStruct._itemss "##r!cZURX[5[5[55$)a Return True if ``self`` and ``other`` assign the same value to to every feature. In particular, return true if ``self[p]==other[p]`` for every feature path *p* such that ``self[p]`` or ``other[p]`` is a base value (i.e., not a nested feature structure). :param check_reentrance: If True, then also return False if there is any difference between the reentrances of ``self`` and ``other``. :note: the ``==`` is equivalent to ``equal_values()`` with ``check_reentrance=True``. _equalset)r&othercheck_reentrances r equal_valuesFeatStruct.equal_valuess{{5CE35#%HHr!c\URUS[5[5[55$)z Return true if ``self`` and ``other`` are both feature structures, assign the same values to all features, and contain the same reentrances. I.e., return ``self.equal_values(other, check_reentrance=True)``. :see: ``equal_values()`` Tr1r&r4s r__eq__FeatStruct.__eq__s!{{5$suce<>**U__-E-EE Et9s5z) )r!cUR(d [S5eUR$![a- UR [ 55UlURs$f=f)z] If this feature structure is frozen, return its hash value; otherwise, raise ``TypeError``. z5FeatStructs must be frozen before they can be hashed.)_frozenr_hashAttributeError_calculate_hashvaluer3r%s r__hash__FeatStruct.__hash__ sS ||VW W ::  22359DJ::  s *4A! A!cXLagURUR:wag[U5[U5:wag[UR55[UR55:wagU(a8[ U5U;d[ U5U;a[ U5[ U54U;$O[ U5[ U54U;agUR [ U55 UR [ U55 UR [ U5[ U545 UR 5HCupgXn[U[5(aURUUUUU5(d gM<Xx:wdMC g g)a Return True iff self and other have equal values. :param visited_self: A set containing the ids of all ``self`` feature structures we've already visited. :param visited_other: A set containing the ids of all ``other`` feature structures we've already visited. :param visited_pairs: A set containing ``(selfid, otherid)`` pairs for all pairs of feature structures we've already visited. TF) rrDr3r'idaddr.rr r2) r&r4r5 visited_self visited_other visited_pairsfname self_fval other_fvals rr2FeatStruct._equalsQ = >>U__ , t9E " tzz| EKKM 2 2 $x<'2e9 +E4"U), ==,F4"U)$ 5 D""U)$2d8RY/0!% EJ)Z00 ''$ !! !* !. r!c\[U5U;agUR[U55 Sn[UR55Hbup4US-nU[ U5- nUS-n[ U[ 5(aX$RU5- nOU[ U5- n[US-5nMd U$)z Return a hash value for this feature structure. :require: ``self`` must be frozen. :param visited: A set containing the ids of all feature structures we've already visited while hashing. i%i) rOrPsortedr.hashrr rKint)r&visitedhashvalrTfvals rrKFeatStruct._calculate_hashvalue]s d8w  BtH!$++-0KE rMG tE{ "G rMG$ ++44W==4:%'J./G1r!'Frozen FeatStructs may not be modified.cZUR(agUR[55 g)z Make this feature structure, and any feature structures it contains, immutable. Note: this method does not attempt to 'freeze' any feature value that is not a ``FeatStruct``; it is recommended that you use only immutable feature values. N)rH_freezer3r%s rfreezeFeatStruct.freeze~s <<  SUr!cUR$)z Return True if this feature structure is immutable. Feature structures can be made immutable with the ``freeze()`` method. Immutable feature structures may not be made mutable again, but new mutable copies can be produced with the ``copy()`` method. )rHr%s rfrozenFeatStruct.frozens||r!c[U5U;agUR[U55 SUl[UR 55H-up#[ U[ 5(dMURU5 M/ g)z Make this feature structure, and any feature structure it contains, immutable. :param visited: A set containing the ids of all feature structures we've already visited while freezing. NT)rOrPrHr[r.rr rd)r&r^rTr`s rrdFeatStruct._freezesZ d8w   BtH !$++-0KE$ ++ W%1r!c^U(a[R"U5$URU5$)z Return a new copy of ``self``. The new copy will not be frozen. :param deep: If true, create a deep copy; if false, create a shallow copy. )copydeepcopyr)r&deeps rrmFeatStruct.copys% ==& &>>$' 'r!c[5er=r#)r&memos r __deepcopy__FeatStruct.__deepcopy__s !##r!c<UR05[U5$)z8 Return True if this feature structure contains itself. )_find_reentrancesrOr%s rcyclicFeatStruct.cyclics%%b)"T(33r!c4UR[55$)z Return an iterator that generates this feature structure, and each feature structure it contains. Each feature structure will be generated exactly once. )_walkr3r%s rwalkFeatStruct.walks zz#%  r!c[5e)z Return an iterator that generates this feature structure, and each feature structure it contains. :param visited: A set containing the ids of all feature structures we've already visited while freezing. r#)r&r^s rrzFeatStruct._walks "##r!c## [U5U;agUR[U55 Uv UR5H3n[U[5(dMUR U5ShvN M5 gN 7fr=)rOrPr+rr rz)r&r^r`s rrzr~s[ d8w   BtH LLND$ ++::g...#.sAA;A;/A90 A;c[U5U;aSU[U5'U$SU[U5'UR5H+n[U[5(dMUR U5 M- U$)z Return a dictionary that maps from the ``id`` of each feature structure contained in ``self`` (including ``self``) to a boolean value, indicating whether it is reentrant or not. TF)rOr+rr rv)r& reentrancesr`s rrvFeatStruct._find_reentrancessk d8{ "$(K4 !%*K4 ! dJ//**;7'r!c[X5$)z/:see: ``nltk.featstruct.substitute_bindings()``)substitute_bindingsr&bindingss rrFeatStruct.substitute_bindingss "422r!c[X5$)z,:see: ``nltk.featstruct.retract_bindings()``)retract_bindingsrs rrFeatStruct.retract_bindingss //r!c[U5$)z*:see: ``nltk.featstruct.find_variables()``)find_variablesr%s r variablesFeatStruct.variabless d##r!c[XX#5$)z,:see: ``nltk.featstruct.rename_variables()``)rename_variables)r&vars used_varsnew_varss rrFeatStruct.rename_variablessI@@r!c[U5$)zz Return the feature structure that is obtained by deleting any feature whose value is a ``Variable``. :rtype: FeatStruct )remove_variablesr%s rrFeatStruct.remove_variabless %%r!c[XX#XE5$r=unify)r&r4rtracefail rename_varss rrFeatStruct.unifysT(4EEr!c[X5$)z Return True if ``self`` subsumes ``other``. I.e., return true If unifying ``self`` with ``other`` would result in a feature structure equal to ``other``. )subsumesr9s rrFeatStruct.subsumess $$r!cDURUR0505$)zr Display a single-line representation of this feature structure, suitable for embedding in other representations. )_reprrvr%s r__repr__FeatStruct.__repr__#s zz$004b99r!c[5e)a Return a string representation of this feature structure. :param reentrances: A dictionary that maps from the ``id`` of each feature value in self, indicating whether that value is reentrant or not. :param reentrance_ids: A dictionary mapping from each ``id`` of a feature value to a unique identifier. This is modified by ``repr``: the first time a reentrant feature value is displayed, an identifier is added to ``reentrance_ids`` for it. r#)r&rreentrance_idss rrFeatStruct._repr*s "##r!)rHrIr=F)T)Nr>N)NFNT)&rC __module__ __qualname____firstlineno____doc__rHrr'r+r.r6r:r?rErLr2rK _FROZEN_ERRORrerhrdrmrsrwr{rzrvrrrrrrrrr__static_attributes__ __classcell__)rs@rr r ns@G+Bh$ $ $I =!* EN>>M &( ($4 !$/030$A&F%: $ $r!r rbz' %sIf self is frozen, raise ValueError.c~^U4SjnTRUlTR=(d S[U--UlU$)z Given a method function, return a new method function that first checks if ``self._frozen`` is true; and if so, raises ``ValueError`` with an appropriate message. Otherwise, call the method and return its result. c\>UR(a[[5eT"U/UQ70UD6$r=)rH ValueErrorr)r&argskwargsmethods rwrapped_check_frozen..wrappedFs* <<]+ +$000 0r!)rCr_FROZEN_NOTICE)rindentrs` r _check_frozenr>s51 G~~+0GHGO Nr!c\rSrSrSrSSjrSrSrSSjrSr S r S r S r \ "\R5r\ "\R 5r\ "\R"5r\ "\R$5rSS jrS rSrSrSrSrSrSrSrg)riVaz A feature structure that acts like a Python dictionary. I.e., a mapping from feature identifiers to feature values, where a feature identifier can be a string or a ``Feature``; and where a feature value can be either a basic value (such as a string or an integer), or a nested feature structure. A feature identifiers for a ``FeatDict`` is sometimes called a "feature name". Two feature dicts are considered equal if they assign the same values to all features, and have the same reentrances. :see: ``FeatStruct`` for information about feature paths, reentrance, cyclic feature structures, mutability, freezing, and hashing. Nc [U[5(a,[5RX5 UR"S0UD6 gUR"U40UD6 g)a Create a new feature dictionary, with the specified features. :param features: The initial value for this feature dictionary. If ``features`` is a ``FeatStruct``, then its features are copied (shallow copy). If ``features`` is a dict, then a feature is created for each item, mapping its key to its value. If ``features`` is a string, then it is processed using ``FeatStructReader``. If ``features`` is a list of tuples ``(name, val)``, then a feature is created for each tuple. :param morefeatures: Additional features for the new feature dictionary. If a feature is listed under both ``features`` and ``morefeatures``, then the value from ``morefeatures`` will be used. Nr>)rrr fromstringupdate)r&rrs r__init__FeatDict.__init__fsD h $ $   ) )( 9 KK ', ' KK 1L 1r!z'Expected feature name or path. Got %r.c^[U[[45(a[R X5$[U[ 5(a-UnUH"n[U[ 5(d[eX#nM$ U$[URU-5e![[4an[U5UeSnAff=f)zcIf the feature with the given name or path exists, return its value; otherwise, raise ``KeyError``.N) rrFeaturedict __getitem__tupler KeyError IndexErrorr _INDEX_ERRORr& name_or_pathvalfides rrFeatDict.__getitem__s lS'N 3 3##D7 7  e , , 4'C%c:66&(C( D-- <= =j) 4|,!3 4s+B B, B''B,c0X$![a Us$f=f)zcIf the feature with the given name or path exists, return its value; otherwise, return ``default``.r)r&rdefaults rget FeatDict.gets$ % % N s  c.X g![a gf=f)rs rhas_keyFeatDict.has_keys ##r!cUR(a[[5e[U[[ 45(a[ RX5$[U[5(aG[U5S:Xa [S5eXSSn[U[5(d [U5eX!S g[URU-5ezcIf the feature with the given name or path exists, delete its value; otherwise, raise ``KeyError``.rThe path () can not be setN)rHrrrrrr __delitem__rrDr rrrr&rparents rrFeatDict.__delitem__s <<]+ + lS'N 3 3##D7 7  e , ,< A% !=>>3B/0!&*55"<00+,D-- <= =r!cUR(a[[5e[U[[ 45(a[ RXU5$[U[5(aI[U5S:Xa [S5eXSSn[U[5(d [U5eX#US'g[URU-5ezSet the value for the feature with the given name or path to ``value``. If ``name_or_path`` is an invalid path, raise ``KeyError``.rrNr)rHrrrrrr __setitem__rrDr rrrr&rvaluers rrFeatDict.__setitem__s <<]+ + lS'N 3 3##D> >  e , ,< A% !=>>3B/0!&*55"<00+0|B'(D-- <= =r!c UR(a[[5eUcSnO[[US5(a+[ UR 5(aUR 5nO[US5(aUnO [S5eUH/upE[ U[[45(d [S5eXPU'M1 UR 5H/upE[ U[[45(d [S5eXPU'M1 g)Nr>items__iter__z"Expected mapping or list of tupleszFeature names must be strings) rHrrhasattrcallablerrrrr)r&rrrkeyrs rrFeatDict.updates <<]+ +  E Xw ' 'HX^^,D,DNN$E Xz * *EAB BHCcC>22 ?@@I%**,HCcC>22 ?@@I-r!cUR5=U[U5'nUR5H2up4[R"XA5U[R"X15'M4 U$r=)rrOr.rmrn)r&rrselfcopyrrs rrsFeatDict.__deepcopy__sN$(NN$44RX HC15s1IHT]]3- .&r!c"UR5$r=)keysr%s rr'FeatDict._keyssyy{r!c"UR5$r=)valuesr%s rr+FeatDict._valuess{{}r!c"UR5$r=)rr%s rr.FeatDict._itemsszz|r!cbSRURUR05055$)zb Display a multi-line representation of this feature dictionary as an FVM (feature value matrix).  )join_strrvr%s r__str__FeatDict.__str__s) yy4#9#9"#=rBCCr!c /nSnSnU[U5(a4[U5U;de[[U5S-5U[U5'[UR 55GHupg[ USS5n[U5U;a%UR USU[U5S35 MGUS:Xa)U(d"[U[[45(aSU-nMvUS:Xa=U(d6[U[5(aS UR-nMS [U5-nM[U[5(a"UR US UR35 MUS LaUR S U-5 GM US LaUR SU-5 GM([U[5(aUR USUS35 GMW[U[5(d"UR US [U535 GMURX5n UR US U 35 GM U[U5(aSU[U5SU3nSRUSRU5U5$)NrrYdisplayz->()prefix%sslashz/%s=Tz+%sFz-%sz=<>(z{}[{}]{}, )rOreprrDr[rgetattrappendrr rnamerr rformatr) r&rrsegmentsrsuffixrTr`r fval_reprs rrFeatDict._repr s  r$x d8>1 11'+C,?!,C'DN2d8 $"$**,/KEeY5G$x>)5'^BtH-E,Fa HI8#Fz$SV7X7XG#FdH--"TYY.F"T$Z/FD(++5'499+ 67 . .D*--5'D6 34j115'4:, 78 JJ{C 5'9+ 67306 r$x 412!F8# UHn[SU-5v M g7frNrD).0ks r FeatDict._str..Ps=A#dQh--srz = z = (rrr z =Nc38# UHn[U5v M g7fr=r)rlines rrrs154SYY5sz[ {}{} ]z(%s) )rOrrDmaxrr[rljustrr rrrrrrrpopr)r&rr maxfnamelenlinesrTr`r fval_lineslnamelinemaxlenr#idstridlines rr FeatDict._str5s r$x d8>1 11'+C,?!,C'DN2d8 $ t9>2d8$!N2d8$<<==v === "$**,/KEE\((5E$)) wc$))56D*-- wd4&23D(++ JJ{C  wc$y/):;<h// wc$t*67D^+ weN2d8,D+EQGH U2Y"_LL$"YY{C FPPZskAo6!;Z P Oa/A5DL:#7 a8I#JJ$ # R W0\ 9? IIK1511QVWQV""4T0B)CDQVW r$x nRX66E5:;UcCJ&!+UE;%j1n*F!&M#e*,$??EM ;Q(X $+M9Mr>r=)rCrrrrrrrrrrrrrrclearr&popitem setdefaultrrsr'r+r.rrrrr>r!rrrVs 24=L>$$>$>& $** %E  !CDLL)Gt/J2D*FX\r!rc\rSrSrSrSSjrSrSrSrSr \ "\ R5r \ "\ R5r \ "\ R5r\ "\ R5r\ "\ R 5r\ "\ R"5r\ "\ R$5r\ "\ R&5r\ "\ R(5rS rS rS rS rS rSrg)riaM A list of feature values, where each feature value is either a basic value (such as a string or an integer), or a nested feature structure. Feature lists may contain reentrant feature values. A "reentrant feature value" is a single feature value that can be accessed via multiple feature paths. Feature lists may also be cyclic. Two feature lists are considered equal if they assign the same values to all features, and have the same reentrances. :see: ``FeatStruct`` for information about feature paths, reentrance, cyclic feature structures, mutability, freezing, and hashing. r>c[U[5(a[5RX5 g[R X5 g)a* Create a new feature list, with the specified features. :param features: The initial list of features for this feature list. If ``features`` is a string, then it is paresd using ``FeatStructReader``. Otherwise, it should be a sequence of basic values and nested feature structures. N)rrrrlistr)r&rs rrFeatList.__init__s. h $ $   ) )( 9 MM$ )r!z&Expected int or feature path. Got %r.cR[U[5(a[RX5$[U[5(a-UnUH"n[U[ 5(d[ eX#nM$ U$[URU-5e![ [4an[ U5UeSnAff=fr=) rr]r5rrr rrrrrs rrFeatList.__getitem__s lC ( (##D7 7  e , , 4'C%c:66&(C( D-- <= =j) 4|,!3 4s+BB& B!!B&cUR(a[[5e[U[[ 45(a[ RX5$[U[5(aG[U5S:Xa [S5eXSSn[U[5(d [U5eX!S g[URU-5er)rHrrrr]slicer5rrrDr rrrrs rrFeatList.__delitem__s <<]+ + lS%L 1 1##D7 7  e , ,< A% !=>>3B/0!&*55"<00+,D-- <= =r!cUR(a[[5e[U[[ 45(a[ RXU5$[U[5(aI[U5S:Xa [S5eXSSn[U[5(d [U5eX#US'g[URU-5er)rHrrrr]r:r5rrrDr rrrrs rrFeatList.__setitem__s <<]+ + lS%L 1 1##D> >  e , ,< A% !=>>3B/0!&*55"<00+0|B'(D-- <= =r!cz^UR5=T[U5'nURU4SjU55 U$)Nc3R># UHn[R"UT5v M g7fr=)rmrn)rr`rrs rr(FeatList.__deepcopy__..sCdd dD11ds$')rrOextend)r&rrrs ` rrsFeatList.__deepcopy__s3$(NN$44RXCdCCr!c<[[[U555$r=)r5rangerDr%s rr'FeatList._keys sE#d)$%%r!cU$r=r>r%s rr+FeatList._valuess r!c[U5$r=) enumerater%s rr.FeatList._itemss r!cU[U5(aF[U5U;de[[U5S-5U[U5'SU[U5-nOSn/nUHn[U5U;a"URSU[U5-5 M4[ U[ 5(aURUR 5 Mf[ U[5(aURSU-5 M[ U[5(a"URURX55 MURS[U5-5 M SRUSRU55$)NrY(%s)rz->(%s)rz{}[{}]r ) rOrrDrrr rrr rrr)r&rrrrr`s rrFeatList._reprs r$x d8>1 11'+C,?!,C'DN2d8 $nRX66FFD$x>)>"T(+C CDD(++ *D*--t ,D*-- ; GHtDz 12vtyy':;;r!N)r>)rCrrrrrrrrrrr5__iadd____imul__rrAinsertr&removereversesortrsr'r+r.rrr>r!rrrs *" >$>*T]]+HT]]+H 4;; 'F 4;; 'F 4;; 'F  !C 4;; 'FDLL)G  #D & any) :param bindings: A dictionary mapping from variables to values. r)_default_fs_classrmrn_substitute_bindingsr3)fstructrfs_classs rrr8s79$W-mmG$GHce< Nr!c [U5U;agUR[U55 [U5(aUR5nO'[ U5(a [ U5nO [ S5eUHupV[U[5(a)Xa;a$X=o`U'[U[5(aXa;aM$[Xb5(a[XaX#5 Ma[U[5(dMxURU5X'M gNExpected mapping or sequence) rOrPrrrrIrrr rVr r)rWrrXr^rrTr`s rrVrVJs '{g KK7 7  g  '"788 x((T-=$,N 2D5>x((T-= d % %  C 1 2 2!55h?GN r!cUS:Xa [U5n[R"X45upURU5 UR 5VVs0sHupE[ U5U_M nnn[ XU[55 U$s snnf)a Return the feature structure that is obtained by replacing each feature structure value that is bound by ``bindings`` with the variable that binds it. A feature structure value must be identical to a bound value (i.e., have equal id) to be replaced. ``bindings`` is modified to point to this new feature structure, rather than the original feature structure. Feature structure values in ``bindings`` may be modified if they are contained in ``fstruct``. r)rUrmrnrrrO_retract_bindingsr3)rWrrX new_bindingsvarr inv_bindingss rrr_sv9$W-"mmW,?@W OOL!3;>>3CD3CZcBsGSL3CLDgXsu= NEsBcx[U5U;agUR[U55 [U5(aUR5nO'[ U5(a [ U5nO [ S5eUHBupV[Xb5(dM[U5U;aU[U5X'[XaX#5 MD grZ) rOrPrrrrIrrr])rWr`rXr^rrTr`s rr]r]ts '{g KK7 7  g  '"788  d % %$x<'!-bh!7 d( D r!c`US:Xa [U5n[U[5U[55$)zU :return: The set of variables used by this feature structure. :rtype: set(Variable) r)rU _variablesr3rWrXs rrrs+ 9$W- gsuh 66r!c[U5U;agUR[U55 [U5(aUR5nO'[ U5(a [ U5nO [ S5eUHupV[U[5(aURU5 M-[Xb5(a[XaX#5 MK[U[5(dMbURUR55 M U$rZ) rOrPrrrrIrrr rcr rr)rWrrXr^rrTr`s rrcrcs '{g KK7 7  g  '"788  dH % % HHTN  ' ' t8 5 1 2 2 KK( )  Kr!c US:Xa [U5nUc0nUc [X5nO [U5n[X5RU5n[ [ R "U5XX4[55$)a Return the feature structure that is obtained by replacing any of this feature structure's variables that are in ``vars`` with new variables. The names for these new variables will be names that are not used by any variable in ``vars``, or in ``used_vars``, or in this feature structure. :type vars: set :param vars: The set of variables that should be renamed. If not specified, ``find_variables(fstruct)`` is used; i.e., all variables will be given new names. :type used_vars: set :param used_vars: A set of variables whose names should not be used by the new variables. :type new_vars: dict(Variable -> Variable) :param new_vars: A dictionary that is used to hold the mapping from old variables to new variables. For each variable *v* in this feature structure: - If ``new_vars`` maps *v* to *v'*, then *v* will be replaced by *v'*. - If ``new_vars`` does not contain *v*, but ``vars`` does contain *v*, then a new entry will be added to ``new_vars``, mapping *v* to the new variable that is used to replace it. To consistently rename the variables in a set of feature structures, simply apply rename_variables to each one, using the same dictionary: >>> from nltk.featstruct import FeatStruct >>> fstruct1 = FeatStruct('[subj=[agr=[gender=?y]], obj=[agr=[gender=?y]]]') >>> fstruct2 = FeatStruct('[subj=[agr=[number=?z,gender=?y]], obj=[agr=[number=?z,gender=?y]]]') >>> new_vars = {} # Maps old vars to alpha-renamed vars >>> fstruct1.rename_variables(new_vars=new_vars) [obj=[agr=[gender=?y2]], subj=[agr=[gender=?y2]]] >>> fstruct2.rename_variables(new_vars=new_vars) [obj=[agr=[gender=?y2, number=?z2]], subj=[agr=[gender=?y2, number=?z2]]] If new_vars is not specified, then an empty dictionary is used. r)rUrr3union_rename_variablesrmrn)rWrrrrXs rrrsvX9$W- |g04yw177 BI  gSU r!c [U5U;agUR[U55 [U5(aUR5nO'[ U5(a [ U5nO [ S5eUHupx[U[5(a<X;aX8X'M'X;a([X5X8'X8X'URX85 MTMV[X5(a[XX#XE5 Mu[U[5(dMUR5H1n X;dM X;dM[X5X9'URX95 M3 URU5X'M U$rZ)rOrPrrrrIrrr _rename_variablerhr rr) rWrrrrXr^rrTr`r_s rrhrhs$ '{g KK7 7  g  '"788  dH % %!)!1$!B!) hn- ' ' d)x Q 1 2 2~~';3#6$4S$DHMMM(-0( "55h?GN'( Nr!c[R"SSUR5Sp2U(dSn[UU35U;aUS- n[UU35U;aM[UU35$)Nz\d+$rr!?rY)resubrr )r_rrns rrjrjsjffWb#((+Q!  dVA3< I - Q dVA3< I - tfQCL !!r!cvUS:Xa [U5n[[R"U5U[ 55$)z :rtype: FeatStruct :return: The feature structure that is obtained by deleting all features whose values are ``Variables``. r)rU_remove_variablesrmrnr3rds rrrs0 9$W- T]]73Xsu EEr!c[U5U;agUR[U55 [U5(a[UR 55nO0[ U5(a[[ U55nO [S5eUH<upE[U[5(aX M[XQ5(dM0[XQU5 M> U$rZ) rOrPrr5rrrIrrr rq)rWrXr^rrTr`s rrqrqs '{g KK7 7W]]_% g  Yw'(788  dH % %  ' ' dg 6  Nr!c\rSrSrSrSrg)_UnificationFailurei4cg)Nz"nltk.featstruct.UnificationFailurer>r%s rr_UnificationFailure.__repr__5s3r!r>N)rCrrrrrr>r!rrtrt4s4r!rtFc US:Xa%[U5n[U5U:wa [S5e[X5(de[X5(deUSLnUc0n[R"XU45upn UR U 5 U(a-[ X5n [ X5n [XU 0U[55 0n U(a [SX5 [XX-X4US5nU[La UcgU"XS5$[XU[55nU(a [X5 [U5 [!XU[55 U(a [#SU5 U(a [%SU5 U$![a gf=f)a Unify ``fstruct1`` with ``fstruct2``, and return the resulting feature structure. This unified feature structure is the minimal feature structure that contains all feature value assignments from both ``fstruct1`` and ``fstruct2``, and that preserves all reentrancies. If no such feature structure exists (because ``fstruct1`` and ``fstruct2`` specify incompatible values for some feature), then unification fails, and ``unify`` returns None. Bound variables are replaced by their values. Aliased variables are replaced by their representative variable (if unbound) or the value of their representative variable (if bound). I.e., if variable *v* is in ``bindings``, then *v* is replaced by ``bindings[v]``. This will be repeated until the variable is replaced by an unbound variable or a non-variable value. Unbound variables are bound when they are unified with values; and aliased when they are unified with variables. I.e., if variable *v* is not in ``bindings``, and is unified with a variable or value *x*, then ``bindings[v]`` is set to *x*. If ``bindings`` is unspecified, then all variables are assumed to be unbound. I.e., ``bindings`` defaults to an empty dict. >>> from nltk.featstruct import FeatStruct >>> FeatStruct('[a=?x]').unify(FeatStruct('[b=?x]')) [a=?x, b=?x2] :type bindings: dict(Variable -> any) :param bindings: A set of variable bindings to be used and updated during unification. :type trace: bool :param trace: If true, generate trace output. :type rename_vars: bool :param rename_vars: If True, then rename any variables in ``fstruct2`` that are also used in ``fstruct1``, in order to avoid collisions on variable names. rzGMixing FeatStruct objects with Python dicts and lists is not supported.Nr>)rUrrrmrnrrrhr3_trace_unify_start_destructively_unify_UnificationFailureErrorUnificationFailure_apply_forwards_apply_forwards_to_bindings_resolve_aliasesrV_trace_unify_succeed_trace_bindings)fstruct1fstruct2rrrrrX user_bindings fstruct1copy fstruct2copy bindings_copyvars1vars2forwardresults rrrDs~j9$X. X &( 24  h ) )) ) h ) )) )D(M37-- X&3/\  OOM"|6|6,ub(CEJG 2|:% 5RT ## < B7 7Vh >F#G6X8SU; R( H% M5 $sE## E0/E0c\rSrSrSrSrg)rziziAn exception that is used by ``_destructively_unify`` to abort unification when a failure is encountered.r>N)rCrrrrrr>r!rrzrzs2r!rzc ~XLaU(a [Xp5 U$X[U5'[U5(a[U5(aUH.n[USS5cMUR XR 5 M0 UH.n[USS5cMUR XR 5 M0 [ UR55H*upX;a[UXU UUUUUXx4-5 X'M&XU'M, U$[U5(ag[U5(aW[U5[U5:wa[$[[U55Hn [U X XUUUUUXz4-5 X 'M! U$[U5(d[U5(a&[U5(d[U5(a[$[S5e)a Attempt to unify ``fstruct1`` and ``fstruct2`` by modifying them in-place. If the unification succeeds, then ``fstruct1`` will contain the unified value, the value of ``fstruct2`` is undefined, and forward[id(fstruct2)] is set to fstruct1. If the unification fails, then a _UnificationFailureError is raised, and the values of ``fstruct1`` and ``fstruct2`` are undefined. :param bindings: A dictionary mapping variables to values. :param forward: A dictionary mapping feature structures ids to replacement structures. When two feature structures are merged, a mapping from one to the other will be added to the forward dictionary; and changes will be made only to the target of the forward dictionary. ``_destructively_unify`` will always 'follow' any links in the forward dictionary for fstruct1 and fstruct2 before actually unifying them. :param trace: If true, generate trace output :param path: The feature path that led us to this unification step. Used for trace output. rNzExpected mappings or sequences)_trace_unify_identityrOrrr2rr[r_unify_feature_valuesrrDr{rDr) rrrrrrrXpathrTfval2findexs rryrys6  !$ 1 %BxL8X!6!6Eui.:##E==9Eui.:##E==9#8>>#34LE "7O8O ##(5  h  L$:$: x=CM )% %CM*F4  y  H + x K$9$9X+h"7"7!! 4 55r!c ~U(a [XU5 [U5U;aU[U5n[U5U;aM[U5U;aU[U5n[U5U;aMS=p[U[5(a'X;a"Un X1n[U[5(aX;aM"[U[5(a'X#;a"Un X2n[U[5(aX#;aM"[X5(a [X'5(a[ XX4XVXx5n GO[U[5(a"[U[5(a X:waXU'Un GOX[U[5(aX#U'Un GO;[U[5(aXU'Un GO[X5(d[X'5(a[ n O[U[ 5(aURXU5n O[U[5(aeURU5n [U[5(a>XRU5:wa*[SU<SU<SU <SURU5<35eO5[U[5(aURU5n OX:XaUn O[ n U [ LaU bXU 'U n U b X:waXU 'U n U [ La1Ub U"XU5n U(a[USSU 5 U [ La[e[X5(a[XU[55n U(a [X5 U(a[X5(a [!X5 U $)a Attempt to unify ``fval1`` and and ``fval2``, and return the resulting unified value. The method of unification will depend on the types of ``fval1`` and ``fval2``: 1. If they're both feature structures, then destructively unify them (see ``_destructively_unify()``. 2. If they're both unbound variables, then alias one variable to the other (by setting bindings[v2]=v1). 3. If one is an unbound variable, and the other is a value, then bind the unbound variable to the value. 4. If one is a feature structure, and the other is a base value, then fail. 5. If they're both base values, then unify them. By default, this will succeed if they are equal, and fail otherwise. NzCustomFeatureValue objects z and z# disagree about unification value: z vs. r)rxrOrr ryr{runify_base_valuesCustomFeatureValuerAssertionError_trace_unify_failrzr|r3rr) rTfval1rrrrrrXfpathfvar1fvar2rs rrr*s& 5/ U)w 5 " U)w  U)w 5 " U)w E UH % %%*; UH % %%*; UH % %%*; UH % %%*; %""z%'B'B% (U(  E8 $ $E8)D)D >#UO E8 $ $ E8 $ $ E $ $ 5(C(C# eW % %,,U8DF 1 2 2[['F%!344;;uCU9U$eVU[[-?A 1 2 2[['F~+ + + "( U^"(##  %.F  eCRj& 1 ' '* *&## (CEB U+ F--( Mr!cUR5H7up#[U5U;aU[U5n[U5U;aMX1U'M9 g){ Replace any feature structure that has a forward pointer with the target of its forward pointer (to preserve reentrancy). N)rrO)rrr_rs rr}r}sF nn& i7"BuI&Ei7" 'r!c[U5U;aU[U5n[U5U;aM[U5U;agUR[U55 [U5(aUR5nO'[ U5(a [ U5nO [ S5eUHUupV[Xb5(dM[U5U;aU[U5n[U5U;aMX`U'[XaX#5 MW U$)rNr[) rOrPrrrrIrrr|)rWrrXr^rrTr`s rr|r|s W+ "W+& W+  '{g KK7 7  g  '"788  d % %T(g%r$x(T(g%!EN D8 = Nr!cUR5HIup[U[5(dMX ;dM#X=o U'[U[5(dMBX ;aM&MK g)zx Replace any bound aliased vars with their binding; and replace any unbound aliased vars with their representative var. N)rrr )rr_rs rr~r~sK nn& ))e.?$,O 3ESM))e.?'r!cUS:Xa [S5 O[SRSU55n[SS[U5S- --S-5 [SS[U5S- --S U--5 [SS[U5--S -[U5-5 [SS[U5--S -[U5-5 g) Nr>z Unification trace:.c3,# UH nSU-v M g7frr>)rros rr%_trace_unify_start..s3dD1Hds | rY|z| Unify feature: %sz / z|\ )printrrD_trace_valrepr)rrrfullnames rrxrxs rz $%883d33 dVs4y1}--34 dVs4y1}--0E0PPQ $#d)# #e +nU.C CD $#d)# #f ,~e/D DEr!c[SS[U5--S-5 [SS[U5--S-5 [SS[U5--S-5 [SS[U5--S-[U5-5 g)Nrrrz| (identical objects)+-->rrDrrrs rrrsx $#d)# #c )* $#d)# #&= => $#d)# #c )* $#d)# #f ,tE{ :;r!cU[LaSnOSn[SS[U5--S-5 [SS[U5--S-U-5 g)Nrz (nonfatal)rrz| |zX zX X <-- FAIL)r{rrD)rrresumes rrrsQ ## $#d)# #g -. $#d)# #&6 6 ?@r!c[SS[U5--S-5 [SS[U5--S-[U5-5 g)Nrrrrrrs rrrsA $#d)# #c )* $#d)# #f ,tE{ :;r!c[U5S:aU[UR5SS9nSSRSU55-n[ SS[U5--S -U-5 gg) Nrc USR$)Nrrvs r!_trace_bindings..s 1Q499r!)r{%s}r c3F# UHupUS[U53v M g7f)z: N)r)rr_rs rr"_trace_bindings..s&% >G se2nS)* +is!rrz Bindings: )rDr[rrr)rr binditemsbindstrs rrrsl 8}q8>>+1DE 499% >G%    dVc$i''*::WDE r!cR[U[5(aSU-$S[U5-$)Nr)rr r)rs rrrs(#x  czd3ir!cU[X5:H$)z Return True if ``fstruct1`` subsumes ``fstruct2``. I.e., return true if unifying ``fstruct1`` with ``fstruct2`` would result in a feature structure equal to ``fstruct2.`` :rtype: bool r)rrs rrr s uX0 00r!c,^/mU4Sjn[XX2S9 T$)z Return a list of the feature paths of all features which are assigned incompatible values by ``fstruct1`` and ``fstruct2``. :rtype: list(tuple) c*>TRU5 U$r=)r)rrr conflict_lists r add_conflictconflicts..add_conflictsT" r!)rrr)rrrrrs @r conflictsrs!M (<= r!c@[US5=(a [US5$)Nrr)rrs rrr+s 1n % <'!V*<.Ls2 Cc#67&S]]_%%s? ?)rr sum)r&rs rr$SubstituteBindingsSequence.variablesJsD#Atz#x'@tAC    E   As??c lURUVs/sHo RX!5PM sn5$s snfr=)rsubst)r&rrs rr.SubstituteBindingsSequence.substitute_bindingsTs*~~E1zz!6EFFEs1cp[U[5(aURU5$URX5$r=)rr rr)r&rrs rr SubstituteBindingsSequence.substWs0 a, - -((2 2<<% %r!r>N) rCrrrrrrrrr>r!rrrDs  G&r!rc\rSrSrSrSrSrg)FeatureValueTuplei^z A base feature value that is a tuple of other base feature values. FeatureValueTuple implements ``SubstituteBindingsI``, so it any variable substitutions will be propagated to the elements contained by the set. A ``FeatureValueTuple`` is immutable. cX[U5S:XagSSRSU55-$)Nrz()rLr c3&# UHov M g7fr=r>rbs rr-FeatureValueTuple.__repr__..is!7$QC&$)rDrr%s rrFeatureValueTuple.__repr__fs* t9> !7$!7777r!r>N)rCrrrrrrr>r!rrr^s 8r!rc"\rSrSrSrSr\rSrg)FeatureValueSetilz A base feature value that is a set of other base feature values. FeatureValueSet implements ``SubstituteBindingsI``, so it any variable substitutions will be propagated to the elements contained by the set. A ``FeatureValueSet`` is immutable. cj[U5S:XagSSR[SU555-$)Nrz{/}rr c3&# UHov M g7fr=r>rs rr+FeatureValueSet.__repr__..ys(>A3r)rDrr[r%s rrFeatureValueSet.__repr__ts1 t9> &(>(>">???r!r>N)rCrrrrrrrr>r!rrrls@Gr!rc$\rSrSrSrSrSrSrg)FeatureValueUnioni~zd A base feature value that represents the union of two or more ``FeatureValueSet`` or ``Variable``. c[U[5n[SU55S:Xa[U[5n[U5$[ U5S:Xa[ U5S$[ RX5$)Nc3B# UHn[U[5v M g7fr=rr rrs rr,FeatureValueUnion.__new__..71z!X&&rrY)_flattenrrrrDr5 frozensetrrrs rrFeatureValueUnion.__new__sj&"34 77 71 <fo6F"6* * v;! <? "  --r!cJSSR[SU555-$)Nr+c3&# UHov M g7fr=r>rs rr-FeatureValueUnion.__repr__..s'=1#r)rr[r%s rrFeatureValueUnion.__repr__s#'='=!=>>>r!r>NrCrrrrrrrr>r!rrr~s ."?r!rc$\rSrSrSrSrSrSrg)FeatureValueConcatizn A base feature value that represents the concatenation of two or more ``FeatureValueTuple`` or ``Variable``. c[U[5n[SU55S:Xa[U[5n[U5$[ U5S:Xa[ U5S$[ RX5$)Nc3B# UHn[U[5v M g7fr=rrs rr-FeatureValueConcat.__new__..rrrrY)rrrrrDr5rrrs rrFeatureValueConcat.__new__si&"45 77 71 <f&78F$V, , v;! <? "}}S))r!c8SSRSU55-$)NrLrc3&# UHov M g7fr=r>rs rr.FeatureValueConcat.__repr__..s 6A3r)rr%s rrFeatureValueConcat.__repr__s 6 6666r!r>Nrr>r!rrrs *"7r!rc/nUH7n[X15(aURU5 M&URU5 M9 U$)zq Helper function -- return a copy of list, with all elements of type ``cls`` spliced in rather than appended in. )rrAr)lstrrrs rrrs= F c   MM#  MM#   Mr!c|\rSrSrSrSSjr\S5r\S5r\S5r Sr S r S r S r S rS rSrSrg)riz] A feature identifier that's specialized to put additional constraints, default values, etc. NcUS;deXlX lX0lURS:XaSUR4UlgURS:XaSUR4UlgSUR4Ulg)N)Nrr rrr rYr)_name_default_display_sortkey)r&rrrs rrFeature.__init__sf3333   ==H $,DM ]]g % ODM ODMr!cUR$)zThe name of this feature.)rr%s rr Feature.nameszzr!cUR$)zDefault value for this feature.)rr%s rrFeature.default}}r!cUR$)z1Custom display location: can be prefix, or slash.)rr%s rrFeature.displayrr!c SUR-$)Nz*%s*rr%s rrFeature.__repr__s !!r!c[U[5(ag[U[5(d [SX5 URUR:$)NT<)rrrrr r9s rrEFeature.__lt__s< eS ! !%)) #C 5}}u~~--r!cp[U5[U5:H=(a URUR:H$r=)typerr9s rr:Feature.__eq__s'DzT%[(FTZZ5;;-FFr!c X:X+$r=r>r9s rr?Feature.__ne__rAr!c,[UR5$r=)r\rr%s rrLFeature.__hash__sDJJr!c&URXU5$r=) read_valuer&spositionrparsers rrFeature.read_values  k::r!cX:XaU$[$)zX If possible, return a single value.. If not, return the value ``UnificationFailure``. )r{)r&rrrs rrFeature.unify_base_values s >L% %r!)rrrr )NN)rCrrrrrpropertyrrrrrEr:r?rLrrrr>r!rrrsl ,".G! ;&r!rc\rSrSrSrSrg) SlashFeatureic&URXU5$r= read_partialr s rrSlashFeature.read_values""1 <N)rCrrrrrr>r!rr)r)s=r!r)cD\rSrSr\R "S5rSrSrSr g) RangeFeatureiz(-?\d+):(-?\d+)cURRX5nU(d [SU5e[UR S55[UR S554UR 54$)NrDrYr!)RANGE_RErrr]groupend)r&r!r"rr#ms rrRangeFeature.read_valuesT MM   ,Wh/ /AGGAJQWWQZ11557::r!cUcU$UcU$[USUS5[USUS54nUSUS:a[$U$)NrrY)r$minr{)r&rrrrngs rrRangeFeature.unify_base_values"sX =L =L%(E!H%s58U1X'>> q6CF?% % r!r>N) rCrrrrmcompiler1rrrr>r!rr/r/szz,-H; r!r/r )rrrr)rc6\rSrSrSrSrSrSrSrSr Sr g ) ri6a An abstract base class for base values that define a custom unification method. The custom unification method of ``CustomFeatureValue`` will be used during unification if: - The ``CustomFeatureValue`` is unified with another base value. - The ``CustomFeatureValue`` is not the value of a customized ``Feature`` (which defines its own unification method). If two ``CustomFeatureValue`` objects are unified with one another during feature structure unification, then the unified base values they return *must* be equal; otherwise, an ``AssertionError`` will be raised. Subclasses must define ``unify()``, ``__eq__()`` and ``__lt__()``. Subclasses may also wish to define ``__hash__()``. c[S5e)zv If this base value unifies with ``other``, then return the unified value. Otherwise, return ``UnificationFailure``. zabstract base classr#r9s rrCustomFeatureValue.unifyJs ""788r!c[$r=NotImplementedr9s rr:CustomFeatureValue.__eq__Qr!c X:X+$r=r>r9s rr?CustomFeatureValue.__ne__TrAr!c[$r=r?r9s rrECustomFeatureValue.__lt__WrBr!cF[SURR-5e)Nz%s objects or unhashable)rrrCr%s rrLCustomFeatureValue.__hash__Zs2T^^5L5LLMMr!r>N) rCrrrrrr:r?rErLrr>r!rrr6s!$9!Nr!rc \rSrSr\\4\\S4SjrS:Sjr \ R"S5r \ R"S5r \ R"S5r\ R"S5r\ R"S 5r\ R"S 5r\ R"S 5r\ R"S 5r\ R"S 5r\ R"S\R*<S\ R*<S\R*<S\R*<S3 5rS;SjrS:SjrSrSrSrSrSrSrS\ 4S\ R"S54S\ R"S54S \ R"S!54S"\ R"S#54S$\ R"S%54S&\ R"S'54S(\ R"S)54S*\ R"S+54/ rS,r S-r!S.r"S/r#SS0S1S2.r$S3r%S4r&S5r'S6r(S7r)S8r*S9r+g)'``) to reference the reentrance identifier. rz end of string)stripr,rD_error)r&r!rWrr"s rrFeatStructReader.fromstringsH& GGI++Aq"g> s1v  KK?H 5 r!z$\s*(?:\((\d+)\)\s*)?(\??[\w-]+)?(\[)z\s*]\s*/z&\s*([+-]?)([^\s\(\)<>"\'\-=\[\],]+)\s*z\s*->\s*z\s*\((\d+)\)\s*z\s*=\s*z\s*,\s*z$\s*(?:\((\d+)\)\s*)?(\??[\w-]+\s*)()r z)|(z\s*(z\s*(=|->)|[+-]z|\]))cUc0nURXX45$![aAn[UR5S:waeUR"U/URQ76 SnAgSnAff=f)a Helper function that reads in a feature structure. :param s: The string to read. :param position: The position in the string to start parsing. :param reentrances: A dictionary from reentrance ids to values. Defaults to an empty dictionary. :return: A tuple (val, pos) of the feature structure created by parsing and the position where the parsed feature structure ends. :rtype: bool Nr!) _read_partialrrDrrZ)r&r!r"rrWrs rr,FeatStructReader.read_partialsb  K $%%a;H H $166{a KK #AFF # # $s A$7AA$cUcAURRX5(aUR5nOUR5nURRX5nU(d.UR RX5nU(d [ SU5eUR5nURS5(a5URS5nXc;a[ SURS55eXCU'[U[5(a#UR5 URXXSU5$USS2 URXXSU5$)Nopen bracket or identifierrYznew identifier)rrrLrM_START_FSTRUCT_RE_BARE_PREFIX_RErr3r2startrrr0_read_partial_featdict_read_partial_featlist)r&r!r"rrWr identifiers rr^FeatStructReader._read_partials ?##))!66++-++-&&,,Q9((..q;E !=xHH99; ;;q>>QJ( !15;;q>BB&- # gx ( ( MMO..qEPWX X ..qEPWX Xr!cURS5(a [S5eURS5(d [S5eU[U5:GajURR X5nUbXSR 54$UR R X5nU(aUR 5nURR X5nU(d [SU5eURS5nXd;a [SU5eUR 5nURXF5 O&URSXU5uprURU5 URR X5(aGM.URR X5nUc [SU5eUR 5nU[U5:aGMj[S U5e) Nr!z open bracketr rgrYbound identifierrcomma close bracket) r2rrD_END_FSTRUCT_RErr3_REENTRANCE_RE _TARGET_REr _read_value _COMMA_RE)r&r!r"rrrWtargetrs rrf'FeatStructReader._read_partial_featlists ;;q>>^, ,{{1~~^, ,Q((..q;E  ++''--a:E 99;--a:$\8<<Q,$%7BB 99;{23#'"2"21a;"Ou%##))!66NN((5E} (33yy{HAQF(33r!cURS5(avURc[SURS55eURS5R 5nUR S5(a [ U5nXeUR'URS5(d URXR5XE5$U[U5:GaS=pxURRX5nUb URXR5XE5$URRX5nUc [SU5eURS5nUR5nUSS:XaEUSS:Xa<URRUS S5nUc[S URS55eXu;a[S URS55eURS 5S :XaS nURS 5S:XaSnUcURRX5nUbtUR5nUR RX5nU(d [SU5eURS 5n X;a [SU5eUR5nXInUcSUR"RX5nU(a%UR5nUR%XqX$5upO [SU5eXU'URRX5(aGMJUR&RX5nUc [SU5eUR5nU[U5:aGM[SU5e)Nr!rarlr z feature namer*rrYzknown special featureznew namerT-Frgrjz equals signrkrl)r2rNrrdrY startswithr _finalizer3rDrmr_FEATURE_NAME_RErKrrnro _ASSIGN_RErprq) r&r!r"rrrW prefixvalrrrrs rre'FeatStructReader._read_partial_featdict s ;;q>>##+ !=u{{1~NN A,,.I##C(($Y/ ,5D(( ){{1~~>>!YY[+G GQ D((..q;E ~~akKK))//Dyy{HAw#~$r(c/~~))$q*5<$%$$yy{H OO11!>E (x@@"[[^F0();XFF$yy{H'/E}--a:$yy{H&*&6&6t&VOE8%]H=="DM##))!66NN((5E} (33yy{HGQL(33r!cURRX5nU(a3URnURXaUR 5U5uprXtU'XB4$)z_ Called when we see the close brace -- checks for a slash feature, and adds in default values. ) _SLASH_RErrOrpr3)r&r!posrrWrrrs rrxFeatStructReader._finalizek sS $$Q, &&D%%duyy{KHFADM |r!ct[U[5(aURX#X@5$URX#U5$r=)rrr)r&rr!r"rs rrpFeatStructReader._read_value| s1 dG $ $??1 B B??1 < read_logic_valuez <(.*?)(?read_set_value{read_tuple_valuez\(c&URXU5$r=r+r&r!r"rrs rr#FeatStructReader.read_fstruct_value s  k::r!c[X5$r=)rrs rrFeatStructReader.read_str_value s $$r!cT[UR55UR54$r=)r]r2r3rs rrFeatStructReader.read_int_value s5;;=!599;..r!cT[UR55UR54$r=)r r2r3rs rrFeatStructReader.read_var_value s & 33r!TF)NoneTrueFalseczUR5UR5peURRXU5U4$r=)r2r3 _SYM_CONSTSr)r&r!r"rrrr3s rrFeatStructReader.read_sym_value s1;;=%))+S##C-s22r!c~URRSURSS5-5UR54$)z%Mainly included for backwards compat.z%s(%s)r!r )rQparser2r3rs rrFeatStructReader.read_app_value s4!!''5;;q!3D(DEuyy{RRr!c URRURS55nXTR 54$![a n[UeSnAff=f![a!n[ SUR S55UeSnAff=f)NrYzlogic expression)rQrr2rrr3rd)r&r!r"rrexprrs rr!FeatStructReader.read_logic_value s H ())// A?$ $. ( a' ( H/Q@a G Hs2*>A AAAA B!A==Bc <URXX4S[[5$)Nr)_read_seq_valuerrrs rr!FeatStructReader.read_tuple_value s"## S2CEW  r!c <URXX4S[[5$)N})rrrrs rrFeatStructReader.read_set_value s!## S/CT  r!c[R"U5nUR5n[R"SU-5R X5n U (aU"5U R54$/n Sn [R"SU-5R X5n U (a7U (aU"U 5U R54$U"U 5U R54$UR XU5upU R U 5 [R"SU-5R X5n U (d[SU-U5eU RS5S:XaSn U R5nM) z> Helper function used by read_tuple_value and read_set_value. z \s*/?\s*%sFTz\s*%sz\s*(,|\+|(?=%s))\s*z',' or '+' or '%s'rYr) rmescaper3r:rrrrr2) r&r!r"rr close_paren seq_class plus_classcpr4r seen_plusrs rr FeatStructReader._read_seq_value s) YY{ #99; JJ}r) * 0 0 = ;' '  8b=)//r!rrrcs *82 #JKjj,O 4 Izz"KLZZ ,N./JJ'J :&Ijj!HIOjj  # #  % %  $ $  $ $  O$*Y<,4\[4z"= , : 01 2::&ABC 2::&9:; 2::h/0 2::&?@A  JJN O RZZ(89: 2::d+, RZZ./N";%/4 >K3SH  "r!rcb^^ SU-RS5nSU-RS5n[U5[U5:a,SS[US5S- --S-nXE/[U5-- nO+SS[US5S- --S-nX5/[U5-- n[X45Hupg[TU-S-U-5 M [TS [US5--S-S [US5--5 [US5S-S -m [TS R T 5-5 [TS R T 5-5 [TS R T 5-5 [TSR T 5-5 0nUR X5n U c[TSR T 5-5 U $[SR UU 4SjSU -RS5555 U(a@[UR55S:a#[[U5R T 55 U $)Nrr[rrr!]z rvr z| |z+-----UNIFY-----+rVz(FAILED)c3L># UHnTURT5-v M g7fr=)center)rr*rlinelens rr&display_unification..' s!V:UQfqxx00:Us!$) rrDziprrrrbound_variablesr) fs1fs2r fs1_lines fs2_lines blanklinefs1_linefs2_linerrrs ` @rdisplay_unificationr s""4(I""4(I 9~I&#Yq\!2Q!677#= [3y>11 #Yq\!2Q!677#= [3y>11 !)7 fx%'(238 &3Yq\** *U 2S3y|;L5L LM)A,!#a'G &&--g6 67 &&--g6 67 &3::g& &' &3::g& &'H YYs %F ~ fz((112 M  IIV4&=:O:OPT:UV V  H4467!; $x.''0 1 Mr!cSSKnSSKnSn[S5 [S5 URR 5 /SQn[ [ U55Vs/sHoU[XE54PM nnSnSn[ U5U:a[URXh55n OUn [S5 [S 5 U"U 5 SS/n S HupXbM [S U [ U54-S S 9 URR 5R5n U S;a gU S;aU(+n[SU-5 MmU S;a[U[ U 5-5 MU S;a U"U5 M[U 5S- n XmSX'[5 XcMM U(aU SRU SSS9nO[U SU S5nUbAUHup_[U5[U5:XdM O UR[ U5U45 [S5 URR 5R5n U S;agGMs snf! [S5 GM=f)Nrz 1-%d: Select the corresponding feature structure q: Quit t: Turn tracing on or off l: List all feature structures ?: Help a This demo will repeatedly present you with a list of feature structures, and ask you to choose two for unification. Whenever a new feature structure is generated, it is added to the list of choices that you can pick from. However, since this can be a large number of feature structures, the demo will only print out a random subset for you to choose between at a given time. If you want to see the complete lists, type "l". For a list of valid commands, type "?". zPress "Enter" to continue...z [agr=[number=sing, gender=masc]]z[agr=[gender=masc, person=3]]z[agr=[gender=fem, person=3]]z[subj=[agr=(1)[]], agr->(1)]z[obj=?x]z [subj=?x]z[/=None]z[/=NP]z[cat=NP]z[cat=VP]z[cat=PP]z/[subj=[agr=[gender=?y]], obj=[agr=[gender=?y]]]z[gender=masc, agr=?C]z%[gender=?S, agr=[gender=?S,person=3]]cUHSup[5 SU-RS5n[SUS-US4-5 USSHn[SU-5 M MU [5 g)Nrrz%3d: %srYrz )rr)fstructsirWr(r#s r list_fstructs'interactive_demo..list_fstructs^ sd"JA GG^**40E )q1ueAh// 0ab gn%" # r!K___________________________________________________________________________z'Choose two feature structures to unify:))Firstr)SecondrYz%%s feature structure (1-%d,q,t,l,?): r)r3)qQxX)tTz Trace = %s)hHrl)r*LrYzBad sentence number)rz3 Type "Enter" to continue unifying; or "q" to quit.)randomsysrstdinreadlinerDrDr r[samplerYr]rrrr)rrrHELPfstruct_stringsr all_fstructsr MAX_CHOICESrselectednthinputnumrrWs rinteractive_demor. sh D    ()IIO$6;3;O5P5PJ) *+5P  | { *fmmLFGH#H h 78h$<3FC+%?L 123 II..0668E 44 *$) o56 /dS]23  *%l3 e*q.C"."3A"6HKG1+%4< a[&&x{!&Nr)NFNTr)r)rr)Jrrmrm functoolsrnltk.internalsrrnltk.sem.logicrrrr r r rrrrrr5rrrVrr]rrcrrhrjrrqrtr{r Exceptionrzryrr}r|r~rxrrrrrrrrrrUrrrrrrrrrr)r/rrrrrrrrC__all__r>r!rrsBPd $<G$$G$G$V: ;0{z4{F W