o
    rZha5                     @   s  d Z ddlZddlT 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T ddlmZ ddlmZmZmZ ddlT ddlmZ G d	d
 d
eZG dd deZG dd deZG dd deZG d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 e  e! Z"G dd deZ#G dd deZ$dd Z%dd Z&dd Z'edZ(dd Z)e*d kre)  dS dS )!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                   @   st   e Zd Zdd Zdd Zdd Zdd Zd	d
 Zdd Zdd Z	dd Z
dd Zdd Zdd Zdd Zdd ZdS )CCGEdgec                 C   s"   || _ || _|| _|||f| _d S N)_span_categ_rule_comparison_key)selfspancategrule r   =/var/www/auris/lib/python3.10/site-packages/nltk/ccg/chart.py__init__;   s   zCCGEdge.__init__c                 C      | j S r   r   r   r   r   r   lhsB      zCCGEdge.lhsc                 C   r    r   r   r"   r   r   r   r   E   r$   zCCGEdge.spanc                 C   
   | j d S Nr   r%   r"   r   r   r   startH      
zCCGEdge.startc                 C   r&   N   r%   r"   r   r   r   endK   r)   zCCGEdge.endc                 C   s   | j d | jd  S )Nr+   r   )r   r   r"   r   r   r   lengthN   s   zCCGEdge.lengthc                 C      dS )Nr   r   r"   r   r   r   rhsQ      zCCGEdge.rhsc                 C   r.   r'   r   r"   r   r   r   dotT   r0   zCCGEdge.dotc                 C   r.   NTr   r"   r   r   r   is_completeW   r0   zCCGEdge.is_completec                 C   r.   NFr   r"   r   r   r   is_incompleteZ   r0   zCCGEdge.is_incompletec                 C      d S r   r   r"   r   r   r   nextsym]   r0   zCCGEdge.nextsymc                 C   r    r   r!   r"   r   r   r   r   `   r$   zCCGEdge.categc                 C   r    r   )r   r"   r   r   r   r   c   r$   zCCGEdge.ruleN)__name__
__module____qualname__r   r#   r   r(   r,   r-   r/   r1   r3   r5   r7   r   r   r   r   r   r   r   :   s    r   c                   @   s   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dd Zdd Zdd Zdd Zdd Zdd Zdd ZdS )CCGLeafEdgez<
    Class representing leaf edges in a CCG derivation.
    c                 C   s&   || _ || _|| _|| |f| _d S r   )_pos_token_leafr   r   )r   postokenleafr   r   r   r   l   s   zCCGLeafEdge.__init__c                 C   
   | j  S r   r=   r   r"   r   r   r   r#   s   r)   zCCGLeafEdge.lhsc                 C   s   | j | j d fS r*   r<   r"   r   r   r   r   v      zCCGLeafEdge.spanc                 C   r    r   rD   r"   r   r   r   r(   y   r$   zCCGLeafEdge.startc                 C   s
   | j d S r*   rD   r"   r   r   r   r,   |   r)   zCCGLeafEdge.endc                 C   r.   r*   r   r"   r   r   r   r-      r0   zCCGLeafEdge.lengthc                 C   r    r   r>   r"   r   r   r   r/      r$   zCCGLeafEdge.rhsc                 C   r.   r'   r   r"   r   r   r   r1      r0   zCCGLeafEdge.dotc                 C   r.   r2   r   r"   r   r   r   r3      r0   zCCGLeafEdge.is_completec                 C   r.   r4   r   r"   r   r   r   r5      r0   zCCGLeafEdge.is_incompletec                 C   r6   r   r   r"   r   r   r   r7      r0   zCCGLeafEdge.nextsymc                 C   r    r   )r=   r"   r   r   r   r@      r$   zCCGLeafEdge.tokenc                 C   rB   r   rC   r"   r   r   r   r      r)   zCCGLeafEdge.categc                 C   r    r   rF   r"   r   r   r   rA      r$   zCCGLeafEdge.leafN)r8   r9   r:   __doc__r   r#   r   r(   r,   r-   r/   r1   r3   r5   r7   r@   r   rA   r   r   r   r   r;   g   s     r;   c                   @   ,   e Zd ZdZdZdd Zdd Zdd Zd	S )
BinaryCombinatorRulezw
    Class implementing application of a binary combinator to a chart.
    Takes the directed combinator to apply.
       c                 C   s
   || _ d S r   _combinator)r   
combinatorr   r   r   r      r)   zBinaryCombinatorRule.__init__c                 c   s    |  | ksd S | j| | r=| j| | D ]}t| |  f|| jd}||||fr<|V  q!d S d S N)r   r   r   )r,   r(   rL   Zcan_combiner   combiner   insertr   chartZgrammarZ	left_edgeZ
right_edgeresnew_edger   r   r   apply   s   zBinaryCombinatorRule.applyc                 C   
   d| j  S N%srK   r"   r   r   r   __str__   r)   zBinaryCombinatorRule.__str__Nr8   r9   r:   rG   ZNUMEDGESr   rU   rY   r   r   r   r   rI      s    rI   c                   @   rH   )
ForwardTypeRaiseRulez1
    Class for applying forward type raising
    rJ   c                 C   
   t | _d S r   )r   rL   r"   r   r   r   r      r)   zForwardTypeRaiseRule.__init__c                 c   s^    |  | ksd S | j| | D ]}t| || jd}|||fr,|V  qd S rN   r,   r(   rL   rO   r   r   r   rP   rQ   r   r   r   rU         zForwardTypeRaiseRule.applyc                 C   rV   rW   rK   r"   r   r   r   rY      r)   zForwardTypeRaiseRule.__str__NrZ   r   r   r   r   r[          	r[   c                   @   rH   )
BackwardTypeRaiseRulez3
    Class for applying backward type raising.
    rJ   c                 C   r\   r   )r   rL   r"   r   r   r   r      r)   zBackwardTypeRaiseRule.__init__c                 c   s^    |  | ksd S | j| | D ]}t| || jd}|||fr,|V  qd S rN   r]   rQ   r   r   r   rU      r^   zBackwardTypeRaiseRule.applyc                 C   rV   rW   rK   r"   r   r   r   rY      r)   zBackwardTypeRaiseRule.__str__NrZ   r   r   r   r   r`      r_   r`   c                   @   s*   e Zd ZdZd
ddZdd Zdd Zd	S )CCGChartParserzV
    Chart parser for CCGs.
    Based largely on the ChartParser class from NLTK.
    r   c                 C   s   || _ || _|| _d S r   )_lexicon_rules_trace)r   lexiconrulestracer   r   r   r     s   
zCCGChartParser.__init__c                 C   r    r   )rb   r"   r   r   r   re     r$   zCCGChartParser.lexiconc                 C   s   t |}tt |}| j}t| D ]}|||D ]}t||||}||d qqtd| d D ]O}td| | d D ]A}td|D ]9}	|}
||	 }|| }|j	|
|fdD ]$}|j	||fdD ]}| j
D ]}d}|||||D ]}|d7 }q|qpqkqaqMqFq9|| S )Nr   rJ   r+   r   )r   )listCCGChartrb   rangeZ
num_leaves
categoriesrA   r;   rP   selectrc   rU   Zparsesr(   )r   tokensrR   lexindexr@   rT   r   r(   partZlstartmidZrendleftrightr   Zedges_added_by_ruleZnewedger   r   r   parse  s6   

zCCGChartParser.parseN)r   )r8   r9   r:   rG   r   re   rt   r   r   r   r   ra     s
    
ra   c                   @   s   e Zd Zdd Zdd ZdS )ri   c                 C   s   t | | d S r   )r   r   )r   rm   r   r   r   r   6  rE   zCCGChart.__init__c                    s    sJ d|v r| S t |tr2| j|  g}| df|g}|g|< |gS g |< g }|D ]8} fdd|D }	tj|	 D ]$}
tj| |	  |
 t|
|t| f}|||
 qPq=||< |S )Nz&CCGChart cannot build incomplete treesLeafc                    s   g | ]
} | qS r   )_trees).0cpcompletememor   
tree_classr   r   
<listcomp>L  s    z#CCGChart._trees.<locals>.<listcomp>)
isinstancer;   r@   _tokensr(   Zchild_pointer_lists	itertoolsproductr   r,   r#   compute_semanticsstrr   append)r   edgerz   r{   r|   wordrA   ZtreesZcplZchild_choiceschildrenr#   r   ry   r   rv   <  s0   


zCCGChart._treesN)r8   r9   r:   r   rv   r   r   r   r   ri   5  s    ri   c                 C   s   | d   d  d u rd S t| dkrbt| tr#| d | d g} | j}| d   d  }| d   d  }t|trFt||S t|t	rPt
||S t|trZt||S td| d t| d   d  S )Nr   rJ   r+   zUnsupported combinator '')label	semanticslenr~   r   ZBackwardCombinatorrL   ZUndirectedFunctionApplicationZcompute_function_semanticsZUndirectedCompositionZcompute_composition_semanticsZUndirectedSubstitutionZcompute_substitution_semanticsAssertionErrorZcompute_type_raised_semantics)r   r   rM   functionargumentr   r   r   r   \  s    






r   c                 C   s   |   }d}d}|D ]O\}}d| }dtt|t| }|t| d }||t| d  }	|d| | d|	  7 }|t| d }
|
|t| d  }|d|
 | d|  7 }q
t|  t|  td|  d S )N rX   rJ    r   )r?   maxr   printrstripprintCCGTree)treeZleafcatsZleafstrZcatstrrA   catZstr_catZnextlenZlcatlenZrcatlenZlleaflenZrleaflenr   r   r   printCCGDerivationw  s   r   c                 C   s
  | }t |tsd|  t| S |D ]
}t|t||}qt | ts;t|d|  td|   d|  t|d  S | \}}|dkrG|S t| d ||  d  d|   d|  }|	 d uro|dt
|	  d 7 }||  t| d |  }t|d |  |S )	NrJ   rX   r   ru   r   -z {})r~   r   r   r   r   r   tupler   r   r   r   )Zlwidthr   Zrwidthchildr@   opZstr_resZ	respadlenr   r   r   r     s&   
* r   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                  C   s*   t tt} | d D ]}t| qd S )NzI might cook and eat the bacon)ra   rn   DefaultRuleSetrt   splitr   )parserrt   r   r   r   demo  s   

r   __main__)+rG   r   Znltk.ccg.combinatorr   r   r   r   r   r   r	   r
   r   Znltk.ccg.lexiconr   r   Znltk.ccg.logicZ
nltk.parser   Znltk.parse.chartr   r   r   Znltk.sem.logicZ	nltk.treer   r   r;   rI   r[   r`   ZApplicationRuleSetZCompositionRuleSetZSubstitutionRuleSetZTypeRaiseRuleSetr   ra   ri   r   r   r   rn   r   r8   r   r   r   r   <module>   sP   ,-4&0''"
