/hYSSKrSSKJr SSKJrJr SSKJrJr "SS\ 5r \"SS55r "S S \ 5r "S S \ 5r "S S\ 5r"SS\5r"SS\5r"SS\ 5r"SS\ 5rg)N)total_ordering)chainislice)raise_unorderable_types slice_boundsct\rSrSrSSjrSrSrSrSrSr S r S r S r SS jr S rSSjrSrSrSrg) OrderedDictNc URXRS55UlURS5UlUc[R U5 g[R X5 g)Nkeysdefault_factory)r get_keys_default_factorydict__init__)selfdatakwargss H/var/www/auris/envauris/lib/python3.13/site-packages/nltk/collections.pyrOrderedDict.__init__sJYYtZZ%78 & +< = < MM$  MM$ %cd[RX5 URRU5 gN)r __delitem__rremoverkeys rrOrderedDict.__delitem__s" # #rcp[RX5$![a URU5s$f=fr)r __getitem__KeyError __missing__rs rr!OrderedDict.__getitem__ s8 )##D. . )##C( ( )s 55c0SUR55$)Nc3$# UHov M g7fr).0rs r 'OrderedDict.__iter__..'s+{{s)r rs r__iter__OrderedDict.__iter__&s+tyy{++rcvUR(dXR;a [5eUR5$r)rrr"rs rr#OrderedDict.__missing__)s+$$JJ)>* $$&&rc[RXU5 XR;aURRU5 ggr)r __setitem__rappend)rritems rr1OrderedDict.__setitem__.s3 D) jj JJ  c " !rcb[RU5 URR5 gr)rclearrr+s rr6OrderedDict.clear3s 4 rcR[RU5nURUlU$r)rcopyr)rds rr9OrderedDict.copy7s IIdO**rcR[UR5UR55$r)zipr valuesr+s ritemsOrderedDict.items<s499; ..rcU(aU(a3[U[5(de[U5[U5:XdeU$[U[5(d,[U[5(d[U[5(de[U[5(d[U[5(aUR 5$[U[5(aUVVs/sHup4UPM snn$gSUR ;a UR$/$s snnf)Nr) isinstancelistlenrr r __dict__r)rrr rvalues rr OrderedDict.keys?s !$----4yCI--- tT**!$ 44!$--.dD))Zk-J-J99;&d++489DLSCD99,  %:: I :sDc~UR(d [5eURR5nXnX X4$r)rr"pop)rrrFs rpopitemOrderedDict.popitemTs5zz* jjnn  I|rc[RXU5 XR;aURRU5 ggr)r setdefaultrr2)rrfailobjs rrMOrderedDict.setdefault]s1 7+ jj JJ  c " !rc[RX5 URU5H/nX R;dMURR U5 M1 gr)rupdater rr2)rrrs rrQOrderedDict.updatebs< D99T?C**$ !!#&#rcB[URUR5$r)maprrr+s rr>OrderedDict.valueshs488TZZ((r)rrrNN)__name__ __module__ __qualname____firstlineno__rrr!r,r#r1r6r9r?r rJrMrQr>__static_attributes__r'rrr r sH&) ,' #  /*# ' )rr c\rSrSrSrSrSrSrSrSr SS jr S r S r S r S rSrSrSrSrSrSrSrSrg)AbstractLazySequenceqa  An abstract base class for read-only sequences whose values are computed as needed. Lazy sequences act like tuples -- they can be indexed, sliced, and iterated over; but they may not be modified. The most common application of lazy sequences in NLTK is for corpus view objects, which provide access to the contents of a corpus without loading the entire corpus into memory, by loading pieces of the corpus from disk as needed. The result of modifying a mutable element of a lazy sequence is undefined. In particular, the modifications made to the element may or may not persist, depending on whether and when the lazy sequence caches that element's value or reconstructs it from scratch. Subclasses are required to define two methods: ``__len__()`` and ``iterate_from()``. c[S5e)zM Return the number of tokens in the corpus file underlying this corpus view. !should be implemented by subclassNotImplementedErrorr+s r__len__AbstractLazySequence.__len__s ""EFFrc[S5e)z Return an iterator that generates the tokens in the corpus file underlying this corpus view, starting at the token number ``start``. If ``start>=len(self)``, then this iterator will generate no tokens. r`rarstarts r iterate_from!AbstractLazySequence.iterate_froms""EFFrc[U[5(a[X5up#[XU5$US:aU[ U5- nUS:a [ S5e[ URU55$![an[ S5UeSnAff=f)zy Return the *i* th token in the corpus file underlying this corpus view. Negative indices and spans are both supported. rindex out of rangeN) rBslicerLazySubsequencerD IndexErrornextrh StopIteration)rirgstopes rr! AbstractLazySequence.__getitem__s a  &t/KE"45 51uSY1u !566 >D--a011  > !56A= >sA// B 9 BB c$URS5$)z\Return an iterator that generates the tokens in the corpus file underlying this corpus view.r)rhr+s rr,AbstractLazySequence.__iter__s  ##rc.^[U4SjU55$)z8Return the number of times this list contains ``value``.c36># UHoT:XdM Sv M g7f)Nr')r(eltrFs rr)-AbstractLazySequence.count..s5u 11s  )sumrrFs `rcountAbstractLazySequence.counts5555rNc[U[X#55up#[[XU55HupEXQ:XdM XB-s $ [ S5e)zReturn the index of the first occurrence of ``value`` in this list that is greater than or equal to ``start`` and less than ``stop``. Negative start and stop values are treated like negative slice bounds -- i.e., they count from the end of the list.zindex(x): x not in list)rrl enumerater ValueError)rrFrgrrrqrzs rindexAbstractLazySequence.indexsJ #4u);< tD 9:FA|y ;233rc6[URU55$)z,Return true if this list contains ``value``.)boolr~r}s r __contains__!AbstractLazySequence.__contains__sDJJu%&&rc[X/5$z,Return a list concatenating self with other.LazyConcatenationrothers r__add__AbstractLazySequence.__add__s $//rc[X/5$z,Return a list concatenating other with self.rrs r__radd__AbstractLazySequence.__radd__s %//rc [U/U-5$z=Return a list concatenating self with itself ``count`` times.rrr~s r__mul__AbstractLazySequence.__mul__ $%00rc [U/U-5$rrrs r__rmul__AbstractLazySequence.__rmul__rr<c/nSnUHjnUR[U55 U[US5S-- nX R:dMB[U5S:dMSSSR USS5-s $ SSR U5-$)z Return a string representation for this corpus view that is similar to a list's representation; but if it would be more than 60 characters long, it is truncated. z [%s, ...]z, Nz[%s])r2reprrD_MAX_REPR_SIZEjoin)rpieceslengthrzs r__repr__AbstractLazySequence.__repr__s C MM$s) $ c&*o) )F+++F a"TYYvcr{%;;;   &)))rcl[U5[U5:H=(a [U5[U5:H$r)typerCrs r__eq__AbstractLazySequence.__eq__s'DzT%[(FT$Z4;-FFrc X:X+$rr'rs r__ne__AbstractLazySequence.__ne__s   rcx[U5[U5:wa [SX5 [U5[U5:$)N<)rrrCrs r__lt__AbstractLazySequence.__lt__s/ ;$t* $ #C 5DzDK''rcF[SURR-5e)z8 :raise ValueError: Corpus view objects are unhashable. z%s objects are unhashable)r __class__rWr+s r__hash__AbstractLazySequence.__hash__s4t~~7N7NNOOrr'rV)rWrXrYrZ__doc__rcrhr!r,r~rrrrrrrrrrrrr[r'rrr]r]qsb(GG>($ 6 4'0011N *G!( Prr]c6\rSrSrSrSrSrSrSrSr Sr g ) rmz A subsequence produced by slicing a lazy sequence. This slice keeps a reference to its source sequence, and generates its values by looking them up in the source sequence. dcX2- UR:a&[[URU5X2- 55$[R U5$)z Construct a new slice from a given underlying sequence. The ``start`` and ``stop`` indices should be absolute indices -- i.e., they should not be negative (for indexing from the back of a list) or greater than the length of ``source``. )MIN_SIZErCrrhobject__new__)clssourcergrrs rrLazySubsequence.__new__s@ <#,, &v22594<HI I>>#& &rc(XlX lX0lgr_source_start_stop)rrrgrrs rrLazySubsequence.__init__s   rc4URUR- $r)rrr+s rrcLazySubsequence.__len__szzDKK''rc [URRXR-5[ S[ U5U- 55$Nr)rrrhrmaxrDrfs rrhLazySubsequence.iterate_froms: LL % %ekk&9 :C3t9uCTsEE>E< E>rN) rWrXrYrZrrrcrhr[r'rrrrs! rrc0\rSrSrSrSrSrSrSrSr g) LazyMapiQa2 A lazy sequence whose elements are formed by applying a given function to each element in one or more underlying lists. The function is applied lazily -- i.e., when you read a value from the list, ``LazyMap`` will calculate that value by applying its function to the underlying lists' value(s). ``LazyMap`` is essentially a lazy version of the Python primitive function ``map``. In particular, the following two expressions are equivalent: >>> from nltk.collections import LazyMap >>> function = str >>> sequence = [1,2,3] >>> map(function, sequence) # doctest: +SKIP ['1', '2', '3'] >>> list(LazyMap(function, sequence)) ['1', '2', '3'] Like the Python ``map`` primitive, if the source lists do not have equal size, then the value None will be supplied for the 'missing' elements. Lazy maps can be useful for conserving memory, in cases where individual values take up a lot of space. This is especially true if the underlying list's values are constructed lazily, as is the case with many corpus readers. A typical example of a use case for this class is performing feature detection on the tokens in a corpus. Since featuresets are encoded as dictionaries, which can take up a lot of memory, using a ``LazyMap`` can significantly reduce memory usage when training and running classifiers. cU(d [S5eX lXlURSS5UlURS:a0OSUl[ SU55[U5:HUlg)a :param function: The function that should be applied to elements of ``lists``. It should take as many arguments as there are ``lists``. :param lists: The underlying lists. :param cache_size: Determines the size of the cache used by this lazy map. (default=5) z"LazyMap requires at least two args cache_sizerrNc3B# UHn[U[5v M g7fr)rBr]r(lsts rr)#LazyMap.__init__..s =BcJs0 1 1Us) TypeError_lists_funcr _cache_size_cacher|rD _all_lazy)rfunctionlistsconfigs rrLazyMap.__init__tsm@A A  !::lA6 ,,q0bd  =B  Zrc#\# [UR5S:XaJUR(a9URSRU5HnUR U5v M g[UR5S:Xa,UR URSU5v US- nM+UR(aURVs/sHo3RU5PM nn/nUHnUR [U55 M US/[UR5-:XagUR"U6v US- nM\URVs/sHo3UPM nnUR"U6v US- nM7![ a gf=fs snf! UR S5 M=fs snf![ aq S/[UR5-n[UR5HupsX1XW'M![ a Mf=f US/[UR5-:XagNf=f7f)Nryr) rDrrrhrrnr2ror)rrrFr iteratorselementsiteratorrqs rrhLazyMap.iterate_froms  t{{ q T^^Q44U;jj''<   "**T[[^E%:;;  ^^<@KKHKS))%0KIH )H. X7!* vDKK(888jj(++  6:kkBksE kHBjj(++ +" I . - C! $vDKK(88H"+DKK"8!*-*HK)! !#9  D6C ,<#<<=sA>H,#E;$&H, F $ H,/F ;H,F.F)!F.#H,; FH,FH,F&#H,)F..=H),G42H)4 H>H)H"H)$H,(H))H,cd[U[5(a4URVs/sHo"UPM nn[UR/UQ76$US:aU[ U5- nUS:a [ S5eURbXR;aURU$[URU55nURbK[ UR5UR:aURR5 X@RU'U$s snf![an[ S5UeSnAff=f)Nrrk) rBrlrrrrDrnrrorhrprrJ)rrr sliced_listsvalrss rr!LazyMap.__getitem__s  eU # #26++>+3J+L>4::5 5 5qyT"qy !566{{&5KK+?{{5)) >4,,U34{{&t{{#d&6&66KK'')%( E"J-?! > !56A= >sDD D/ D**D/c:[SUR55$)Nc38# UHn[U5v M g7frrDrs rr)"LazyMap.__len__..3{3s88{)rrr+s rrcLazyMap.__len__3t{{333r)rrrrrN) rWrXrYrZrrrhr!rcr[r'rrrrQs D0.`44rrc*\rSrSrSrSrSrSrSrg)LazyZipiaN A lazy sequence whose elements are tuples, each containing the i-th element from each of the argument sequences. The returned list is truncated in length to the length of the shortest argument sequence. The tuples are constructed lazily -- i.e., when you read a value from the list, ``LazyZip`` will calculate that value by forming a tuple from the i-th element of each of the argument sequences. ``LazyZip`` is essentially a lazy version of the Python primitive function ``zip``. In particular, an evaluated LazyZip is equivalent to a zip: >>> from nltk.collections import LazyZip >>> sequence1, sequence2 = [1, 2, 3], ['a', 'b', 'c'] >>> zip(sequence1, sequence2) # doctest: +SKIP [(1, 'a'), (2, 'b'), (3, 'c')] >>> list(LazyZip(sequence1, sequence2)) [(1, 'a'), (2, 'b'), (3, 'c')] >>> sequences = [sequence1, sequence2, [6,7,8,9]] >>> list(zip(*sequences)) == list(LazyZip(*sequences)) True Lazy zips can be useful for conserving memory in cases where the argument sequences are particularly long. A typical example of a use case for this class is combining long sequences of gold standard and predicted values in a classification or tagging task in order to calculate accuracy. By constructing tuples lazily and avoiding the creation of an additional long sequence, memory usage can be significantly reduced. c6[R"US/UQ76 g)z< :param lists: the underlying lists :type lists: list(list) cU$rr')eltss r"LazyZip.__init__..sTrN)rr)rrs rrLazyZip.__init__s 1:E:rc## [RX5nU[U5:a#[U5v US- nU[U5:aM#g7f)Nry)rrhrDro)rrrs rrhLazyZip.iterate_fromsG''4c$ix. QJEc$i s AA  A c:[SUR55$)Nc38# UHn[U5v M g7frrrs rr)"LazyZip.__len__.. rr)minrr+s rrcLazyZip.__len__rrr'N) rWrXrYrZrrrhrcr[r'rrrrs>;4rrc\rSrSrSrSrSrg) LazyEnumeratei a A lazy sequence whose elements are tuples, each containing a count (from zero) and a value yielded by underlying sequence. ``LazyEnumerate`` is useful for obtaining an indexed list. The tuples are constructed lazily -- i.e., when you read a value from the list, ``LazyEnumerate`` will calculate that value by forming a tuple from the count of the i-th element and the i-th element of the underlying sequence. ``LazyEnumerate`` is essentially a lazy version of the Python primitive function ``enumerate``. In particular, the following two expressions are equivalent: >>> from nltk.collections import LazyEnumerate >>> sequence = ['first', 'second', 'third'] >>> list(enumerate(sequence)) [(0, 'first'), (1, 'second'), (2, 'third')] >>> list(LazyEnumerate(sequence)) [(0, 'first'), (1, 'second'), (2, 'third')] Lazy enumerations can be useful for conserving memory in cases where the argument sequences are particularly long. A typical example of a use case for this class is obtaining an indexed list for a long sequence of values. By constructing tuples lazily and avoiding the creation of an additional long sequence, memory usage can be significantly reduced. cV[RU[[U55U5 g)z1 :param lst: the underlying list :type lst: list N)rrrangerD)rrs rrLazyEnumerate.__init__)s uSX4rr'N)rWrXrYrZrrr[r'rrrr s 85rrc:\rSrSrSrS SjrSrSrSrSr S r g) LazyIteratorListi1z Wraps an iterator, loading its elements on demand and making them subscriptable. __repr__ displays only the first few elements. Nc*XlX l/Ulgr)_it_lenr)rit known_lens rrLazyIteratorList.__init__8s  rcUR(a UR$UR[UR55HnM [UR5UlUR$r)rrhrDrrs rrcLazyIteratorList.__len__=sN 9999 ""3t{{#34A 5 $ yyrc## [UR5U:aK[UR5nURR U5 [UR5U:aMKUnU[UR5:a1URUv US- nU[UR5:aM1[UR5nURR U5 Uv M6![ a gf=f7f)zBCreate a new iterator over this list starting at the given offset.ryN)rDrrorr2rp)rrgvrqs rrhLazyIteratorList.iterate_fromEs$++&TXXA KK  q !$++& #dkk""++a. FA#dkk"" N ""1%   s+A#C;'A C;47C++ C85C;7C88C;c6[U5"[X55$rrrrs rrLazyIteratorList.__add__VsDz%,--rc6[U5"[X55$rr(rs rrLazyIteratorList.__radd__ZsDz%,--r)rrrr) rWrXrYrZrrrcrhrrr[r'rrrr1s   "..rrc@^\rSrSrSrSrSU4SjjrSrSrSr U=r $) Trieibz!A Trie implementation for stringsTcf>[TU]5 U(aUHnURU5 M gg)aABuilds a Trie object, which is built around a ``dict`` If ``strings`` is provided, it will add the ``strings``, which consist of a ``list`` of ``strings``, to the Trie. Otherwise, it'll construct an empty Trie. :param strings: List of strings to insert into the trie (Default is ``None``) :type strings: list(str) N)superrinsert)rstringsstringrs rr Trie.__init__gs.  ! F#" rc~[U5(aXSRUSS5 gSU[R'g)a9Inserts ``string`` into the Trie :param string: String to insert into the trie :type string: str :Example: >>> from nltk.collections import Trie >>> trie = Trie(["abc", "def"]) >>> expected = {'a': {'b': {'c': {True: None}}}, 'd': {'e': {'f': {True: None}}}} >>> trie == expected True rryN)rDr0r-LEAF)rr2s rr0 Trie.insertxs6 v;; O " "6!": .#DOrc"[5X'X$r)r-rs rr#Trie.__missing__sF yrr'r) rWrXrYrZrr5rr0r#r[ __classcell__)rs@rr-r-bs+ D$"#,rr-)r functoolsr itertoolsrrnltk.internalsrrrr r]rmrrrrrr-r'rrr=s$#@V)$V)|APAPAPH& *& R/,/dF4"F4R/4g/4d"5G"5J+.++.b.4.r