/hkSSKJr SSKJr SSKJr SSKJrJrJ r SSK J r SSK J r \"SS55r"S S 5r"S S 5r"S S5rSrSrSrSr\S:Xa\"5 gg)) defaultdict)total_ordering)chain)DependencyGrammarDependencyProductionProbabilisticDependencyGrammar)raise_unorderable_types)DependencyGraphcH\rSrSrSrSrSrSrSrSr Sr S r S r S r g ) DependencySpana0 A contiguous span over some part of the input string representing dependency (head -> modifier) relationships amongst words. An atomic span corresponds to only one word so it isn't a 'span' in the conventional sense, as its _start_index = _end_index = _head_index for concatenation purposes. All other spans are assumed to have arcs between all nodes within the start and end indexes of the span, and one head index corresponding to the head word for the entire span. This is the same as the root node if the dependency structure were depicted as a graph. cXlX lX0lX@lXPlXU[ U54Ul[UR 5UlgN) _start_index _end_index _head_index_arcs_tagstuple_comparison_keyhash_hash)self start_index end_index head_indexarcstagss ]/var/www/auris/envauris/lib/python3.13/site-packages/nltk/parse/projectivedependencyparser.py__init__DependencySpan.__init__(sB'#%  + E$KP$../ cUR$)zS :return: An value indexing the head of the entire ``DependencySpan``. :rtype: int )rrs rrDependencySpan.head_index1s r"cNSURURUR4-$)zR :return: A concise string representatino of the ``DependencySpan``. :rtype: str. Span %d-%d; Head Index: %d)rrrr$s r__repr__DependencySpan.__repr__8s/ ,    OO   /   r"cSURURUR4-n[[ UR 55H'nUSX R UUR U4-- nM) U$)zQ :return: A verbose string representation of the ``DependencySpan``. :rtype: str r'z %d <- %d, %s)rrrrangelenrr)rstris r__str__DependencySpan.__str__Cso +    OO   .   s4::'A #q**Q-A&GG GC( r"cp[U5[U5:H=(a URUR:H$r)typerrothers r__eq__DependencySpan.__eq__Qs- J$u+ % W$*>*>%BWBW*W r"c X:X+$rr3s r__ne__DependencySpan.__ne__Vs   r"cv[U[5(d [SX5 URUR:$)N<) isinstancer r rr3s r__lt__DependencySpan.__lt__Ys0%00 #C 5##e&;&;;;r"cUR$)z5 :return: The hash value of this ``DependencySpan``. )rr$s r__hash__DependencySpan.__hash__^szzr")rrrrrrrN)__name__ __module__ __qualname____firstlineno____doc__r rr(r/r5r9r>rA__static_attributes__r8r"rr r s/ 0     !< r"r c0\rSrSrSrSrSrSrSrSr g) ChartCelljz A cell from the parse chart formed when performing the CYK algorithm. Each cell keeps track of its x and y coordinates (though this will probably be discarded), and a list of spans serving as the cell's entries. c:XlX l[5Ulg)ze :param x: This cell's x coordinate. :type x: int. :param y: This cell's y coordinate. :type y: int. N)_x_yset_entries)rxys rr ChartCell.__init__qs r"c:URRU5 g)z Appends the given span to the list of spans representing the chart cell's entries. :param span: The span to add. :type span: DependencySpan N)rPadd)rspans rrU ChartCell.add|s $r"cNSURURUR4-$)zN :return: A verbose string representation of this ``ChartCell``. :rtype: str. z CC[%d,%d]: %s)rMrNrPr$s rr/ChartCell.__str__s" $''477DMM!BBBr"c SU-$)zN :return: A concise string representation of this ``ChartCell``. :rtype: str. z%sr8r$s rr(ChartCell.__repr__s d{r")rPrMrNN) rCrDrErFrGr rUr/r(rHr8r"rrJrJjs  Cr"rJc*\rSrSrSrSrSrSrSrg)ProjectiveDependencyParsera~ A projective, rule-based, dependency parser. A ProjectiveDependencyParser is created with a DependencyGrammar, a set of productions specifying word-to-word dependency relations. The parse() method will then return the set of all parses, in tree representation, for a given input sequence of tokens. Each parse must meet the requirements of the both the grammar and the projectivity constraint which specifies that the branches of the dependency tree are not allowed to cross. Alternatively, this can be understood as stating that each parent node and its children in the parse tree form a continuous substring of the input sequence. cXlg)z Create a new ProjectiveDependencyParser, from a word-to-word dependency grammar ``DependencyGrammar``. :param dependency_grammar: A word-to-word relation dependencygrammar. :type dependency_grammar: DependencyGrammar N)_grammar)rdependency_grammars rr #ProjectiveDependencyParser.__init__s + r"c## [U5Ul/n[S[UR5S-5HnUR /5 [S[UR5S-5HSnX#R [ X455 X4S-:XdM)X#UR [US- X3S- S/S/55 MU M [S[UR5S-5Hn[US- SS5Hxn[US- US5HanX%URHInX#URH1nURXg5HnX#UR U5 M M3 MK Mc Mz M U[UR5SRHfn Sn [[U55H,nU SUS-XXSSSU RUS-SS S 4 -- n M. [U 5n U R5v Mh g 7f) a Performs a projective dependency parse on the list of tokens using a chart-based, span-concatenation algorithm similar to Eisner (1996). :param tokens: The list of input tokens. :type tokens: list(str) :return: An iterator over parse trees. :rtype: iter(Tree) rnull %d %s %s %s %s %s %d %s %s %s ROOT-N) list_tokensr+r,appendrJrUr rP concatenaterr tree) rtokenschartr.jkspan1span2newspanparse conll_formatdgs rrx ProjectiveDependencyParser.parsesF| q#dll+a/0A LL 1c$,,/!34 !0A:HQKOON1q5!URD6($ST51q#dll+a/0A1q5"b)q1ua,A!&!!5!5%*Xa[%9%9E+/+;+;E+I %  8,J&:"6-*13t||,-a099EL3v;' LEIIKKNQ& P !  ( !.B'')O+:s BH E7H c /nURUR:Xa [S5 URUR:aUnUnUnURUR-nURUR-nURR UR URUR UR5(aaURXRRUR- 'UR[URURURUU55 URUR-nURR UR URUR UR5(aaURXQRUR- 'UR[URURURUU55 U$a Concatenates the two spans in whichever way possible. This includes rightward concatenation (from the leftmost word of the leftmost span to the rightmost word of the rightmost span) and leftward concatenation (vice-versa) between adjacent spans. Unlike Eisner's presentation of span concatenation, these spans do not share or pivot on a particular word/word-index. :return: A list of new spans formed through concatenation. :rtype: list(DependencySpan) z8Error: Mismatched spans - replace this with thrown error rprintrrr`containsrmrrnr rrrurvspans temp_spannew_arcsnew_tagss rro&ProjectiveDependencyParser.concatenates   !3!3 3 L M    2 2 2IEE;;,;;, == ! ! LL** +T\\%:K:K-L  @E?P?PH&&););; < LL&&$$%%  ;;, == ! ! LL** +T\\%:K:K-L  @E?P?PH&&););; < LL&&$$%%   r"r`rmN) rCrDrErFrGr rxrorHr8r"rr]r]s +0d4r"r]c6\rSrSrSrSrSrSrSrSr Sr g ) 'ProbabilisticProjectiveDependencyParseriagA probabilistic, projective dependency parser. This parser returns the most probable projective parse derived from the probabilistic dependency grammar derived from the train() method. The probabilistic model is an implementation of Eisner's (1996) Model C, which conditions on head-word, head-tag, child-word, and child-tag. The decoding uses a bottom-up chart-based span concatenation algorithm that's identical to the one utilized by the rule-based projective parser. Usage example >>> from nltk.parse.dependencygraph import conll_data2 >>> graphs = [ ... DependencyGraph(entry) for entry in conll_data2.split('\n\n') if entry ... ] >>> ppdp = ProbabilisticProjectiveDependencyParser() >>> ppdp.train(graphs) >>> sent = ['Cathy', 'zag', 'hen', 'wild', 'zwaaien', '.'] >>> list(ppdp.parse(sent)) [Tree('zag', ['Cathy', 'hen', Tree('zwaaien', ['wild', '.'])])] cg)zX Create a new probabilistic dependency parser. No additional operations are necessary. Nr8r$s rr 0ProbabilisticProjectiveDependencyParser.__init__:sr"c[U5Ul/n[S[UR5S-5HnUR /5 [S[UR5S-5HnX#R [ X455 X4S-:XdM)XS- UR R;aQUR RXS- H-nX#UR[US- X3S- S/U/55 M/ M[SXS- -5 /s s $ M [S[UR5S-5Hn[US- SS5Hxn[US- US5HanX&URHInX#URH1nURXx5Hn X#URU 5 M M3 MK Mc Mz M /n Sn Sn U[UR5SRHn SnSn[[U55HdnUSXS U RUS-S 4-- nUS US-XXU RUU RUS U RUS-S S S 4 -- nMf [U5nURU5nU R UUR!545 M U R#5 S U 5$)a( Parses the list of tokens subject to the projectivity constraint and the productions in the parser's grammar. This uses a method similar to the span-concatenation algorithm defined in Eisner (1996). It returns the most probable parse derived from the parser's probabilistic dependency grammar. rrdrez7No tag found for input token '%s', parse is impossible.rgNrhz %s %s %d %s rfrirjrkc3*# UH upUv M g7frr8).0scorerps r @ProbabilisticProjectiveDependencyParser.parse..s0%%%s)rlrmr+r,rnrJr`rrUr rrProrr compute_probrpsort)rrqrrr.rstagrtrurvrwtrees max_parse max_scorerxry malt_formatrzrs rrx-ProbabilisticProjectiveDependencyParser.parse@sF| q#dll+a/0A LL 1c$,,/!34 !0A:!e} (;(;;#'==#6#6v!e}#EC!HQKOO .q1uaQse L$F U$Um, " 51 q#dll+a/0A1q5"b)q1ua,A!&!!5!5%*Xa[%9%9E+/+;+;E+I %  8,J&:"6-*1  3t||,-a099ELK3v;'1IKKNQ& 5   LEIIKKNKKNKKNQ& P !  (*!.B%%b)E LL%+ ,5:6  0%00r"c /nURUR:Xa [S5 URUR:aUnUnUnURUR-nURUR-nURR UR URUR UR5(aaURXRRUR- 'UR[URURURUU55 URUR-nURUR-nURR UR URUR UR5(aaURXQRUR- 'UR[URURURUU55 U$r}r~rs rro3ProbabilisticProjectiveDependencyParser.concatenates   !3!3 3 L M    2 2 2IEE;;,;;, == ! ! LL** +T\\%:K:K-L  @E?P?PH&&););; < LL&&$$%%  ;;,;;, == ! ! LL** +T\\%:K:K-L  @E?P?PH&&););; < LL&&$$%%   r"c /n[[5n0nUGHn[S[UR55GH~n[ [ R"URUSR555nURU5nURU5n X-n [SUS-- U S-5GHn URUSn URUSn X;aXLRU 5 OU 1XL'SnSnSnSnU S:aX-nUS:a*URUUSnURUUSnU S :wa0URUUS-SnURUUS-SnUS:waUR[X/55 S RUUUU U 5nS RUU U 5nUU==S- ss'UU==S- ss'GM$U S:dGM-X-S- nUU :a*URUUSnURUUSnU S:wa0URUUS- SnURUUS- SnUS:waUR[X/55 S RUUUU U 5nS RUU U 5nUU==S- ss'UU==S- ss'GM GM GM [X#U5Ulg)aK Trains a ProbabilisticDependencyGrammar based on the list of input DependencyGraphs. This model is an implementation of Eisner's (1996) Model C, which derives its statistics from head-word, head-tag, child-word, and child-tag relationships. :param graphs: A list of dependency graphs to train from. :type: list(DependencyGraph) rddepsrrgwordrSTOPSTARTre'(head ({} {}) (mods ({}, {}, {}) left))(mods ({}, {}, {}) left))((head ({} {}) (mods ({}, {}, {}) right))(mods ({}, {}, {}) right))N)rintr+r,nodesrlr from_iterablevalues left_childrenright_childrenrUrnrformatrr`)rgraphs productionseventsrrz node_indexchildrennr_left_childrennr_right_children nr_children child_index head_wordhead_tagchild child_tag prev_wordprev_tag array_index head_event mod_events rtrain-ProbabilisticProjectiveDependencyParser.trains/ S!B#As288}5 ''(rr) r+r,rrlrrrrrrr`_events)rrzprobrrrrrrrrrrrrrrrh_countm_counts rr4ProbabilisticProjectiveDependencyParser.compute_prob s3rxx=1JE//0DV0L0S0S0UVWH!// ;  " 1 1* = *>K$Q*:Q*>%?ARUVAVW HHZ08 88J/6" # "?"-"@K"a' ")> ? G$&HHX-B$CE$J "b($&HHXAo-F$G$O #%88H1_,E#Fu#M!J!Q!Q! ! "J!< B B ! !I #mm33J?G"mm33I>G!|' 11) 1_"-"@1"DK"0 ")> ? G$&HHX-B$CE$J "a'$&HHXAo-F$G$O #%88H1_,E#Fu#M!K!R!R! ! "J!= C C ! !I #mm33J?G"mm33I>G!|' 11)} X2N r"rN) rCrDrErFrGr rxrorrrHr8r"rrrs'4 @1D3jTRlSr"rc,[5 [5 gr)projective_rule_parse_demoprojective_prob_parse_demor8r"rdemorhs  r"c[R"S5n[U5 [U5nUR /SQ5nUHn[U5 M g)zs A demonstration showing the creation and use of a ``DependencyGrammar`` to perform a projective dependency parse. zP 'scratch' -> 'cats' | 'walls' 'walls' -> 'the' 'cats' -> 'the' )thecatsscratchrwallsN)r fromstringrr]rxgrammarpdprrps rrrnsL  ** G 'N $W -C II@ AE d r"c|[5 [S5 [S5 [S5 [R"S5n[U5 [5 [S5 [S5 [U5nUR /SQ5nUHn[U5 M [5 [S5 [S 5 [S 5 [S 5 [R"S 5n[U5 [5 [S 5 [U5nUR /SQ5nUHn[U5 M g)z A demonstration showing the creation of a ``DependencyGrammar`` in which a specific number of modifiers is listed for a given head. This can further constrain the number of possible parses created by a ``ProjectiveDependencyParser``. z>A grammar with no arity constraints. Each DependencyProductionz;specifies a relationship between one head word and only onezmodifier word.zj 'fell' -> 'price' | 'stock' 'price' -> 'of' | 'the' 'of' -> 'stock' 'stock' -> 'the' z 'price' | 'stock' 'price' -> 'of' 'the' 'of' -> 'stock' 'stock' -> 'the' z:This constrains the number of possible parses to just one:N)rrrr]rxrs rarity_parse_demors G JK GH ** G 'N G HI 45 $W -C IID EE d  G :; >? AB "#** G 'N G D %W -C IID EE d r"cfSSKJn URS5Vs/sHo(dM [U5PM nn[ 5n[ S5 UR U5 /SQn[ SSRU5S5 [ S 5 URU5Hn[ U5 M g s snf) zH A demo showing the training and use of a projective dependency parser. r) conll_data2z z6Training Probabilistic Projective Dependency Parser...)Cathyzaghenwildzwaaien.z Parsing ' z'...zParse:N) nltk.parse.dependencygraphrsplitr rrrjoinrx)rentryrppdpsentrps rrrs 72=2C2CF2K U2Ku$oe$2KF U 2 4D BCJJv :D +sxx~v. (O 4  d !Vs B.B.__main__N) collectionsr functoolsr itertoolsr nltk.grammarrrrnltk.internalsr rr r rJr]rrrrrrCr8r"rrs$$ 36FFF\((`}}JAAR ! (3l& zFr"