Ë
    çÍ:ja5  ã                   ó  — d Z ddlZddl­ ddlmZmZmZmZmZmZm	Z	m
Z
mZ ddlmZmZ ddl­ ddlmZ ddlmZmZmZ ddl­ ddlmZ  G d	„ d
e«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z ee«       ee«      gZ ee	«       ee«       ee«      gZ ee
«       ee«      gZ  e«        e«       gZ!eez   e z   e!z   Z" G d„ de«      Z# G d„ de«      Z$d„ Z%d„ Z&d„ Z' ed«      Z(d„ Z)e*dk(  r e)«        yy)aB  
The lexicon is constructed by calling
``lexicon.fromstring(<lexicon string>)``.

In order to construct a parser, you also need a rule set.
The standard English rules are provided in chart as
``chart.DefaultRuleSet``.

The parser can then be constructed by calling, for example:
``parser = chart.CCGChartParser(<lexicon>, <ruleset>)``

Parsing is then performed by running
``parser.parse(<sentence>.split())``.

While this returns a list of trees, the default representation
of the produced trees is not very enlightening, particularly
given that it uses the same tree class as the CFG parsers.
It is probably better to call:
``chart.printCCGDerivation(<parse tree extracted from list>)``
which should print a nice representation of the derivation.

This entire process is shown far more clearly in the demonstration:
python chart.py
é    N)Ú*)	ÚBackwardApplicationÚ
BackwardBxÚBackwardCompositionÚ
BackwardSxÚ	BackwardTÚForwardApplicationÚForwardCompositionÚForwardSubstitutionÚForwardT)ÚTokenÚ
fromstring)ÚParserI)ÚAbstractChartRuleÚChartÚEdgeI)ÚTreec                   óZ   — e Zd Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zy)ÚCCGEdgec                 óB   — || _         || _        || _        |||f| _        y ©N)Ú_spanÚ_categÚ_ruleÚ_comparison_key)ÚselfÚspanÚcategÚrules       úc/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/nltk/ccg/chart.pyÚ__init__zCCGEdge.__init__;   s&   € ØˆŒ
ØˆŒØˆŒ
Ø $ e¨TÐ2ˆÕó    c                 ó   — | j                   S r   ©r   ©r   s    r    ÚlhszCCGEdge.lhsB   ó   € Ø�{‰{Ðr"   c                 ó   — | j                   S r   ©r   r%   s    r    r   zCCGEdge.spanE   ó   € Ø�z‰zÐr"   c                 ó    — | j                   d   S ©Nr   r)   r%   s    r    ÚstartzCCGEdge.startH   ó   € Ø�z‰z˜!‰}Ðr"   c                 ó    — | j                   d   S ©Né   r)   r%   s    r    ÚendzCCGEdge.endK   r.   r"   c                 ó@   — | j                   d   | j                  d   z
  S )Nr1   r   )r   r   r%   s    r    ÚlengthzCCGEdge.lengthN   s   € Ø�z‰z˜!‰}˜tŸy™y¨™|Ñ+Ð+r"   c                  ó   — y)N© r6   r%   s    r    ÚrhszCCGEdge.rhsQ   s   € Ør"   c                  ó   — yr,   r6   r%   s    r    ÚdotzCCGEdge.dotT   ó   € Ør"   c                  ó   — y©NTr6   r%   s    r    Úis_completezCCGEdge.is_completeW   ó   € Ør"   c                  ó   — y©NFr6   r%   s    r    Úis_incompletezCCGEdge.is_incompleteZ   ó   € Ør"   c                  ó   — y r   r6   r%   s    r    ÚnextsymzCCGEdge.nextsym]   r>   r"   c                 ó   — | j                   S r   r$   r%   s    r    r   zCCGEdge.categ`   r'   r"   c                 ó   — | j                   S r   )r   r%   s    r    r   zCCGEdge.rulec   r*   r"   N)Ú__name__Ú
__module__Ú__qualname__r!   r&   r   r-   r2   r4   r7   r9   r=   rA   rD   r   r   r6   r"   r    r   r   :   sC   „ ò3òòòòò,òòòòòòór"   r   c                   ód   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚCCGLeafEdgez<
    Class representing leaf edges in a CCG derivation.
    c                 ó^   — || _         || _        || _        ||j                  «       |f| _        y r   )Ú_posÚ_tokenÚ_leafr   r   )r   ÚposÚtokenÚleafs       r    r!   zCCGLeafEdge.__init__l   s,   € ØˆŒ	ØˆŒØˆŒ
Ø # U§[¡[£]°DÐ9ˆÕr"   c                 ó6   — | j                   j                  «       S r   ©rN   r   r%   s    r    r&   zCCGLeafEdge.lhss   ó   € Ø�{‰{× Ñ Ó"Ð"r"   c                 ó8   — | j                   | j                   dz   fS r0   ©rM   r%   s    r    r   zCCGLeafEdge.spanv   s   € Ø—	‘	˜4Ÿ9™9 q™=Ð)Ð)r"   c                 ó   — | j                   S r   rW   r%   s    r    r-   zCCGLeafEdge.starty   s   € Ø�y‰yÐr"   c                 ó    — | j                   dz   S r0   rW   r%   s    r    r2   zCCGLeafEdge.end|   s   € Ø�y‰y˜1‰}Ðr"   c                  ó   — yr0   r6   r%   s    r    r4   zCCGLeafEdge.length   r:   r"   c                 ó   — | j                   S r   ©rO   r%   s    r    r7   zCCGLeafEdge.rhs‚   r*   r"   c                  ó   — yr,   r6   r%   s    r    r9   zCCGLeafEdge.dot…   r:   r"   c                  ó   — yr<   r6   r%   s    r    r=   zCCGLeafEdge.is_completeˆ   r>   r"   c                  ó   — yr@   r6   r%   s    r    rA   zCCGLeafEdge.is_incomplete‹   rB   r"   c                  ó   — y r   r6   r%   s    r    rD   zCCGLeafEdge.nextsymŽ   r>   r"   c                 ó   — | j                   S r   )rN   r%   s    r    rQ   zCCGLeafEdge.token‘   r'   r"   c                 ó6   — | j                   j                  «       S r   rT   r%   s    r    r   zCCGLeafEdge.categ”   rU   r"   c                 ó   — | j                   S r   r\   r%   s    r    rR   zCCGLeafEdge.leaf—   r*   r"   N)rG   rH   rI   Ú__doc__r!   r&   r   r-   r2   r4   r7   r9   r=   rA   rD   rQ   r   rR   r6   r"   r    rK   rK   g   sM   „ ñò:ò#ò*òòòòòòòòòò#ór"   rK   c                   ó&   — e Zd ZdZdZd„ Zd„ Zd„ Zy)ÚBinaryCombinatorRulezw
    Class implementing application of a binary combinator to a chart.
    Takes the directed combinator to apply.
    é   c                 ó   — || _         y r   ©Ú_combinator)r   Ú
combinators     r    r!   zBinaryCombinatorRule.__init__£   s
   € Ø%ˆÕr"   c              #   óÚ  K  — |j                  «       |j                  «       k(  sy | j                  j                  |j	                  «       |j	                  «       «      r�| j                  j                  |j	                  «       |j	                  «       «      D ]Q  }t        |j                  «       |j                  «       f|| j                  ¬«      }|j                  |||f«      sŒN|–— ŒS y y ­w©N)r   r   r   )r2   r-   rj   Úcan_combiner   Úcombiner   Úinsert©r   ÚchartÚgrammarÚ	left_edgeÚ
right_edgeÚresÚnew_edges          r    ÚapplyzBinaryCombinatorRule.apply§   sÆ   è ø€ à—‘“ :×#3Ñ#3Ó#5Ò5Øð ×Ñ×'Ñ'¨	¯©Ó(9¸:×;KÑ;KÓ;MÔNØ×'Ñ'×/Ñ/°	·±Ó0AÀ:×CSÑCSÓCUÓVò #�Ü"Ø#Ÿ/™/Ó+¨Z¯^©^Ó-=Ð>ØØ×)Ñ)ô�ð
 —<‘< ¨9°jÐ*AÕBØ"“Nñ#ð Oùs   ‚C C+Ã#C+c                 ó    — d| j                   z  S ©Nú%sri   r%   s    r    Ú__str__zBinaryCombinatorRule.__str__¹   ó   € Ø�d×&Ñ&Ñ&Ð&r"   N©rG   rH   rI   rd   ÚNUMEDGESr!   rx   r|   r6   r"   r    rf   rf   ›   s   „ ñð
 €Hò&ò#ó$'r"   rf   c                   ó&   — e Zd ZdZdZd„ Zd„ Zd„ Zy)ÚForwardTypeRaiseRulez1
    Class for applying forward type raising
    rg   c                 ó   — t         | _        y r   )r   rj   r%   s    r    r!   zForwardTypeRaiseRule.__init__È   s
   € Ü#ˆÕr"   c              #   óF  K  — |j                  «       |j                  «       k(  sy | j                  j                  |j	                  «       |j	                  «       «      D ]@  }t        |j                  «       || j                  ¬«      }|j                  ||f«      sŒ=|–— ŒB y ­wrm   ©r2   r-   rj   ro   r   r   r   rp   rq   s          r    rx   zForwardTypeRaiseRule.applyË   s‚   è ø€ Ø—‘“ :×#3Ñ#3Ó#5Ò5Øà×#Ñ#×+Ñ+¨I¯O©OÓ,=¸z×?OÑ?OÓ?QÓRò 	ˆCÜ I§N¡NÓ$4¸CÀd×FVÑFVÔWˆHØ�|‰|˜H y lÕ3Ø“ñ	ùó   ‚BB!ÂB!c                 ó    — d| j                   z  S rz   ri   r%   s    r    r|   zForwardTypeRaiseRule.__str__Ô   r}   r"   Nr~   r6   r"   r    r�   r�   Á   s   „ ñð €Hò$òó'r"   r�   c                   ó&   — e Zd ZdZdZd„ Zd„ Zd„ Zy)ÚBackwardTypeRaiseRulez3
    Class for applying backward type raising.
    rg   c                 ó   — t         | _        y r   )r   rj   r%   s    r    r!   zBackwardTypeRaiseRule.__init__ß   s
   € Ü$ˆÕr"   c              #   óF  K  — |j                  «       |j                  «       k(  sy | j                  j                  |j	                  «       |j	                  «       «      D ]@  }t        |j                  «       || j                  ¬«      }|j                  ||f«      sŒ=|–— ŒB y ­wrm   r„   rq   s          r    rx   zBackwardTypeRaiseRule.applyâ   s‚   è ø€ Ø—‘“ :×#3Ñ#3Ó#5Ò5Øà×#Ñ#×+Ñ+¨I¯O©OÓ,=¸z×?OÑ?OÓ?QÓRò 	ˆCÜ J§O¡OÓ$5¸SÀt×GWÑGWÔXˆHØ�|‰|˜H z mÕ4Ø“ñ	ùr…   c                 ó    — d| j                   z  S rz   ri   r%   s    r    r|   zBackwardTypeRaiseRule.__str__ë   r}   r"   Nr~   r6   r"   r    rˆ   rˆ   Ø   s   „ ñð €Hò%òó'r"   rˆ   c                   ó$   — e Zd ZdZdd„Zd„ Zd„ Zy)ÚCCGChartParserzV
    Chart parser for CCGs.
    Based largely on the ChartParser class from NLTK.
    c                 ó.   — || _         || _        || _        y r   )Ú_lexiconÚ_rulesÚ_trace)r   ÚlexiconÚrulesÚtraces       r    r!   zCCGChartParser.__init__  s   € ØˆŒØˆŒØˆ�r"   c                 ó   — | j                   S r   )r�   r%   s    r    r’   zCCGChartParser.lexicon  s   € Ø�}‰}Ðr"   c                 ó  — t        |«      }t        t        |«      «      }| j                  }t        |j	                  «       «      D ]U  }|j                  |j                  |«      «      D ]0  }t        |||j                  |«      «      }|j                  |d«       Œ2 ŒW t        d|j	                  «       dz   «      D ]§  }t        d|j	                  «       |z
  dz   «      D ]‚  }t        d|«      D ]q  }	|}
||	z   }||z   }|j                  |
|f¬«      D ]L  }|j                  ||f¬«      D ]3  }| j                  D ]"  }d}|j                  ||||«      D ]  }|dz  }Œ	 Œ$ Œ5 ŒN Œs Œ„ Œ© |j                  |j                  «       «      S )Nr6   rg   r1   r   )r   )ÚlistÚCCGChartr�   ÚrangeÚ
num_leavesÚ
categoriesrR   rK   rp   Úselectr�   rx   Úparsesr-   )r   Útokensrr   ÚlexÚindexrQ   rw   r   r-   ÚpartÚlstartÚmidÚrendÚleftÚrightr   Úedges_added_by_ruleÚnewedges                     r    ÚparsezCCGChartParser.parse  s™  € Ü�f“ˆÜœ˜f›Ó&ˆØ�m‰mˆô ˜5×+Ñ+Ó-Ó.ò 	+ˆEØŸ™¨¯
©
°5Ó(9Ó:ò +�Ü& u¨e°U·Z±ZÀÓ5FÓG�Ø—‘˜X rÕ*ñ+ð	+ô ˜!˜U×-Ñ-Ó/°!Ñ3Ó4ò 	=ˆDÜ˜q %×"2Ñ"2Ó"4°tÑ";¸aÑ"?Ó@ò =�ô " ! T›Nò =�DØ"�FØ $™,�CØ  4™<�Dà %§¡°6¸3°- Ó @ò =˜Ø%*§\¡\¸¸T°{ \Ó%Cò =˜Eà(,¯©ò = Ø67Ð 3Ø/3¯z©z¸%ÀÀdÈEÓ/Rò != GØ$7¸1Ñ$<Ñ$7ñ!=ñ=ñ=ñ=ñ=ñ=ð	=ð$ �|‰|˜CŸI™I›KÓ(Ð(r"   N)r   )rG   rH   rI   rd   r!   r’   r©   r6   r"   r    r�   r�     s   „ ñó
ò
ó)r"   r�   c                   ó   — e Zd Zd„ Zd„ Zy)r˜   c                 ó0   — t        j                  | |«       y r   )r   r!   )r   rž   s     r    r!   zCCGChart.__init__6  s   € Ü�‰�t˜VÕ$r"   c           
      ó²  — |sJ d«       ‚||v r||   S t        |t        «      rV ||j                  «       | j                  |j	                  «          g«      } ||j                  «       df|g«      }|g||<   |gS g ||<   g }| j                  |«      D ]¹  }|D �	cg c]  }	| j                  |	|||«      ‘Œ }
}	t        j                  |
Ž D ]�  }t        | j                  |j	                  «       |j                  «        |j                  «       t        ||«      «      t        |j                  «       «      f}|j                   |||«      «       Œƒ Œ» |||<   |S c c}	w )Nz&CCGChart cannot build incomplete treesÚLeaf)Ú
isinstancerK   rQ   Ú_tokensr-   Úchild_pointer_listsÚ_treesÚ	itertoolsÚproductr   r2   r&   Úcompute_semanticsÚstrr   Úappend)r   ÚedgeÚcompleteÚmemoÚ
tree_classÚwordrR   ÚtreesÚcplÚcpÚchild_choicesÚchildrenr&   s                r    r±   zCCGChart._trees<  sU  € ÙÐAÐAÓAˆxà�4‰<Ø˜‘:Ðä�dœKÔ(Ù˜dŸj™j›l¨T¯\©\¸$¿*¹*»,Ñ-GÐ,HÓIˆDÙ˜tŸz™z›|¨VÐ4°t°fÓ=ˆDØ˜ˆD�‰JØ�6ˆMàˆˆT‰
Øˆà×+Ñ+¨DÓ1ò 	8ˆCØSVÖWÈR˜TŸ[™[¨¨X°t¸ZÕHÐWˆMÐWÜ%×-Ñ-¨}Ð=ò 	8�äØŸ™ T§Z¡Z£\°D·H±H³JÐ?ØŸ™›
Ü)¨(°DÓ9óô
 ˜Ÿ	™	›Ó$ð�ð —‘™Z¨¨XÓ6Õ7ñ	8ð	8ð ˆˆT‰
Øˆùò Xs   ÂEN)rG   rH   rI   r!   r±   r6   r"   r    r˜   r˜   5  s   „ ò%ór"   r˜   c                 ó   — | d   j                  «       d   j                  «       €y t        | «      dk(  rït        |j	                  «       t
        «      r
| d   | d   g} |j	                  «       j                  }| d   j                  «       d   j                  «       }| d   j                  «       d   j                  «       }t        |t        «      rt        ||«      S t        |t        «      rt        ||«      S t        |t        «      rt        ||«      S t        d|z   dz   «      ‚t        | d   j                  «       d   j                  «       «      S )Nr   rg   r1   zUnsupported combinator 'ú')ÚlabelÚ	semanticsÚlenr®   r   ÚBackwardCombinatorrj   ÚUndirectedFunctionApplicationÚcompute_function_semanticsÚUndirectedCompositionÚcompute_composition_semanticsÚUndirectedSubstitutionÚcompute_substitution_semanticsÚAssertionErrorÚcompute_type_raised_semantics)rÀ   r·   rk   ÚfunctionÚarguments        r    r´   r´   \  s*  € Ø��{×ÑÓ˜1Ñ×'Ñ'Ó)Ð1Øä
ˆ8ƒ}˜ÒÜ�d—i‘i“kÔ#5Ô6Ø  ™ X¨a¡[Ð1ˆHà—Y‘Y“[×,Ñ,ˆ
Ø˜A‘;×$Ñ$Ó& qÑ)×3Ñ3Ó5ˆØ˜A‘;×$Ñ$Ó& qÑ)×3Ñ3Ó5ˆä�jÔ"?Ô@Ü-¨h¸ÓAÐAÜ˜
Ô$9Ô:Ü0°¸8ÓDÐDÜ˜
Ô$:Ô;Ü1°(¸HÓEÐEä Ð!;¸jÑ!HÈ3Ñ!NÓOÐOä,¨X°a©[×->Ñ->Ó-@ÀÑ-C×-MÑ-MÓ-OÓPÐPr"   c                 óà  — | j                  «       }d}d}|D ]—  \  }}d|z  }dt        t        |«      t        |«      «      z   }|t        |«      z
  dz  }||t        |«      z
  dz  z   }	|d|z  |z   d|	z  z   z  }|t        |«      z
  dz  }
|
|t        |«      z
  dz  z   }|d|
z  |z   d|z  z   z  }Œ™ t        |j	                  «       «       t        |j	                  «       «       t        d| «       y )NÚ r{   rg   ú r   )rP   ÚmaxrÅ   ÚprintÚrstripÚprintCCGTree)ÚtreeÚleafcatsÚleafstrÚcatstrrR   ÚcatÚstr_catÚnextlenÚlcatlenÚrcatlenÚlleaflenÚrleaflens               r    ÚprintCCGDerivationrã   w  s  € à�x‰x‹z€HØ€GØ€Fð ò :‰	ˆˆcØ˜‘*ˆØ”cœ#˜d›)¤S¨£\Ó2Ñ2ˆØœS ›\Ñ)¨aÑ/ˆØ˜W¤s¨7£|Ñ3°qÑ8Ñ8ˆØ�#˜‘- 'Ñ)¨C°'©MÑ9Ñ9ˆØœc $›iÑ'¨AÑ-ˆØ˜w¬¨T«Ñ2°aÑ7Ñ7ˆØ�3˜‘> DÑ(¨3°©>Ñ9Ñ9‰ð:ô 
ˆ'�.‰.Ó
ÔÜ	ˆ&�-‰-‹/Ôô ��DÕr"   c           	      óˆ  — | }t        |t        «      sd| z   t        |«      z   S |D ]  }t        |t	        ||«      «      }Œ t        |j                  «       t        «      s?t        |d| z   t        d|j                  «       z  «      z   d| z   t        |d   «      z   «      S |j                  «       \  }}|dk(  r|S t        | dz  || z
  dz  z   d|z  z   «       d|j                  «       z  }|j                  «       �"|dt        |j                  «       «      z   dz   z  }|| z
  t        |«      z
  dz  | z   }t        |dz  |z   «       |S )	Nrg   r{   r   r­   rÓ   ú-z {ú})r®   r   rÅ   rÔ   r×   rÃ   ÚtuplerÕ   r   rÄ   rµ   )ÚlwidthrØ   ÚrwidthÚchildrQ   ÚopÚstr_resÚ	respadlens           r    r×   r×   �  sL  € Ø€Fô �dœDÔ!Ø�6‰zœC ›IÑ%Ð%ð ò :ˆÜ�Vœ\¨&°%Ó8Ó9‰ð:ô
 �d—j‘j“l¤EÔ*ÜØ�A˜‘J¤ T¨D¯J©J«LÑ%8Ó!9Ñ9¸1¸v¹:ÌÈDÐQRÉGËÑ;Tó
ð 	
ð —*‘*“,�K€UˆBà	ˆV‚|Øˆô 
ˆ&�3‰,˜& 6™/¨SÑ0Ñ
0°4¸"±9Ñ
<Ô=à�e—k‘k“mÑ$€GØ‡�ÓÐ$Ø�4œ#˜eŸo™oÓ/Ó0Ñ0°3Ñ6Ñ6ˆØ˜&‘¤3 w£<Ñ/°AÑ5¸Ñ>€IÜ	ˆ)�c‰/˜GÑ
#Ô$Ø€Mr"   ar  
    :- S, NP, N, VP    # Primitive categories, S is the target primitive

    Det :: NP/N         # Family of words
    Pro :: NP
    TV :: VP/NP
    Modal :: (S\NP)/VP # Backslashes need to be escaped

    I => Pro             # Word -> Category mapping
    you => Pro

    the => Det

    # Variables have the special keyword 'var'
    # '.' prevents permutation
    # ',' prevents composition
    and => var\.,var/.,var

    which => (N\N)/(S/NP)

    will => Modal # Categories can be either explicit, or families.
    might => Modal

    cook => TV
    eat => TV

    mushrooms => N
    parsnips => N
    bacon => N
    c                  óŠ   — t        t        t        «      } | j                  dj	                  «       «      D ]  }t        |«       Œ y )NzI might cook and eat the bacon)r�   rŸ   ÚDefaultRuleSetr©   Úsplitrã   )Úparserr©   s     r    Údemorò   Ù  s8   € ÜœC¤Ó0€FØ—‘Ð>×DÑDÓFÓGò "ˆÜ˜5Õ!ñ"r"   Ú__main__)+rd   r²   Únltk.ccg.combinatorr   r   r   r   r   r	   r
   r   r   Únltk.ccg.lexiconr   r   Únltk.ccg.logicÚ
nltk.parser   Únltk.parse.chartr   r   r   Únltk.sem.logicÚ	nltk.treer   r   rK   rf   r�   rˆ   ÚApplicationRuleSetÚCompositionRuleSetÚSubstitutionRuleSetÚTypeRaiseRuleSetrï   r�   r˜   r´   rã   r×   rŸ   rò   rG   r6   r"   r    ú<module>rÿ      s[  ðñó2 ä !÷
÷ 
õ 
÷ /Ü Ý ß <Ñ <Ü Ý ô*ˆeô *ôZ1�%ô 1ôh'Ð,ô 'ôL'Ð,ô 'ô.'Ð-ô 'ñ2 Ð+Ó,ÙÐ,Ó-ðÐ ñ
 Ð+Ó,ÙÐ,Ó-Ù˜Ó$ðÐ ñ Ð,Ó-Ù˜Ó$ðÐ ñ )Ó*Ñ,AÓ,CÐDÐ ð Ð+Ñ+Ð.AÑAÐDTÑTð ô
-)�Wô -)ô`$ˆuô $òNQò6ò2!ñN ðó€òD"ð ˆzÒÙ…Fð r"   