
    ga5                        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/var/www/openai/venv/lib/python3.12/site-packages/nltk/ccg/chart.py__init__zCCGEdge.__init__;   s&    

 $eT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       zzr"   c                      | j                   d   S Nr   r)   r%   s    r    startzCCGEdge.startH       zz!}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    zz!}tyy|++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    		499q=))r"   c                     | j                   S r   rW   r%   s    r    r-   zCCGLeafEdge.starty   s    yyr"   c                      | j                   dz   S r0   rW   r%   s    r    r2   zCCGLeafEdge.end|   s    yy1}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:CSCSCUV"#//+Z^^-=>))
 <<9j*AB"N W 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##++IOO,=z?O?O?QRCINN$4CdFVFVWH||Hyl3 S   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##++IOO,=z?O?O?QRCJOO$5StGWGWXH||Hzm4 S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  sp   ff&mm 5++-.E

5(9:&ueUZZ5FGXr* ; / !U--/!34Dq%"2"2"4t";a"?@ "!TND"F$,C 4<D %63- @%*\\T{\%CE(,67 3/3zz%dE/RG$71$<$7 0S )4 &D !A + A 5$ ||CIIK((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    tV$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<  sN   AAAx4<:dK(djjlT\\$**,-G,HIDtzz|V4tf=DDJ6MT
++D1CSVWSVRT[[XtZHSVMW%--}=TZZ\DHHJ?
)(D9
 		$ ZX67 > 2 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(  rt        |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}diik#56 Xa[1HYY[,,
A;$$&q)335A;$$&q)335j"?@-hAA
$9:08DD
$:;1(HEE !;j!H3!NOO,Xa[->->-@-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   xxzHGF 	c*c#d)S\22S\)a/Ws7|3q88#-')C'M99c$i'A-wT2a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     sG   F dD!6zCI%% V\&%89 
 djjlE*AJTDJJL%8!991v:DQRG;T
 	
 **,KUB	V| 
&3,&6/S0
04"9
<=ekkm$G$4#eoo/00366&3w</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     s4    C0F>DDFG5! H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ADTT 
-)W -)`$u $NQ62!N D" zF r"   