gdZddlZddlZddlZddlZddlZddlZddlmZm Z ddlm Z ddl m Z ddl m Z ddlmZmZddlmZmZmZd Zd3d Zd4d Zd Zd ZdZdZdZdZdZdZdZ dZ!d5dZ"dZ#dZ$dZ%dZ&dZ'dZ(Gdde)Z*Gdd e+Z,Gd!d"e-Z.Gd#d$Z/Gd%d&e,Z0Gd'd(e-Z1Gd)d*eZ2Gd+d,eZ3Gd-d.eZ4Gd/d0eZ5d1Z6e7d2k(re6yy)6z8 Corpus reader for the FrameNet 1.7 lexicon and corpus. N) OrderedDict defaultdict) zip_longest) itemgetter)pprint)XMLCorpusReader XMLCorpusView)LazyConcatenationLazyIteratorListLazyMapz epytext enc+Ktj|ddjdfd}|ddD]}t||yw)zy Wrap the first of 'lines' with textwrap and the remaining lines at exactly the same positions as the first. rFdrop_whitespace c3Kd}|rN|tdz kr=|dt||t|d}|dz }|r|tdz kr=|r0tj|djdEd{yy7w)NrFrr)lentextwrapfillsplit)lineil0l0wrap_ats P/var/www/openai/venv/lib/python3.12/site-packages/nltk/corpus/reader/framenet.py_zmimic_wrap.._'ssSWq[(~RW& &BsG 'D 1HCsSWq[( }}T7EJPPQUV V V  VsAB ,B B B rN)rrrlist)linesrkwargsrlrs ` @r mimic_wrapr!sU uQx% @ F Ft LB HW12Y1Q4jsAAcdjtj||jdDcgc]}||z c}Scc}w)z Helper function for pretty-printing a long string. :param defstr: The string to be printed. :type defstr: str :return: A nicely formatted string representation of the long string. :rtype: str r)joinrrr)defstrprefixrrs r_pretty_longstringr&5sF 99#+==#A#G#G#MN#M4$#MN Ns Acd}|D]f}t||trBt||dkDr1|d|dz }|djt ||dz }|dz }X|d|d ||dz }h|S) z Helper function for pretty-printing any AttrDict object. :param obj: The obj to be printed. :type obj: AttrDict :return: A nicely formatted string representation of the AttrDict object. :rtype: str A[z] z{} r%r] ) isinstancestrrformatr&)objoutstrks r _pretty_anyr4CsF  c!fc "s3q6{R'7 !Cj F dkk"4SVD"IJ JF dNF !Bs1vhb) )F  Mc|j}t|dk(ryd}|dj|z }d|vr|d|jdz }d|vr|d z }|t |j d z }|d |j jd |j jd z }|j|dz }n4|d|jjd |jjd z }|dt|jdz }|d djd|jDzdt|jdkDzzz }|S)z Helper function for pretty-printing a semantic type. :param st: The semantic type to be printed. :type st: AttrDict :return: A nicely formatted string representation of the semantic type. :rtype: str rzr(z!semantic type ({0.ID}): {0.name} abbrev [abbrev] r definition [definition] r+z [rootType] () z[superType] z [superType] z [subTypes] z subtypes , c3TK|] }|jd|jd"ywr;)NnameID.0xs r z"_pretty_semtype..vs&=AqvvhavQ'&(r) keysrr0r7r&r9rootTyperBrC superTypesubTypesr#)stsemkeysr2s r_pretty_semtyperOYsWggiG 7|q F 299"==F7Ibii[++w""$R]]D99 BKK,,-Qr{{~~.>cBBF ||((L!2!2 31R\\__4ESII C ,-[99F  ))== = > #bkk"Q& ' (F Mr5c(dj|}|S)z Helper function for pretty-printing a frame relation type. :param freltyp: The frame relation type to be printed. :type freltyp: AttrDict :return: A nicely formatted string representation of the frame relation type. :rtype: str zR {0.subFrameName}>r0)freltypr2s r_pretty_frame_relation_typerS|sb h hF Mr5c(dj|}|S)z Helper function for pretty-printing a frame relation. :param frel: The frame relation to be printed. :type frel: AttrDict :return: A nicely formatted string representation of the frame relation. :rtype: str zg<{0.type.superFrameName}={0.superFrameName} -- {0.type.name} -> {0.type.subFrameName}={0.subFrameName}>rQ)frelr2s r_pretty_frame_relationrVsw } } F Mr5c(dj|}|S)z Helper function for pretty-printing an FE relation. :param ferel: The FE relation to be printed. :type ferel: AttrDict :return: A nicely formatted string representation of the FE relation. :rtype: str z<{0.type.superFrameName}={0.frameRelation.superFrameName}.{0.superFEName} -- {0.type.name} -> {0.type.subFrameName}={0.frameRelation.subFrameName}.{0.subFEName}>rQ)ferelr2s r_pretty_fe_relationrYs%qxx F Mr5c|j}d}|dj|z }d|vr|dz }|t|jdz }d|vr4|d|jj d|jj d z }d |vr|d |jd z }d |vr|d|jd z }d|vr|d|jd z }d|vr|d|jdz }d|vr4|djdjd|jDz }d|vry|dt|jdz }|dt|jdkDzdjd|jDzd t|jdkDzzz }d|vr|d|jd z }d |vr|j Dcgc]}|j }}|d!t|j d"z }t#j$djt'|d#j)d D] }|d|d z } d$|vr'|d%jt|j*z }|Scc}w)&z Helper function for pretty-printing a lexical unit. :param lu: The lu to be printed. :type lu: AttrDict :return: A nicely formatted string representation of the lexical unit. :rtype: str r(z!lexical unit ({0.ID}): {0.name} r9r:r+framez [frame] r;r<incorporatedFEz [incorporatedFE] rPOS [POS] status [status] totalAnnotatedz [totalAnnotated] z annotated examples lexemesz [lexemes] {}  c3RK|]}|jd|j!yw)/N)rBr])rElexs rrGz_pretty_lu..s$C z377), s%'semTypesz [semTypes]  semantic types rr=c3TK|] }|jd|jd"ywr?rArDs rrGz_pretty_lu..s&A[166(!ADD6+[rHURLz [URL] subCorpusz [subCorpus] z subcorpora < exemplarsz0 [exemplars] {} sentences across all subcorpora )rIr0r&r9r[rBrCr\r]r_rar#rbrrgrjrkrrsortedrrm)lulukeysr2rFsubcrs r _pretty_lurrsWWYF F 3::2>>Fv""$R]]D99&Jrxx}}oQrxx{{m3??6!'(9(9':"== HRVVHB''6K {"--6!'(9(9'::OPPF$++ HHC C C  VM#bkk"2!33DEE C $q( )iiAR[[AA Bc"++&*+ ,   HRVVHB''f " - 1 -N3r||#4"5]CCMM$))F4L"92>DDTJD 4&m #FKfFMM     M.s;I$cd}|dj|z }t|D]\}}|d|d|jdz }|dz }|S)a  Helper function for pretty-printing a list of exemplar sentences for a lexical unit. :param sent: The list of exemplar sentences to be printed. :type sent: list(AttrDict) :return: An index of the text of the exemplar sentences. :rtype: str r(z4exemplar sentences for {0.name} in {0.frame.name}: r*r-r)r0 enumeratetext)rmror2isents r_pretty_exemplarsrxs]F FMMbQQFY'4AaS499+R((( dNF Mr5cd}|dj|z }|dj|z }|dz }t|jD]\}}|d|d|jdz }|dz }|S)z Helper function for pretty-printing a list of annotated sentences for a full-text document. :param sent: The list of sentences to be printed. :type sent: list(AttrDict) :return: An index of the text of the sentences. :rtype: str r(z'full-text document ({0.ID}) {0.name}: zY[corpid] {0.corpid} [corpname] {0.corpname} [description] {0.description} [URL] {0.URL} z [sentence] r*r-r)r0rtsentenceru)sentsr2rvrws r_pretty_fulltext_sentencesr|sF 9@@GGF nuu F FU^^,4AaS499+R((- dNF Mr5c(d}|dj||jjd|jjz }|dt |j dz }|d|j dz }|dz }||jz }|d z }|S) a Helper function for pretty-printing an annotated sentence from a full-text document. :param sent: The sentence to be printed. :type sent: list(AttrDict) :return: The text of the sentence with annotation set indices on frame targets. :rtype: str r(z%full-text sentence ({0.ID}) in {1}: rBr^ tags  [POS_tagset]  z[text] + [annotationSet] r)r0docget descriptionrr] POS_tagset_ascii)rwr2s r_pretty_fulltext_sentencersF 7>> dhhll6488#7#78F TXXw//F 055F ,,F dkkmF dNF Mr5c d}|dj|z }t|j}|j}|j}d}d}d}d}|D]\} } } | |k\s Jd| | | ff|d| |z zd| | z zzz }t | | | z kDrDt | | | z z } |d| |zd| zz|| |zdz}|d| |zd| zz|| |zdz}|| z }|d| |z z| j | | z zz }| }|||g} |d jtd jtt| d dijddz }|d z }|S) z Helper function for pretty-printing a sentence with its POS tags. :param aset: The POS annotation set of the sentence to be printed. :type sent: list(AttrDict) :return: The text of the sentence and its POS tags. :rtype: str r(zEPOS annotation set ({0.ID}) {0.POS_tagset} in sentence {0.sent.ID}: rOverlapping targets?rc-N~rr fillvalue) r0rnr]rwrurljustr#maprr!replace)asetr2overtrws0s1s2rvadjustjr3lblamt long_liness r _pretty_posrsF W^^ F 488 E 99D B B B A F 1cAv<.As < 77 7==dggF F  -44 F :AA "" #   HS]O733ODOO#4B77 &-- DGG S\Q.cBF $++ DGG S\Q.cBF&N/ $;49 *11Sc^c$s)n.AUs F/  **FE $;49 SEm #FE * H  j F fF dkkmF dNF Mr5c|jdk(sd|vr#t|jdkDr t|St |S)ar Given a sentence or FE annotation set, construct the width-limited string showing an ASCII visualization of the sentence's annotations, calling either _annotation_ascii_frames() or _annotation_ascii_FEs() as appropriate. This will be attached as a method to appropriate AttrDict instances and called in the full pretty-printing of the instance. fulltext_sentencer)_typerr_annotation_ascii_frames_annotation_ascii_FEs)rws r_annotation_asciirsC zz((4C(:(:$;a$?(--$T**r5c g}t|jddD]\}}|jD]\}}d|dzd}|jdk(s|jjdk(r7|dz }|jdk(r|dz }|jjdk(r|d z }|j |||jj j|ft|}t}t|D]\}\}}} } |d kDs|||dz dks ||dz dd ||fk(re||dz d | k(rW||dz d | z} | jd djdd} ||dz dd | fz||dz <|j||j} |D](\}}} } | d| zdz|j||zdz| zz } *| dz } | cStt|D]}||=|j} d}d}d}d }d }t}|D]R\}}} } ||k\s5||k\s0Jdtd|jddDrdndz||| ff|d||z zd||z zzz }| d||z }||z t!| kr5d }||vr*||| k(rn&|dz }| d||z dz t#|z}||vr*| ||<|d||z z|j%||z zz }t!| ||z kDr[t!| ||z z }| d||zd|zz| ||zdz} |d||zd|zz|||zdz}|d||zd|zz|||zdz}||z }|d||z z| j%||z zz }|}U| |||g}dj't)dj&t+t-|ddijdd}|dz }|rV|ddj'd|j/Dzdzz }t!|t!t1|k(sJd |S)!a! ASCII string rendering of the sentence along with its targets and frame names. Called for all full-text sentences, as well as the few LU sentences with multiple targets (e.g., fn.lu(6412).exemplars[82] has two want.v targets). Line-wrapped to limit the display width. rNr*rUNANNProblemrc!?rrz !z! z ?z? rz :: zG (Unable to display sentence with targets marked inline due to overlap)r(rc3:K|]}|jdk(yw)rN)r_)rErs rrGz+_annotation_ascii_frames..sU>Td4;;'1>Tsz UNANN*rrrrr=c3>K|]}dj|yw=Nr#rEpairs rrGz+_annotation_ascii_frames..s"O>Nd388D>>Nr@Abbreviation clash)rtrTargetr_rappendr[rBrnsetraddrureversedranyrr/rr#rrr!itemsdict)rwrarrr3indexS duplicatesofname asetIndex combinedIndexrrrs11rrvrfAbbrevsshortrrrr2s rrrs ET//344KKDAqQq\F{{g%9)D# ;;')cMF77>>Y.cMF LL!Q 2 2F; < 5 5MEJ'0'7# #Aq% q5Q%A,q/)a!e Ra QF*uQU|A%/G!a%LOi/!. 5 5dD A I I$PT U $QU|BQ/=2BBa!e q!II.3*Aq% )C/$))Aa.@6IEQQA/4__'(8(fZ( ) !H* B B C B A F}H"'1eYAv6 &Ud>P>PQRQS>TUU  Ay! 6 cQUmcQUm++gA ESZ A8#E?e+QkA *SV3 8# #( sa!e}u{{1q5111 y>QU #i.AE*CN"OOORUUU8}DN 33I5II3 Mr5c d}d}d}|D]\}}}|d||z z|jrdnd||z zzz }|d||z } t|t| kDr5d} | |vr*|| |k(rn&| dz } |d||z dz t| z} | |vr*||| <|d||z z| j||z zz }|}d} |r8| dd j d t |j Dzd zz } ||| gS) z#Helper for _annotation_ascii_FEs().r(rrc^rNrz [r=c3>K|]}dj|yw):NrrDs rrGz-_annotation_ascii_FE_layer..;sH5G 5Grr)islowerrr/rr#rnr) rni feAbbrevsrrrvrr3fenamerrsNIs r_annotation_ascii_FE_layerr%s1 B B A 1f cQUmfnn&6sCAEJJJwQ v;U #A9$U#v-Q{Q+c!f4 9$ $* %  cQUmekk!a%000  C  tdiiHVBHHJ5GHHH3NN C=r5c t}g}d}dD]w}||vs||s||D]b\}|dk(r tfd|jdDrd}|j|j j ddfdy|r t |i|}t t|jd|s|ngz|jd |}d x}} d |vrRt |jd|jd |}d |vr't |jd|jd |} |jD]\} } |\} } }t| | kr| d | t| z zz } t| | kr| d | t| z zz } | |d <| d | | | | j d dj ddz| | d z|d<|jg}|r|jd d|j|d|d |dzg|r@|j|d|d |dzg| r|j| d| d | dzg|jddjtdjt!t#|dd i}|rV|ddjd|j%Dzdzz }t|tt'|k(sJd|dz }|S)a ASCII string rendering of the sentence along with a single target and its FEs. Secondary and tertiary FE layers are included if present. 'sent' can be an FE annotation set or an LU sentence with a single target. Line-wrapped to limit the display width. FrXc3bK|]&\}}}|cxkr|ksn|cxkrks nnd(yw)rN)rErFrfelblrbs rrGz(_annotation_ascii_FEs..Qs-SJ[Q5!q*1*Q QR qJs!/ /rTrr(rNrrrcrrrrrr;r=c3>K|]}dj|ywrrrs rrGz(_annotation_ascii_FEs..}s!O=NT#((4.=Nrr@r)rrFErlowerrrrnrrrrruextendr#rrr!rr)rwrposspecposspec_separaterrPOSSPECFE1rrrvrFE1spanFE1nameFE1exprr2rrs @@rrr?s IGD $;49!#Y 1c3JSDGGAJSS%399;..sB78'E ,Wb)D $twwqz, r;r< excludesFEz [excludesFE] semTypez [semType]  r@) rIr0r[r&r9r7rrrBrCrr)fefekeysr2s r _pretty_fersWWYF F KRR BHHFv""$R]]D996Ibii[++VK }B//v/! == j F ++,Abmm.>.>-?sC CFv/! == j F ++,Abmm.>.>-?sC CFF, ::  j F M f"**//!2!BJJMM?!DDtK KF Mr5c 4d}|dj|z }|d|jdz }|dz }|t|jddzz }|dt |j d z }|dt |j d kDzd j d |j Dzdt |j d kDzzz }|d jt |jz }|ddj d|jDzdzz }|dt |jdz }g}t|jjD](\}}|d|jd}|j|*|djtd j |dz }|dt |jdz }i}t|jjD]4\}} ||jj|d|jd6t|j!dD]2} |dj| d j t|| z }4|djt |j"z }|ddj d|j"Dzdzz }|S#t$rAg||j<||jj|d|jdY%wxYw)z Helper function for pretty-printing a frame. :param frame: The frame to be printed. :type frame: AttrDict :return: A nicely formatted string representation of the frame. :rtype: str r(zframe ({0.ID}): {0.name} z[URL] rr:r+rz [semTypes] rhrr=c3TK|] }|jd|jd"ywr?rArDs rrGz _pretty_frame..s&@AqvvhavQ'rHz% [frameRelations] {} frame relations rc32K|]}t|ywN)repr)rErUs rrGz _pretty_frame..s M8Ld8Lsz [lexUnit] z lexical units rr@z{} r,z [FE] z frame elements c(gdj|S)N)CorezCore-Unexpressed PeripheralzExtra-Thematic)index)ct2s rz_pretty_frame..s %* r5keyz {:>16}: {} z) [FEcoreSets] {} frame element core sets c3xK|]-}dj|Dcgc]}|jc}/ycc}ww)r=N)r#rB)rEcoreSetrFs rrGz _pretty_frame..s4 @PWDIIw/w!qvvw/ 0@P/s :5 :)r0rjr&r9rrgr#frameRelationslexUnitrnrrCrrrKeyErrorrI FEcoreSets) r[r2lustrsluNamerotmpstrfesfeNamercts r _pretty_framer"sF ,33E::F uyyk&&F F  !1!1484??F C/00ABBF  ENN#a'( ))@@ @ A #enn%) * +F  7>> E !F dV[[ M8L8L MMMPTTTF S/00@AAF FU]]0023 82beeWA& f4 fmm.tyy/@NOOF EHH &788F CUXX^^-.  ;   # #vhbq$9 :/     .''DIIfSWo,FGG ;BB E  F  ++ @E@P@P      F M3 ;!C    # #vhbq$9 : ;s8.K  ALLceZdZdZy) FramenetErrorz/An exception class for framenet-related errors.N)__name__ __module__ __qualname____doc__rr5rr$r$s9r5r$cPeZdZdZfdZdZdZfdZdZdZ dZ d Z xZ S) AttrDictaA class that wraps a dict and allows accessing the keys of the dict as if they were attributes. Taken from here: https://stackoverflow.com/a/14620633/8879 >>> foo = {'a':1, 'b':2, 'c':3} >>> bar = AttrDict(foo) >>> pprint(dict(bar)) {'a': 1, 'b': 2, 'c': 3} >>> bar.b 2 >>> bar.d = 4 >>> pprint(dict(bar)) {'a': 1, 'b': 2, 'c': 3, 'd': 4} c$t||i|yr )super__init__selfargsr __class__s rr-zAttrDict.__init__s $)&)r5c|||<yr r)r/rBvalues r __setattr__zAttrDict.__setattr__ s T r5c.|dk(r |jS||S)N _short_repr)r6r/rBs r __getattr__zAttrDict.__getattr__s = ## #Dzr5cft||}t|tr|j S|Sr )r, __getitem__r.Future_data)r/rBvr1s rr:zAttrDict.__getitem__s- G  % a 779 r5cNd|vrA|djdr|jS dj|d|d|dS|jS#t$rE dj|d|dcYS#t$rdj|d|dcYcYSwxYwwxYw)Nrrelationz<{} ID={} name={}>rCrBz <{} name={}>z <{} ID={}>)endswith__repr__r0rr/s rr6zAttrDict._short_reprs d?G}%%j1}}& J+22M4:tF|==? "  JJ)00gV MMJ'..tG}d4jIIJ Js/A B$ A:7B$:!B B$B  B$cd}d|vr t|}|S|ddk(r t|}|S|ddk(r t|}|S|ddk(r t|}|S|ddk(rt ||dj }|S|ddk(r t |}|S|dd k(r t|}|S|dd k(r t|}|S|dd vrt|d }|S|ddk(r t|}|S|ddk(r t|}|S|ddk(r t|}|S|ddk(r t|}|S|ddk(r t|}|St|}|S)Nr(rr[rro luexemplarsrfulltext_annotation lusentencer)luannotationsetfulltext_annotationsetT)rposannotationsetsemtypeframerelationtype framerelation ferelation)r4r"rrrrxrr|rrrrOrSrVrYr/r2s r_strz AttrDict._str)s $  &FJ I']g %"4(FF E']d "%FB A']d "%F> =']m +&tT!WZZ8F: 7 M2 2/5F2 1']l *'-F. -']1 1.t4F* )']K K'>F& %']0 0 &F" !']i '$T*F ']1 106F ']o -+D1F ']l *(.F !&F r5c"|jSr rOrBs r__str__zAttrDict.__str__Tyy{r5c"|jSr rRrBs rrAzAttrDict.__repr__W||~r5) r%r&r'r(r-r4r8r:r6rOrRrA __classcell__r1s@rr*r*s1 *  # )Vr5r*c4eZdZdZfdZdZdZdZxZS) SpecialListz A list subclass which adds a '_type' attribute for special printing (similar to an AttrDict, though this is NOT an AttrDict subclass). c2t||i|||_yr )r,r-r)r/typr0rr1s rr-zSpecialList.__init__as $)&) r5cd}|jsJt|dk(rd}|S|jdk(rt||dj}|SJ|j)Nr(rz[]rD)rrrxrrNs rrOzSpecialList._stresczzz t9>F  ZZ= (&tT!WZZ8F  %$** $5r5c"|jSr rQrBs rrRzSpecialList.__str__qrSr5c"|jSr rUrBs rrAzSpecialList.__repr__trVr5) r%r&r'r(r-rOrRrArWrXs@rrZrZ[s  r5rZcReZdZdZfdZdZdZdZdZdZ dZ d Z d Z xZ S) r;z Wraps and acts as a proxy for a value to be loaded lazily (on demand). Adapted from https://gist.github.com/sergey-miryanov/2935416 c@t||i|||_d|_y)z} :param loader: when called with no arguments, returns the value to be stored :type loader: callable N)r,r-_loader_d)r/loaderr0rr1s rr-zFuture.__init__~s% $)&) r5c|t|jr|j|_d|_|jSr )callablerbrcrBs rr<z Future._datas+ DLL !llnDGDLwwr5c4t|jSr )boolr<rBs r __nonzero__zFuture.__nonzero__sDJJL!!r5c4t|jSr )rr<rBs r__len__zFuture.__len__s4::<  r5cB|jj||Sr )r< __setitem__)r/rr3s rrmzFuture.__setitem__szz|''U33r5c@|jj|Sr )r<r:r/rs rr:zFuture.__getitem__zz|'',,r5c@|jj|Sr )r<r8ros rr8zFuture.__getattr__rpr5c>|jjSr )r<rRrBs rrRzFuture.__str__szz|##%%r5c>|jjSr )r<rArBs rrAzFuture.__repr__szz|$$&&r5)r%r&r'r(r-r<rirkrmr:r8rRrArWrXs@rr;r;xs5  "!4--&'r5r;c(eZdZdZfdZdZxZS) PrettyDictz Displays an abbreviated repr of values where possible. Inherits from AttrDict, so a callable value will be lazily converted to an actual value. cv|jdd}t||i|tj |d|y)N breakLinesF _BREAK_LINES)popr,r-rr4)r/r0rrxr1s rr-zPrettyDict.__init__s7zz,6  $)&) ~|Z>y)FFramenetCorpusReaderaTA corpus reader for the Framenet Corpus. >>> from nltk.corpus import framenet as fn >>> fn.lu(3238).frame.lexUnit['glint.v'] is fn.lu(3238) True >>> fn.frame_by_name('Replacing') is fn.lus('replace.v')[0].frame True >>> fn.lus('prejudice.n')[0].frame.frameRelations == fn.frame_relations('Partiality') True rFc||_y)a<Enable or disable warnings of data integrity issues as they are encountered. If v is truthy, warnings will be enabled. (This is a function rather than just an attribute/property to ensure that if enabling warnings is the first action taken, the corpus reader is instantiated first.) N) _warnings)r/r=s rwarningszFramenetCorpusReader.warningsGs r5ctj|||d|_d|_d|_d|_d|_i|_d|_d|_ d|_ d|_ d|_ d|_ d|_d|_y)Nr[rofulltextz2https://framenet2.icsi.berkeley.edu/fnReports/dataz README.txt)rr- _frame_dir_lu_dir _fulltext_dir _fnweb_url _frame_idx_cached_frames_lu_idx _fulltext_idx _semtypes _freltyp_idx _frel_idx _ferel_idx _frel_f_idx_readme)r/rootfileidss rr-zFramenetCorpusReader.__init__Ps  tW5" 'O  ! # r5NcV|t|j|Sd}t|y)z6Display help information summarizing the main methods.NaK Citation: Nathan Schneider and Chuck Wooters (2017), "The NLTK FrameNet API: Designing for Discoverability with a Rich Linguistic Resource". Proceedings of EMNLP: System Demonstrations. https://arxiv.org/abs/1703.07438 Use the following methods to access data in FrameNet. Provide a method name to `help()` for more information. FRAMES ====== frame() to look up a frame by its exact name or ID frames() to get frames matching a name pattern frames_by_lemma() to get frames containing an LU matching a name pattern frame_ids_and_names() to get a mapping from frame IDs to names FRAME ELEMENTS ============== fes() to get frame elements (a.k.a. roles) matching a name pattern, optionally constrained by a frame name pattern LEXICAL UNITS ============= lu() to look up an LU by its ID lus() to get lexical units matching a name pattern, optionally constrained by frame lu_ids_and_names() to get a mapping from LU IDs to names RELATIONS ========= frame_relation_types() to get the different kinds of frame-to-frame relations (Inheritance, Subframe, Using, etc.). frame_relations() to get the relation instances, optionally constrained by frame(s) or relation type fe_relations() to get the frame element pairs belonging to a frame-to-frame relation SEMANTIC TYPES ============== semtypes() to get the different kinds of semantic types that can be applied to FEs, LUs, and entire frames semtype() to look up a particular semtype by name, ID, or abbreviation semtype_inherits() to check whether two semantic types have a subtype-supertype relationship in the semtype hierarchy propagate_semtypes() to apply inference rules that distribute semtypes over relations between FEs ANNOTATIONS =========== annotations() to get annotation sets, in which a token in a sentence is annotated with a lexical unit in a frame, along with its frame elements and their syntactic properties; can be constrained by LU name pattern and limited to lexicographic exemplars or full-text. Sentences of full-text annotation can have multiple annotation sets. sents() to get annotated sentences illustrating one or more lexical units exemplars() to get sentences of lexicographic annotation, most of which have just 1 annotation set; can be constrained by LU name pattern, frame, and overt FE(s) doc() to look up a document of full-text annotation by its ID docs() to get documents of full-text annotation that match a name pattern docs_metadata() to get metadata about all full-text documents without loading them ft_sents() to iterate over sentences of full-text annotation UTILITIES ========= buildindexes() loads metadata about all frames, LUs, etc. into memory to avoid delay when one is accessed for the first time. It does not load annotations. readme() gives the text of the FrameNet README file warnings(True) to display corpus consistency warnings when loading data )help__getattribute__print)r/attrnamemsgs rrzFramenetCorpusReader.helpks2  --h78 8 G P c r5c|js|ji|_t|j dd|j 5}|D]}||j|d< dddy#1swYyxYw)NzframeIndex.xmlzframeIndex/framerC)r_buildrelationindexrr abspath _handle_elt)r/viewfs r_buildframeindexz%FramenetCorpusReader._buildframeindexsm~~  $ $ &  LL) *,>@P@P +,$(   s A..A7ci|_t|jdd|j5}|D]"}|D]}||j|j<$ dddy#1swYyxYw)NzfulltextIndex.xmlzfulltextIndex/corpus)rr r_handle_fulltextindex_eltrC)r/rdoclistrs r_buildcorpusindexz&FramenetCorpusReader._buildcorpusindexsj   LL, - "  * * "C14D&&svv.#    s (A  A)ci|_t|jdd|j5}|D]}||j|d< dddy#1swYyxYw)Nz luIndex.xmlz luIndex/lurC)rr rr)r/rros r _buildluindexz"FramenetCorpusReader._buildluindexs[  LL 't7G7G  RX&   s AAc i_i_tt_i_t jddj5}|D]z}|j|j<|jD]N}tfd|jx}x|_ ||j<tfd|jx}x|_||j"<|j|j<j|jj%|jj|jj%|j|j&D]W}||_ ||_td||_td||_|j |j<YQ} dddy#1swYyxYw)NzfrRelation.xmlz frameRelations/frameRelationTypecfdS)Nc&jSr  frame_by_idfIDr/srrzLFramenetCorpusReader._buildrelationindex....T-=-=c-Br5rrs`rrz:FramenetCorpusReader._buildrelationindex..%Br5cfdS)Nc&jSr rrsrrzLFramenetCorpusReader._buildrelationindex....rr5rrs`rrz:FramenetCorpusReader._buildrelationindex..rr5cfdS)NcJjjjSr ) superFramer superFENamefersrrzLFramenetCorpusReader._buildrelationindex....s1B1B3??1Sr5rrs`rrz:FramenetCorpusReader._buildrelationindex..s)Sr5cfdS)NcJjjjSr )subFramer subFENamersrrzLFramenetCorpusReader._buildrelationindex....s1Or5rrs`rrz:FramenetCorpusReader._buildrelationindex..s)Or5)rrrrrrr r_handle_framerelationtype_eltrCrr;supIDrsuperFrameNamesubIDr subFrameNamer feRelationssuperFEsubFE)r/rrRrUsupFsubFrXs` rrz(FramenetCorpusReader._buildrelationindexs&s+  LL) * .  . . 07!!'**-#22DLRBDJJOMD4?T'2H2H-IIOBDJJOID4=40D0D+E/3DNN477+$$TZZ044TWW=$$TZZ044TWW=!%!1!1+/()-(.S %) '-OQVW' 5:1"23    s FGG%ct|jr,|jdtjt |i|yy)Nfile)r setdefaultsysstderrr)r/messagers r_warnzFramenetCorpusReader._warn s/ >>   fcjj 1 7 %f % r5c|j|j|j|jy)zE Build the internal indexes to make look-ups faster. N)rrrrrBs r buildindexesz!FramenetCorpusReader.buildindexess4       "r5c |j|j}t jj|j|j|}t|d5}|d}ddd|j}|j|jD] \}} | ||< |S#t$r,|j|j|j}Yt$r}t d||d}~wwxYw#1swYxYw)a Returns the annotated document whose id number is ``fn_docid``. This id number can be obtained by calling the Documents() function. The dict that is returned from this function will contain the following keys: - '_type' : 'fulltextannotation' - 'sentence' : a list of sentences in the document - Each item in the list is a dict containing the following keys: - 'ID' : the ID number of the sentence - '_type' : 'sentence' - 'text' : the text of the sentence - 'paragNo' : the paragraph number - 'sentNo' : the sentence number - 'docID' : the document ID number - 'corpID' : the corpus ID number - 'aPos' : the annotation position - 'annotationSet' : a list of annotation layers for the sentence - Each item in the list is a dict containing the following keys: - 'ID' : the ID number of the annotation set - '_type' : 'annotationset' - 'status' : either 'MANUAL' or 'UNANN' - 'luName' : (only if status is 'MANUAL') - 'luID' : (only if status is 'MANUAL') - 'frameID' : (only if status is 'MANUAL') - 'frameName': (only if status is 'MANUAL') - 'layer' : a list of labels for the layer - Each item in the layer is a dict containing the following keys: - '_type': 'layer' - 'rank' - 'name' - 'label' : a list of labels in the layer - Each item is a dict containing the following keys: - 'start' - 'end' - 'name' - 'feID' (optional) :param fn_docid: The Framenet id number of the document :type fn_docid: int :return: Information about the annotated document :rtype: dict zUnknown document id: NfullTextAnnotationr)rfilename TypeErrorrrr$ospathr#_rootrr _handle_fulltextannotation_eltr) r/fn_docidxmlfnameelocpathrrinfor3r=s rrzFramenetCorpusReader.docs\ K))(3<>> from nltk.corpus import framenet as fn >>> f = fn.frame_by_id(256) >>> f.ID 256 >>> f.name 'Medical_specialties' >>> f.definition # doctest: +NORMALIZE_WHITESPACE "This frame includes words that name medical specialties and is closely related to the Medical_professionals frame. The FE Type characterizing a sub-are in a Specialty may also be expressed. 'Ralph practices paediatric oncology.'" :param fn_fid: The Framenet id number of the frame :type fn_fid: int :param ignorekeys: The keys to ignore. These keys will not be included in the output. (optional) :type ignorekeys: list(str) :return: Information about a frame :rtype: dict Also see the ``frame()`` function for details about what is contained in the dict that is returned. rrBzUnknown frame id: NF) check_cache)rrrrr$ frame_by_name)r/fn_fid ignorekeysfentryrBrs rrz FramenetCorpusReader.frame_by_idas> F__V,F&  &>D!!$ !FF  3  ! ! #??6*62D F"4VH =>A E Fs00+A9A9%A44A9Tc |r*||jvr|j|j|S|js|jtjj |j |j|dz} t|d5}|d}ddd|j|}|sJ|jdz|jzdz|zdz|_ |jD]u jj dk(s|j"j%D]<} t' fd| jDr"| jj) >w||j|j*<|j*|j|j < |S#1swY xYw#t$r}td||d}~wwxYw) a Get the details for the specified Frame using the frame's name. Usage examples: >>> from nltk.corpus import framenet as fn >>> f = fn.frame_by_name('Medical_specialties') >>> f.ID 256 >>> f.name 'Medical_specialties' >>> f.definition # doctest: +NORMALIZE_WHITESPACE "This frame includes words that name medical specialties and is closely related to the Medical_professionals frame. The FE Type characterizing a sub-are in a Specialty may also be expressed. 'Ralph practices paediatric oncology.'" :param fn_fname: The name of the frame :type fn_fname: str :param ignorekeys: The keys to ignore. These keys will not be included in the output. (optional) :type ignorekeys: list(str) :return: Information about a frame :rtype: dict Also see the ``frame()`` function for details about what is contained in the dict that is returned. .xmlr[rNzUnknown frame: re Lexical_typec3&K|]}|u ywr r)rErFrMs rrGz5FramenetCorpusReader.frame_by_name..s)4ARs)rrrrrr#rrr OSErrorr$_handle_frame_eltrrjrgrJrBrvaluesrrrC) r/fn_fnamer r rrrrr rorMs @rr z"FramenetCorpusReader.frame_by_names: 8t':'::??4#6#6x#@A A  ! ! #'',,$**FARS Ew0D1g1 ''Z8 v__s*T__1 ..//1B)+ **2. 2"&, "+199FKK(  710 E/( <=1 D Es0 F.F!F.!F+&F.. G 7GG crt|tr|j||}|S|j||}|S)a Get the details for the specified Frame using the frame's name or id number. Usage examples: >>> from nltk.corpus import framenet as fn >>> f = fn.frame(256) >>> f.name 'Medical_specialties' >>> f = fn.frame('Medical_specialties') >>> f.ID 256 >>> # ensure non-ASCII character in definition doesn't trigger an encoding error: >>> fn.frame('Imposing_obligation') # doctest: +ELLIPSIS frame (1494): Imposing_obligation... The dict that is returned from this function will contain the following information about the Frame: - 'name' : the name of the Frame (e.g. 'Birth', 'Apply_heat', etc.) - 'definition' : textual definition of the Frame - 'ID' : the internal ID number of the Frame - 'semTypes' : a list of semantic types for this frame - Each item in the list is a dict containing the following keys: - 'name' : can be used with the semtype() function - 'ID' : can be used with the semtype() function - 'lexUnit' : a dict containing all of the LUs for this frame. The keys in this dict are the names of the LUs and the value for each key is itself a dict containing info about the LU (see the lu() function for more info.) - 'FE' : a dict containing the Frame Elements that are part of this frame The keys in this dict are the names of the FEs (e.g. 'Body_system') and the values are dicts containing the following keys - 'definition' : The definition of the FE - 'name' : The name of the FE e.g. 'Body_system' - 'ID' : The id number - '_type' : 'fe' - 'abbrev' : Abbreviation e.g. 'bod' - 'coreType' : one of "Core", "Peripheral", or "Extra-Thematic" - 'semType' : if not None, a dict with the following two keys: - 'name' : name of the semantic type. can be used with the semtype() function - 'ID' : id number of the semantic type. can be used with the semtype() function - 'requiresFE' : if not None, a dict with the following two keys: - 'name' : the name of another FE in this frame - 'ID' : the id of the other FE in this frame - 'excludesFE' : if not None, a dict with the following two keys: - 'name' : the name of another FE in this frame - 'ID' : the id of the other FE in this frame - 'frameRelation' : a list of objects describing frame relations - 'FEcoreSets' : a list of Frame Element core sets for this frame - Each item in the list is a list of FE objects :param fn_fid_or_fname: The Framenet name or id number of the frame :type fn_fid_or_fname: int or str :param ignorekeys: The keys to ignore. These keys will not be included in the output. (optional) :type ignorekeys: list(str) :return: Information about a frame :rtype: dict )r.r/r r)r/fn_fid_or_fnamer rs rr[zFramenetCorpusReader.framesAN os +""?J?A  *=Ar5cHtfd|jDS)a Returns a list of all frames that contain LUs in which the ``name`` attribute of the LU matches the given regular expression ``pat``. Note that LU names are composed of "lemma.POS", where the "lemma" part can be made up of either a single lexeme (e.g. 'run') or multiple lexemes (e.g. 'a little'). Note: if you are going to be doing a lot of this type of searching, you'd want to build an index that maps from lemmas to frames because each time frames_by_lemma() is called, it has to search through ALL of the frame XML files in the db. >>> from nltk.corpus import framenet as fn >>> from nltk.corpus.reader.framenet import PrettyList >>> PrettyList(sorted(fn.frames_by_lemma(r'(?i)a little'), key=itemgetter('ID'))) # doctest: +ELLIPSIS [, ] :return: A list of frame objects. :rtype: list(AttrDict) c3^K|]$}tfd|jDr|&yw)c3JK|]}tj|ywr research)rErpats rrGzAFramenetCorpusReader.frames_by_lemma...7sB f299S&) s #N)rr)rErrs rrGz7FramenetCorpusReader.frames_by_lemma..4s+ "B BB "s*-)rframes)r/rs `rframes_by_lemmaz$FramenetCorpusReader.frames_by_lemmas%* [[]   r5c,|j|ddgS)a Returns basic information about the LU whose id is ``fn_luid``. This is basically just a wrapper around the ``lu()`` function with "subCorpus" info excluded. >>> from nltk.corpus import framenet as fn >>> lu = PrettyDict(fn.lu_basic(256), breakLines=True) >>> # ellipses account for differences between FN 1.5 and 1.7 >>> lu # doctest: +ELLIPSIS {'ID': 256, 'POS': 'V', 'URL': 'https://framenet2.icsi.berkeley.edu/fnReports/data/lu/lu256.xml', '_type': 'lu', 'cBy': ..., 'cDate': '02/08/2001 01:27:50 PST Thu', 'definition': 'COD: be aware of beforehand; predict.', 'definitionMarkup': 'COD: be aware of beforehand; predict.', 'frame': , 'lemmaID': 15082, 'lexemes': [{'POS': 'V', 'breakBefore': 'false', 'headword': 'false', 'name': 'foresee', 'order': 1}], 'name': 'foresee.v', 'semTypes': [], 'sentenceCount': {'annotated': ..., 'total': ...}, 'status': 'FN1_Sent'} :param fn_luid: The id number of the desired LU :type fn_luid: int :return: Basic information about the lexical unit :rtype: dict rkrm)r ro)r/fn_luids rlu_basiczFramenetCorpusReader.lu_basic:s>wwwK+EwFFr5cn|js|jt}|jj||}||ur|j dj ||||t d|||dd}|j|j}|j|k(sJ|j|f||d<||j|<n.d|vr*|j|j}|j|}|r2t |jD cic] \} } | |vs | | c} } S|Scc} } w)aq Access a lexical unit by its ID. luName, frameID, and frameName are used only in the event that the LU does not have a file in the database (which is the case for LUs with "Problem" status); in this case, a placeholder LU is created which just contains its name, ID, and frame. Usage examples: >>> from nltk.corpus import framenet as fn >>> fn.lu(256).name 'foresee.v' >>> fn.lu(256).definition 'COD: be aware of beforehand; predict.' >>> fn.lu(256).frame.name 'Expectation' >>> list(map(PrettyDict, fn.lu(256).lexemes)) [{'POS': 'V', 'breakBefore': 'false', 'headword': 'false', 'name': 'foresee', 'order': 1}] >>> fn.lu(227).exemplars[23] # doctest: +NORMALIZE_WHITESPACE exemplar sentence (352962): [sentNo] 0 [aPos] 59699508 [LU] (227) guess.v in Coming_to_believe [frame] (23) Coming_to_believe [annotationSet] 2 annotation sets [POS] 18 tags [POS_tagset] BNC [GF] 3 relations [PT] 3 phrases [Other] 1 entry [text] + [Target] + [FE] When he was inside the house , Culley noticed the characteristic ------------------ Content he would n't have guessed at . -- ******* -- Co C1 [Evidence:INI] (Co=Cognizer, C1=Content) The dict that is returned from this function will contain most of the following information about the LU. Note that some LUs do not contain all of these pieces of information - particularly 'totalAnnotated' and 'incorporatedFE' may be missing in some LUs: - 'name' : the name of the LU (e.g. 'merger.n') - 'definition' : textual definition of the LU - 'ID' : the internal ID number of the LU - '_type' : 'lu' - 'status' : e.g. 'Created' - 'frame' : Frame that this LU belongs to - 'POS' : the part of speech of this LU (e.g. 'N') - 'totalAnnotated' : total number of examples annotated with this LU - 'incorporatedFE' : FE that incorporates this LU (e.g. 'Ailment') - 'sentenceCount' : a dict with the following two keys: - 'annotated': number of sentences annotated with this LU - 'total' : total number of sentences with this LU - 'lexemes' : a list of dicts describing the lemma of this LU. Each dict in the list contains these keys: - 'POS' : part of speech e.g. 'N' - 'name' : either single-lexeme e.g. 'merger' or multi-lexeme e.g. 'a little' - 'order': the order of the lexeme in the lemma (starting from 1) - 'headword': a boolean ('true' or 'false') - 'breakBefore': Can this lexeme be separated from the previous lexeme? Consider: "take over.v" as in:: Germany took over the Netherlands in 2 days. Germany took the Netherlands over in 2 days. In this case, 'breakBefore' would be "true" for the lexeme "over". Contrast this with "take after.v" as in:: Mary takes after her grandmother. *Mary takes her grandmother after. In this case, 'breakBefore' would be "false" for the lexeme "after" - 'lemmaID' : Can be used to connect lemmas in different LUs - 'semTypes' : a list of semantic type objects for this LU - 'subCorpus' : a list of subcorpora - Each item in the list is a dict containing the following keys: - 'name' : - 'sentence' : a list of sentences in the subcorpus - each item in the list is a dict with the following keys: - 'ID': - 'sentNo': - 'text': the text of the sentence - 'aPos': - 'annotationSet': a list of annotation sets - each item in the list is a dict with the following keys: - 'ID': - 'status': - 'layer': a list of layers - each layer is a dict containing the following keys: - 'name': layer name (e.g. 'BNC') - 'rank': - 'label': a list of labels for the layer - each label is a dict containing the following keys: - 'start': start pos of label in sentence 'text' (0-based) - 'end': end pos of label in sentence 'text' (0-based) - 'name': name of label (e.g. 'NN1') Under the hood, this implementation looks up the lexical unit information in the *frame* definition file. That file does not contain corpus annotations, so the LU files will be accessed on demand if those are needed. In principle, valence patterns could be loaded here too, though these are not currently supported. :param fn_luid: The id number of the lexical unit :type fn_luid: int :param ignorekeys: The keys to ignore. These keys will not be included in the output. (optional) :type ignorekeys: list(str) :return: All information about the lexical unit :rtype: dict z#LU ID not found: {} ({}) in {} ({})ror)rrCrBframeIDr_r[r) rrobjectrrr0r*rr&rBr) r/r#r rr& frameNameOOVluinforr3r=s rrozFramenetCorpusReader.lu[s5L||    h!!'3/ S= JJ5<<GY  !!"&' F  0A66Y& ;(; ;&F7O$*DLL ! F "  0A\\'*F fllnTnda@SQTnTU U Us  D1 "D1 c |j}d|d}tjj|j|j |}|j s|j t|d5}|d}ddd|j|} |jdz|j zdz|z|_ | j|_td|jD cgc]} | j D]} | c} } |_|j"D];} || d <|j$| d <| j&D]} || d <|j$| d <=|S#1swYxYw#t$r}td||d}~wwxYwcc} } w) z Augment the LU information that was loaded from the frame file with additional information from the LU file. rorrrNzUnknown LU id: rerDrr[)rCrrr#rrrrr rr$_handle_lexunit_eltrrjrkrZrzrmr[r) r/ror r#rrrrrlu2rqrwrs r_lu_filezFramenetCorpusReader._lu_filesf %%WIT"'',,$** eD||     Dw 2d1g3 &&sJ73&5;eC}} " R\\T\TdmmdDmD\T  LLDDJHHDM**T "W +! %32 D/' ; EE E;'E66E;ct|_t|jdd|j5}|D]>}|d}|d}|d}||j|<||j|<||j|<@ dddg}|j D]z}|j rP|j|j j|_|j jj|_||vr|j|||_ |t|}|sJ|rH|jd}|jD]$}|j|_ |j|&|rGyy#1swYxYw)z Create the semantic types index.z semTypes.xmlzsemTypes/semTyperBr7rCNr)r*rr r_handle_semtype_eltsemtypesrKrJrrLrrJrry) r/rrMnrrvrootsqueuechilds r _loadsemtypesz"FramenetCorpusReader._loadsemtypes&sG!  LL (   $ $ vJxLtH%&q!$%q!$&q!  --/B||#||BLL,>,>?  %%,,R0U?LL$  "U  u1B!# U#%5  s AE,,E5c|js|j|js|jd}d}d}|r|dz }d}|j D]}|j j }|jj } |rR||urN|0|j||sJ|j||jf||x|j_}d}|dz }|jjdvr@|r>||ur:|J|j||jf|x|j _}d}|dz }|ryy#t$r }Yd}~d}~wwxYw)a Apply inference rules to distribute semtypes over relations between FEs. For FrameNet 1.5, this results in 1011 semtypes being propagated. (Not done by default because it requires loading all frame files, which takes several seconds. If this needed to be fast, it could be rewritten to traverse the neighboring relations on demand for each FE semtype.) >>> from nltk.corpus import framenet as fn >>> x = sum(1 for f in fn.frames() for fe in f.FE.values() if fe.semType) >>> fn.propagate_semtypes() >>> y = sum(1 for f in fn.frames() for fe in f.FE.values() if fe.semType) >>> y-x > 1000 True TrrFN)Perspective_onSubframePrecedes) rr6rr fe_relationsrrrsemtype_inheritsrBtypeAssertionError)r/changedrv nPropagationsrXsuperSTsubSTexs rpropagate_semtypesz'FramenetCorpusReader.propagate_semtypesJsb~~      $ $ &   FAG**,--// ++7%#7$}0E0EeW0U#LL!!JJXU !=:AAEKK/%&*G)Q.M +UU!!0 'Quejj0QQ:?? -"&%* 1- :&sB,D;; E Ec&t|tr|}n |j|} |j|}|S#t$r"|j |j|}Y>> from nltk.corpus import framenet as fn >>> fn.semtype(233).name 'Temperature' >>> fn.semtype(233).abbrev 'Temp' >>> fn.semtype('Temperature').ID 233 :param key: The name, abbreviation, or id number of the semantic type :type key: string or int :return: Information about a semantic type :rtype: dict )r.intrrr6)r/rstidrMs rrJzFramenetCorpusReader.semtypes c3 D +~~c*  &%B   +""$~~c* +  &    %B  &s 6A$(A! A!$(BBct|ts|j|}t|ts|j|}|j}|r||ury|j}|ry)NTF)r.rrJrK)r/rMrApars rr<z%FramenetCorpusReader.semtype_inheritss["d#b!B'4(ll7+Gllg~--Cr5cb tjj}|1t fdj |jDStj|S#t$r6j tjj}YwxYw)a Obtain details for a specific frame. >>> from nltk.corpus import framenet as fn >>> len(fn.frames()) in (1019, 1221) # FN 1.5 and 1.7, resp. True >>> x = PrettyList(fn.frames(r'(?i)crim'), maxReprSize=0, breakLines=True) >>> x.sort(key=itemgetter('ID')) >>> x [, , , ] A brief intro to Frames (excerpted from "FrameNet II: Extended Theory and Practice" by Ruppenhofer et. al., 2010): A Frame is a script-like conceptual structure that describes a particular type of situation, object, or event along with the participants and props that are needed for that Frame. For example, the "Apply_heat" frame describes a common situation involving a Cook, some Food, and a Heating_Instrument, and is evoked by words such as bake, blanch, boil, broil, brown, simmer, steam, etc. We call the roles of a Frame "frame elements" (FEs) and the frame-evoking words are called "lexical units" (LUs). FrameNet includes relations between Frames. Several types of relations are defined, of which the most important are: - Inheritance: An IS-A relation. The child frame is a subtype of the parent frame, and each FE in the parent is bound to a corresponding FE in the child. An example is the "Revenge" frame which inherits from the "Rewards_and_punishments" frame. - Using: The child frame presupposes the parent frame as background, e.g the "Speed" frame "uses" (or presupposes) the "Motion" frame; however, not all parent FEs need to be bound to child FEs. - Subframe: The child frame is a subevent of a complex event represented by the parent, e.g. the "Criminal_process" frame has subframes of "Arrest", "Arraignment", "Trial", and "Sentencing". - Perspective_on: The child frame provides a particular perspective on an un-perspectivized parent frame. A pair of examples consists of the "Hiring" and "Get_a_job" frames, which perspectivize the "Employment_start" frame from the Employer's and the Employee's point of view, respectively. :param name: A regular expression pattern used to match against Frame names. If 'name' is None, then a list of all Framenet Frames will be returned. :type name: str :return: A list of matching Frames (or all Frames). :rtype: list(AttrDict) c3FK|]\}}j|ywr r[)rErfinfor/s rrGz.FramenetCorpusReader.frames..s"2XJC 32X!) rrrIr~rrframe_ids_and_namesrrr[)r/rBfIDss` rrzFramenetCorpusReader.framessz 0,,./D  262J2J42P2V2V2X !T2 2 0  ! ! #,,./D 0s#A//>> from nltk.corpus import framenet as fn >>> fn.fes('Noise_maker') [] >>> sorted([(fe.frame.name,fe.name) for fe in fn.fes('sound')]) # doctest: +NORMALIZE_WHITESPACE [('Cause_to_make_noise', 'Sound_maker'), ('Make_noise', 'Sound'), ('Make_noise', 'Sound_source'), ('Sound_movement', 'Location_of_sound_source'), ('Sound_movement', 'Sound'), ('Sound_movement', 'Sound_source'), ('Sounds', 'Component_sound'), ('Sounds', 'Location_of_sound_source'), ('Sounds', 'Sound_source'), ('Vocalizations', 'Location_of_sound_source'), ('Vocalizations', 'Sound_source')] >>> sorted([(fe.frame.name,fe.name) for fe in fn.fes('sound',r'(?i)make_noise')]) # doctest: +NORMALIZE_WHITESPACE [('Cause_to_make_noise', 'Sound_maker'), ('Make_noise', 'Sound'), ('Make_noise', 'Sound_source')] >>> sorted(set(fe.name for fe in fn.fes('^sound'))) ['Sound', 'Sound_maker', 'Sound_source'] >>> len(fn.fes('^sound$')) 2 :param name: A regular expression pattern used to match against frame element names. If 'name' is None, then a list of all frame elements will be returned. :type name: str :return: A list of matching frame elements :rtype: list(AttrDict) c3K|]O}|jjD]0\}}%tj|tjr|2Qywr )rrrrI)rErrrrBs rrGz+FramenetCorpusReader.fes..3sL ddjjl |ryyvrtt< * sAA)r.rFr[r/rr)r/rBr[rs ` rrzFramenetCorpusReader.fesskF  %%**U+,E3'U+[[]F    r5c8 jsj|tfdj|j D}|ot |t r|h nGt |tr*j|Dchc]}|jc} n |jh t fd|D}|S|nt |t rj|g}n%t |trj|}n|g}tttd|D}|Sjj Dcgc]\}}|jjvr|!}}}t!j"|}|Scc}wcc}}w)a Obtain details for lexical units. Optionally restrict by lexical unit name pattern, and/or to a certain frame or frames whose name matches a pattern. >>> from nltk.corpus import framenet as fn >>> len(fn.lus()) in (11829, 13572) # FN 1.5 and 1.7, resp. True >>> PrettyList(sorted(fn.lus(r'(?i)a little'), key=itemgetter('ID')), maxReprSize=0, breakLines=True) [, , ] >>> PrettyList(sorted(fn.lus(r'interest', r'(?i)stimulus'), key=itemgetter('ID'))) [, ] A brief intro to Lexical Units (excerpted from "FrameNet II: Extended Theory and Practice" by Ruppenhofer et. al., 2010): A lexical unit (LU) is a pairing of a word with a meaning. For example, the "Apply_heat" Frame describes a common situation involving a Cook, some Food, and a Heating Instrument, and is _evoked_ by words such as bake, blanch, boil, broil, brown, simmer, steam, etc. These frame-evoking words are the LUs in the Apply_heat frame. Each sense of a polysemous word is a different LU. We have used the word "word" in talking about LUs. The reality is actually rather complex. When we say that the word "bake" is polysemous, we mean that the lemma "bake.v" (which has the word-forms "bake", "bakes", "baked", and "baking") is linked to three different frames: - Apply_heat: "Michelle baked the potatoes for 45 minutes." - Cooking_creation: "Michelle baked her mother a cake for her birthday." - Absorb_heat: "The potatoes have to bake for more than 30 minutes." These constitute three different LUs, with different definitions. Multiword expressions such as "given name" and hyphenated words like "shut-eye" can also be LUs. Idiomatic phrases such as "middle of nowhere" and "give the slip (to)" are also defined as LUs in the appropriate frames ("Isolated_places" and "Evading", respectively), and their internal structure is not analyzed. Framenet provides multiple annotated examples of each sense of a word (i.e. each LU). Moreover, the set of examples (approximately 20 per LU) illustrates all of the combinatorial possibilities of the lexical unit. Each LU is linked to a Frame, and hence to the other words which evoke that Frame. This makes the FrameNet database similar to a thesaurus, grouping together semantically similar words. In the simplest case, frame-evoking words are verbs such as "fried" in: "Matilde fried the catfish in a heavy iron skillet." Sometimes event nouns may evoke a Frame. For example, "reduction" evokes "Cause_change_of_scalar_position" in: "...the reduction of debt levels to $665 million from $2.6 billion." Adjectives may also evoke a Frame. For example, "asleep" may evoke the "Sleep" frame as in: "They were asleep for hours." Many common nouns, such as artifacts like "hat" or "tower", typically serve as dependents rather than clearly evoking their own frames. :param name: A regular expression pattern used to search the LU names. Note that LU names take the form of a dotted string (e.g. "run.v" or "a little.adv") in which a lemma precedes the "." and a POS follows the dot. The lemma may be composed of a single lexeme (e.g. "run") or of multiple lexemes (e.g. "a little"). If 'name' is not given, then all LUs will be returned. The valid POSes are: v - verb n - noun a - adjective adv - adverb prep - preposition num - numbers intj - interjection art - article c - conjunction scon - subordinating conjunction :type name: str :type frame: str or int or frame :return: A list of selected (or all) lexical units :rtype: list of LU objects (dicts). See the lu() function for info about the specifics of LU objects. c3FK|]\}}j|ywr r")rEluIDrr/s rrGz+FramenetCorpusReader.lus..s" 2U,$ 2UrNc3TK|]}|jjvs|!ywr )r[rC)rEroframeIDss rrGz+FramenetCorpusReader.lus..s!#S2288;;(;RBs((c3bK|]'}t|jj)ywr )rrr)rErs rrGz+FramenetCorpusReader.lus..s#&PAtAII,<,<,>'?s-/)rrrlu_ids_and_namesrr.rFr/rrCr[riterr r_ _bad_statusesrro) r/rBr[resultrrrWroluIDsrYs ` @rluszFramenetCorpusReader.lus:sR||      262G2G2M2S2S2U F eS) %wHs+.2kk%.@A.@.@AH %zH##S#SS$ # %%**U+,E3'U++&&P&PPQF !% 2 2 4 4HD"99D$6$66 4  #477E2F + Bs F$Fc*|js|j|jjDcic]L\}}|j|jvr/| t j ||j ||jNc}}Scc}}w)z Uses the LU index, which is much faster than looking up each LU definition if only the names and IDs are needed. )rrrr_r]rrrB)r/rBrWr*s rr[z%FramenetCorpusReader.lu_ids_and_namess ||    !% 2 2 4 4 f}}D$6$664!=!I &++  4   sABc t|jj}|Stfd|DS#t$r6|j t|jj}YVwxYw)a] Return an index of the annotated documents in Framenet. Details for a specific annotated document can be obtained using this class's doc() function and pass it the value of the 'ID' field. >>> from nltk.corpus import framenet as fn >>> len(fn.docs()) in (78, 107) # FN 1.5 and 1.7, resp. True >>> set([x.corpname for x in fn.docs_metadata()])>=set(['ANC', 'KBEval', 'LUCorpus-v0.3', 'Miscellaneous', 'NTI', 'PropBank']) True :param name: A regular expression pattern used to search the file name of each annotated document. The document's file name contains the name of the corpus that the document is from, followed by two underscores "__" followed by the document name. So, for example, the file name "LUCorpus-v0.3__20000410_nyt-NEW.xml" is from the corpus named "LUCorpus-v0.3" and the document name is "20000410_nyt-NEW.xml". :type name: str :return: A list of selected (or all) annotated documents :rtype: list of dicts, where each dict object contains the following keys: - 'name' - 'ID' - 'corpid' - 'corpname' - 'description' - 'filename' c3VK|] }tj|d|"yw)rNr)rErFrBs rrGz5FramenetCorpusReader.docs_metadata..s)!aRYYtQz]%C%O6s)))rrrr~r)r/rBftlists ` r docs_metadataz"FramenetCorpusReader.docs_metadatas~D = 2 2 9 9 ;. sr5)rrer7s` rdocszFramenetCorpusReader.docs s 69K9KD9QRRr5c|r3|r!|j|jzS|jS|r|jSy)zF Annotated sentences matching the specified criteria. N)rmft_sents)r/rm full_texts rr{zFramenetCorpusReader.sents sC ~~'$--/99~~'' ==? "r5c|r"td|jD}ng}|rN(t|jj tfd|j D}ng}|r |r||zS|S|r|Sy)zH Frame annotation sets matching the specified criteria. c34K|]}|jywr )frameAnnotation)rErws rrGz3FramenetCorpusReader.annotations.. s+1N$$1NsNc3vK|]0}|jddD]}|jddvr|2yw)rNrWCXN_ASET)rr)rErwr luNamePattern matchedLUIDss rrGz3FramenetCorpusReader.annotations..$ sK,+D ..qr2D (DHHVZ,HL,X2+s69)rrmrr[rIrj)r/rqrmrkepartftpartrrs ` @r annotationsz FramenetCorpusReader.annotations s *+15 1N+EE ("4#8#8#G#L#L#NO +, MMO,FF v~% Mr5c   tdKItts9ttrcn#jjur td|tts j}t t  |q|t|trt j|D]O} j|jj |jjj|Qtjt  nYj| nGt|trj|g n|g |jj|i ttrtfd D n&j vr tdjg ttrtfd D nj!Dchc]}|jjc} 7j!Dchc]}|jj}} |z tjt  nj   fd}t|Scc}wcc}w)ab Lexicographic exemplar sentences, optionally filtered by LU name and/or 1-2 FEs that are realized overtly. 'frame' may be a name pattern, frame ID, or frame instance. 'fe' may be a name pattern or FE instance; if specified, 'fe2' may also be specified to retrieve sentences with both overt FEs (in either order). z3exemplars(..., fe=None, fe2=) is not allowedzSexemplars() call with inconsistent `fe` and `fe2` specification (frames must match)rLc3K|]@}|jvs,tfd|jjDr|Byw)c3hK|])}tj|tj+ywr rrrT)rEffers rrGz;FramenetCorpusReader.exemplars...h s#O;CryyS"$$7;/2NrrrI)rErrs rrGz1FramenetCorpusReader.exemplars..d s<4!'A:O14499;OO!'AA zAexemplars() call with inconsistent `frame` and `fe` specificationc3K|]@}|jvs,tfd|jjDr|Byw)c3hK|])}tj|tj+ywr ry)rErzfe2s rrGz;FramenetCorpusReader.exemplars...w s#"T 299S#rtt#< r{Nr|)rErrs rrGz1FramenetCorpusReader.exemplars..s s<8%+"add{""T "TT%+r}c 3KD]P}dx}}ttrN|jjDchc]*}t j |tj s)|,c}n jh}kttrN|jjDchc]*}t j |tj s)|,c}n jh}  |jn|jjD]A}|jD]0}| j||s| j||s-|2CSycc}wcc}wwr ) r.r/rrIrrrTrBrrrm_exemplar_of_fes) rrfes2rzrorCrrrrq lusByFramer/s r _matching_exsz5FramenetCorpusReader.exemplars.._matching_exs s;!!d>&b#.)* P ryyS"$$7O P ggY  *#s3-.DDIIKUKS299S#rtt;TSKU"%((%0qvv&))+, !llK4+@+@S+I LD,A,A"d,K"$H + ,!Q Vs59E%*E'E+>E%)*E E A!E%:E%E%)r$r.r/r[rrrr`rrCrBrr rrFrr) r/rqr[rrrorzframes2rrrs `` `` @@rrmzFramenetCorpusReader.exemplars5 s{ :#/ UV V ^c3'b#&!2GBXXSYY.'m =R^Jr34GHHE!     9} 5# 6 , UF"hh}EhB 288;;/"288==188<C%TZZf>F![[/FeS)"jj/0F#WF ,"'**dhh}Eh.R!SJ~b#&34!'4Fxxv-+_!hhZF?!#s+!78%+8"~26((2,?,3#)),,,??7;xx}E}syy||}GE#g-F T&\:  % %6&mo66M@Es KKc |jdr*ttt|jddn t}d|vr||jdr*ttt|jddn tz}d|vrF||j dr*ttt|j ddn tz}|||zS|S)z Given an exemplar sentence and a set of FE names, return the subset of FE names that are realized overtly in the sentence on the FE, FE2, or FE3 layer. If 'fes' is None, returns all overt FE names. rrrr)rrrziprr)r/rCr overtNamess rrz%FramenetCorpusReader._exemplar_of_fes s68UU1XSc2558n-a0135 B; 266!9#d3q ?3A67#% OJ{rvvayc$sBFF1I"7":;ceS #&?zCB Br5cDtd|j|DS)zW Full-text annotation sentences, optionally filtered by document name. c3BK|]}|jD]}|ywr )rz)rEdrws rrGz0FramenetCorpusReader.ft_sents.. s!& 3Q D D3s)rrh)r/docNamePatterns rrjzFramenetCorpusReader.ft_sents s'&& ))N3&   r5cn|js|j|jjS)a Obtain a list of frame relation types. >>> from nltk.corpus import framenet as fn >>> frts = sorted(fn.frame_relation_types(), key=itemgetter('ID')) >>> isinstance(frts, list) True >>> len(frts) in (9, 10) # FN 1.5 and 1.7, resp. True >>> PrettyDict(frts[0], breakLines=True) {'ID': 1, '_type': 'framerelationtype', 'frameRelations': [ Child=Change_of_consistency>, Child=Rotting>, ...], 'name': 'Inheritance', 'subFrameName': 'Child', 'superFrameName': 'Parent'} :return: A list of all of the frame relation types in framenet :rtype: list(dict) )rrrrBs rframe_relation_typesz)FramenetCorpusReader.frame_relation_types s.*   $ $ &  ''))r5c`|}|js|jd}|St|tsC|j Dcgc]}|j |k(s|c}d}t|tsJ|t|trd|vrt |j}nqt|ts8t|tr |j}n|j|j}|j|Dcgc]}|j|}}|H|Dcgc]}|j|us|}}n)| |j}n|jj}|| tdt|ts8t|tr |j}n|j|j}||k(r td|Dcgc]6}|jj|k(s|j j|k(r|8}}t t#|dScc}wcc}wcc}wcc}w)a :param frame: (optional) frame object, name, or ID; only relations involving this frame will be returned :param frame2: (optional; 'frame' must be a different frame) only show relations between the two specified frames, in either direction :param type: (optional) frame relation type (name or object); show only relations of this type :type frame: int or str or AttrDict :return: A list of all of the frame relations in framenet :rtype: list(dict) >>> from nltk.corpus import framenet as fn >>> frels = fn.frame_relations() >>> isinstance(frels, list) True >>> len(frels) in (1676, 2070) # FN 1.5 and 1.7, resp. True >>> PrettyList(fn.frame_relations('Cooking_creation'), maxReprSize=0, breakLines=True) [ Child=Cooking_creation>, Child=Cooking_creation>, ReferringEntry=Cooking_creation>] >>> PrettyList(fn.frame_relations(274), breakLines=True) [ Child=Dodging>, Child=Evading>, ...] >>> PrettyList(fn.frame_relations(fn.frame('Cooking_creation')), breakLines=True) [ Child=Cooking_creation>, Child=Cooking_creation>, ...] >>> PrettyList(fn.frame_relations('Cooking_creation', type='Inheritance')) [ Child=Cooking_creation>] >>> PrettyList(fn.frame_relations('Cooking_creation', 'Apply_heat'), breakLines=True) # doctest: +NORMALIZE_WHITESPACE [ Child=Cooking_creation>, ReferringEntry=Cooking_creation>] Nrrz:frame_relations(frame=None, frame2=) is not allowedzEThe two frame arguments to frame_relations() must be different framesc\|jj|j|jfSr )r=rCrr)rUs rrz6FramenetCorpusReader.frame_relations... s$)),,0C0CTEVEV!Wr5r)rrr.rrrBrrrFrCr rr=rr$rrrn) r/r[frame2r= relation_typerelsrtfrelIDrels rframe_relationsz$FramenetCorpusReader.frame_relations s#D ~~  $ $ &  $mT2%)%>%>%@T%@rBGGtO%@TUVW!$---  %&+;u+D!%"6"67!%-!%. % $ 2 25 9 < <=A=M=Me=TU=T6v.=TU'+@tsxx4/?t@  &&D>>((*D  }#Pfc*fd+#YYF!//7::F#[  C>>$$.#,,//V2K   W   [UVA,s$HH;H!H&-H&;H+c|js|jtt|jj dS)a Obtain a list of frame element relations. >>> from nltk.corpus import framenet as fn >>> ferels = fn.fe_relations() >>> isinstance(ferels, list) True >>> len(ferels) in (10020, 12393) # FN 1.5 and 1.7, resp. True >>> PrettyDict(ferels[0], breakLines=True) # doctest: +NORMALIZE_WHITESPACE {'ID': 14642, '_type': 'ferelation', 'frameRelation': Child=Lively_place>, 'subFE': , 'subFEName': 'Degree', 'subFrame': , 'subID': 11370, 'supID': 2271, 'superFE': , 'superFEName': 'Degree', 'superFrame': , 'type': } :return: A list of all of the frame element relations in framenet :rtype: list(dict) c|jj|jj|j|jj |j fSr )r=rC frameRelationrrrr)rXs rrz3FramenetCorpusReader.fe_relations..R s@JJMM''66%%''44OO #r5r)rrrrnrrBs rr;z!FramenetCorpusReader.fe_relations2 sA6  $ $ & &&(   r5cxjsjtfdjDS)a Obtain a list of semantic types. >>> from nltk.corpus import framenet as fn >>> stypes = fn.semtypes() >>> len(stypes) in (73, 109) # FN 1.5 and 1.7, resp. True >>> sorted(stypes[0].keys()) ['ID', '_type', 'abbrev', 'definition', 'definitionMarkup', 'name', 'rootType', 'subTypes', 'superType'] :return: A list of all of the semantic types in framenet :rtype: list(dict) c3^K|]$}t|tsj|&ywr )r.rFr)rErvr/s rrGz0FramenetCorpusReader.semtypes..l s' '5!As9KDNN1 ~s--)rr6rrBs`rr1zFramenetCorpusReader.semtypes\ s6~~     '+~~   r5ct||} |j}||Sgd}|D]@tfd|Dr|}|j rt ||<<||<B|S#t$r|cYSwxYw)a Extracts a subset of the attributes from the given element and returns them in a dictionary. :param d: A dictionary in which to store the attributes. :type d: dict :param elt: An ElementTree Element :type elt: Element :return: Returns the input dict ``d`` possibly including attributes from ``elt`` :rtype: dict )xsischemaLocationxmlnsbgColorfgColorc3@K|]}j|ywr )r@)rErFattrs rrGz. s:\4==#\s)r=attribr~risdigitrF)r/rr attr_dict ignore_attrsvalrs @r_load_xml_attributesz)FramenetCorpusReader._load_xml_attributesp s DGAJ  I  H D:\::D/C{{}c($$3 H s A// A=<A=c |jdd}|jdd}tjdd|}|jdd}|jdd}|jdd}|jdd}|jd d}|jd d}|jd d}|jd d }|jdd }|jdd}|jdd}|jdd}|jdd}|jdd}|jdd}|jdd}|S#t$rY|SwxYw)z Gets rid of all tags and newline characters from the given input :return: A cleaned-up version of the input string :rtype: str zr(zzzzzzzzzz'zzzzzz z rrc)rrsubr~)r/datas r _strip_tagsz FramenetCorpusReader._strip_tags sc  <<r*D<<+D66.D9D<<"-D<<,D<<"-D<<r*D<<+D<<"-D<< 2.D<<,D<<-D<<,D<<"-D<<r*D<<+D<< b1D<< r2D<<c*D     sEE E-,E-c6|jt|S)z8Extracts and returns the attributes of the given element)rr*)r/rtagspecs rrz FramenetCorpusReader._handle_elt s((S99r5c|jt|}|j}|j}g}|D]}|jj ds|jt|}d|vr |j} n |j } |d| d|_|jdz|jzdz|jz|_ ||_ ||_ |j||S)a Extracts corpus/document info from the fulltextIndex.xml file. Note that this function "flattens" the information contained in each of the "corpus" elements, so that each "document" element will contain attributes for the corpus and corpusid. Also, each of the "document" items will contain a new attribute called "filename" that is the base file name of the xml file for the document in the "fulltext" subdir of the Framenet corpus. documentrB__rre)rr*rBrCtagr@rrrrrjcorpnamecorpidr) r/rrftinforrretlistrrdocnames rrz.FramenetCorpusReader._handle_fulltextindex_elt s**8:s;;;Cww +// C@S=!hhG!ooG"*2gYd; OOc)D,>,>>Ds||S ( # s#r5cr jt| d d<d d<d d<t d<g d<t d<g d <|D] }| vs |= |D]O}|jj dr2d|vr.|j d<j |j  d<Q|jj dr-d|vr)j|}| d|j< |d<|jj d r. sGwvd|BGG4wsr_rezlu{}.xmlrCrjcfdS)Nc:jjSr )r.rkror/srrzJFramenetCorpusReader._handle_frame_elt....  b(9(C(Cr5rrs`rrz8FramenetCorpusReader._handle_frame_elt..  Cr5rkcfdS)Nc:jjSr )r.rmrsrrzJFramenetCorpusReader._handle_frame_elt.... rr5rrs`rrz8FramenetCorpusReader._handle_frame_elt.. rr5rmrrLr)rr*rurr@rur_handle_fe_eltrB_handle_fecoreset_eltrr_handle_framelexunit_eltr]rrr0r;rrrCrJrrrrr) r/rr r3rfeinfocoresetluentry semtypeinforrBrCrs ` @rrz&FramenetCorpusReader._handle_frame_elt sq**8:s;!w!|%'!"!|t !|&LyzAF{1ICww -,j2P-0XX)*'+'7'7'A|$!!$'D ,B,,S1,2t V[[)"(w!!+.;j3P44S9|$++GwGG!!),*1L77<8$(:(::#) OOll#!'' 6 7(.CWM( $(.CWM( $3:y!',,/||&&(+2 WZZ(!!),:1M"77 CH z"))$,,{~~*FGOR$(#7#7f#7#E ))""$B}}==--r}}/?/?b & $ }}''2---}}==--r}}/?/?b & $ }}''2---% r5c|jt|}g}|D]+}|j|jt|-|S)zLoad fe coreset info from xml.)rr*r)r/rrtmprs rrz*FramenetCorpusReader._handle_fecoreset_elt3 sG((S9C JJt00SA B r5c$|jt|}d|d<t|d<|D]^}|jj ds|j |}||d<|j D]}||d< |dj|`|S)SLoad frame-relation element and its child fe-relation elements from frRelation.xml.rKrrrr=)rr*rrr@_handle_framerelation_eltrr)r/rr0rrrUrXs rrz2FramenetCorpusReader._handle_framerelationtype_elt< s((S9+W !+ Cww055c:#V !--E$(E&M.%&--d3  r5c*|jt|}|d|dk7s J||fd|d<t|d<|D]M}|jj ds|j |}d|d<||d<|dj |O|S) rrrrLrr FERelationrMr)rr*rrr@rr)r/rrrrXs rrz.FramenetCorpusReader._handle_framerelation_eltL s((S9$%n)==JT{J='W (l]Cww -((-!-g)-o&]#**51  r5ct}d|d<g|d<|D]f}|jjdr|jjds;|j|}||_|dj |h|S)zLoad full annotation info for a document from its xml file. The main element (fullTextAnnotation) contains a 'header' element (which we ignore here) and a bunch of 'sentence' elements.rErrzheader)r*rr@_handle_fulltext_sentence_eltrr)r/rrrrs rrz3FramenetCorpusReader._handle_fulltextannotation_elt\ s z-W ZCww)!!*-66s;Z ''*  r5c |jt|}d|d<g|d<g|d<t}tjt ||d<d|d<|D]Q}|j jdr|j|j|d<>|j jdsZ|j|t|ddk( }d |vr||_ |j|_ |dj|d |vs|jD]\}||vrE|jd j!|jt#||d |d|jL|j%|^|dj|j|j&|j(fT|ddj*dk(sJ|ddj,|d<|ddj.|d<|S)zLoad information from the given 'sentence' element. Each 'sentence' element contains a "text" and "annotationSet" sub elements.rrrtargetsrr(ruris_poscxnIDrzDuplicate target span "{}"z in sentencerCrr]r)rr*rtypes MethodTyperrr@rru!_handle_fulltextannotationset_eltrrwrrrr0slicerrr(r_r]r)r/rr target_spansrrtspans rrz2FramenetCorpusReader._handle_fulltext_sentence_elto s((S9+W "_Yu )) t XV Cww'#//9V !!/2::T/%:!;q!@;a<_%,,Q/q=!" L0 JJ < C C$(IIeUm$<!"!& - $T $ ),,U3"*O**AHHahh +LM9<O$Q'..'999?+A.22U !/215@@\ r5c|j||}|sbd|d<d|vrY|j|j|j|j|j |d<|j j|d<|S)zxLoad information from the given 'annotationSet' element. Each 'annotationSet' contains several "layer" elements.rrHrr)rr&r(rr[)_handle_luannotationset_eltrorWrr&r(rr[)r/rrrs rrz6FramenetCorpusReader._handle_fulltextannotationset_elt sx//F/C4DMd"!WWII;; LL"nn %T !% W  r5c|jt|}d|d<g|d<|D]L}|jjds|jt|}|dj |N|S)zhLoad information from the given 'layer' element. Each 'layer' contains several "label" elements.layerrlabelrr*rr@r)r/rrrr s r_handle_fulltextlayer_eltz.FramenetCorpusReader._handle_fulltextlayer_elt ss((S9W W Cww(--hj#>W $$Q'  r5ct}d|d<|j||}d|d<d|d<t|d<t|d<t|d<|D]h}|jj dr.|j |d<|j|j |d<M|jj dr|jt||d<|jj d rd|jt|}t|jtst|j|_ |dj||jj d s"|jt|}|dj|j|jk|djd |S) zELoad the lexical unit info from an xml element in a frame's xml file.rorr(r9r sentenceCountrbrglexemerc|jSr )order)rFs rrz?FramenetCorpusReader._handle_framelexunit_elt.. sQWWr5r)r*rrurrr@rurr.rBr/rrJrCsort)r/rr*r lexemeinfors rrz-FramenetCorpusReader._handle_framelexunit_elt sw**637!|%'!"",,&Ly'\zCww --0XX)*'+'7'7'A|$!!/2*.*C*CJLRU*V'!!(+!66z|SI !*//37'**//&:JOy!((4!!),"77 cJ z"))$,,{~~*FG& y#45 r5c|jt|}d|d<d|d<d|d<t|d<t|d<t|d<|D] }||vs||= |D]}|jj d r |jj d r<|jj dr2d|vr.|j |d<|j |j |d<|jj dr-d|vr)|j|}||dj||jj d r2d |vr.|dj|jt||jj d s;d |vsA|jt|}|dj|j|j|S) z Load full info for a lexical unit from its xml file. This should only be called when accessing corpus annotations (which are not included in frame files). rorr(r9rrkrbrgrvalencesrr) rr*rrr@rur_handle_lusubcorpus_eltrrurJrC)r/rr r*r3rscrs rr,z(FramenetCorpusReader._handle_lexunit_elt s **8:s;w!|%'!"(l{&Ly'\zAF{1ICww)!!*-!!,/L 4R-0XX)*'+'7'7'A|$!!+.;j3P11#6>;'..r2!!(+ 0Jy!(()B)B:.w s"RE=1a7h#6Esz,Annotation set {} has multiple Target layersrrr)rr)BNCPENNr]r)rrz+Unexpected layer in sentence annotationset:) rrrrrrrrrz(Unexpected layer in frame annotationset:z$Missing target in annotation set ID=rr)rr*rrrrr@_handle_lulayer_eltrrrendrBrCritypernr0allrankr/)r/rrrrr rrrthespanrvrrr3s rrz0FramenetCorpusReader._handle_luannotationset_eltF s((S9.4*:KW W )) t X d?KCww(,,S1=EBM((+ ww"c>'*yy#''A+sxx&HG vv. (/e'; Wdggqvvw=W W';!LL1"xx2~ $ $B$'HH$&sxxL$'II !"03yy388 % '&#5MEvv)$ JJ U \ \$(GG!" %""RE"RRRR#t+ JJ N U U$(GG!" GL-Le!Qq!fe-LDN466Q;#'t#33#3*/DJ$%#3!#3;QVV;#3 $s166{ 2A#$D=0=',bkDG</ vv{*{',QVV ?2 vv{*{&+U -.VV\*! vv^; $ $Q$%FF!" !vv . !% $NPQPVPV!"(-QVV mn'-t# A$''KL4< <}}$} c.MsN# c|jt|}d|d<g|d<|D]O}|jjds|jt|}|<|dj |Q|S)z#Load a layer from an annotation setlulayerrrr)r/rrrr s rrz(FramenetCorpusReader._handle_lulayer_elt sv))(*c:"ggCww(--hj#>='N))!,   r5c|jt|}d|d<d|d<d|d<d|d<d|d<d|d<|D]}|jjdr.|j|d<|j |j|d<M|jjdr9|jt|}|j |j|d<|jjdr|jt||d<|jjds|jt||d<|S) Nrrr(r9rrrr)rr*rr@rurrJrC)r/rrrstinfos rrz#FramenetCorpusReader._handle_fe_elt s0**8:s;w!|%'!" y#|#|Cww --0XX)*'+'7'7'A|$!!),228:sC$(LL$;y!!!,/'+'@'@S'Q|$!!,/'+'@'@S'Q|$ r5c(|jt|}d|d<d|d<t|d<|D][}|j.|j|d<|j |j|d<=|jt|}||d<]|S)NrJrrKrLrr9)rr*rrur)r/rrsemtr supertypeinfos rr0z(FramenetCorpusReader._handle_semtype_elt s((S9!W  [%<ZCxx#+.88'(%)%5%5chh%?\" $ 9 9(*c J $1[!  r5r )NN)TT)NTT)NNNN)NNNF)?r%r&r'r(r]rrr-rrrrrrrrrr r[r r$ror.r6rDrJr<rrOrr`r[rerhr{rurmrrjrrr;r1rrrrrrrrrrrrrr,rrrrrr0rr5rrr1s KMI$6Rh - 5 #:L& #AF.0*GX24BH13L\ 6GB&(ddgR') D!$H6r@ H3T  2 hIV  -^S #@m7^ C *2] ~( T (*X)V:B13EN  &/b"  D#J$,\jX ,r5rcddlm}td|jtdt |j tdt |j tdt |jttd|j d}td t |d t|Dcgc]}|j|jfc}|dj}|j|}td j|j|jt |j|jD]}td |td |jdt |jtd |jDcgc]}|c}td|jdtd |jjDcgc]}|jdk(s|j c}td|jd}|j jDcgc]}d|vr|j"dk(r|}}td |Dcgc]}|jc}td|jdt |j td|j jDcgc]}|jc}ddd|j dj}|j%|}td|jt'|td|j)Dchc]}|j*} }t't-| t-| d} |j| } td| dt'| Dcgc]}|j.c}tdt'|j1dycc}wcc}wcc}wcc}wcc}wcc}wcc}wcc}w) Nr)framenetzBuilding the indexes...zNumber of Frames:zNumber of Lexical Units:zNumber of annotated documents:zMgetting frames whose name matches the (case insensitive) regex: "(?i)medical"z (?i)medicalzFound z) Frames whose name matches "(?i)medical":z3 Number of frame relations for the "{}" ({}) frame:z z" Number of Frame Elements in the "z" frame:z# The "core" Frame Elements in the "rz= All Lexical Units that are incorporated in the "Ailment" FE:r\Ailmentz! Number of Lexical Units in the "r+rz...z ailment.nz Information on the LU: z: Names of all of the corpora used for fulltext annotation:z* Names of the annotated documents in the "z " corpus:zO Searching for all Frames that have a lemma that matches the regexp: "^run.v$":z^run.v$) nltk.corpusrrrrrr`rhrBrCr[r0rrrrrr\r$rrerrrr ) fn medframesrtmp_idm_framefrrF ailment_lusr* allcorpora firstcorpfirstcorp_docss rdemor s* #$OO  s299;/0 $c"&&(m4 *C N; G  W .)I F3y>""K LM 9 -9aAFFADD>9 -. q\__FhhvG  >EE LL'**  G " "#  $$ eR%  -gll^8D GJJ %WZZ(Z!Z()  0h GH %'**"3"3"5N"5Qv9M!&&"5NO  JKhhsmG''))A q Q%5%5%B )  %+.+Q!&&+./  ,W\\N(C GOO $!7!7!9:!9A!9:2A>F __[ ) , ,F [[ F %fkk] 34 6N  GH&(&6&6&89&8!**&8J9 4  Z #IWWY'N 7 {) LM  /1AJJ /0 Z 2  j )*y .6) O /;: 0s6P9 P$ P) P) &P.P3 7P8 ?P=Q__main__)r))r(r)r)8r(rrrrrr collectionsrrroperatorrrnltk.corpus.readerrr nltk.utilr r r __docformat__r!r&r4rOrSrVrYrrrxr|rrrrrrrrr" Exceptionr$rr*rrZr;rurrrrrrr%rr5rr%sF  0!=BB , , F   1h$,,,^bJ+$aH4BJ(VAH:I:ataH$:('('VOO0PP@*G*4*-*4D/DDr"?r"pEw+t zFr5