o
    wi                     @   s|  d dl Z d dlmZ d dlmZ d dlmZmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ zd dlm Z m!Z! d dl"m#Z# d dl$m%Z% W n	 e&ye   Y nw G dd	 d	eZ'G d
d deZ(G dd dZ)G dd de)eZ*dd Z+G dd de)eZ,G dd de,eZ-G dd de,eZ.G dd de-eZ/G dd de,eZ0G dd de)eZ1G dd de)eZ2G d d! d!e)eZ3G d"d# d#e)eZ4G d$d% d%e4eZ5G d&d' d'e5eZ6G d(d) d)e4eZ7G d*d+ d+e5Z8G d,d- d-e)e
Z9d.d/ Z:G d0d1 d1e;e)eZ<G d2d3 d3e=Z>g fd4d5Z?G d6d7 d7Z@d8d9 ZAd:d; ZBeCd<kr<eA  dS dS )=    N)reduce)chain)APPAbstractVariableExpressionAllExpressionAndExpressionApplicationExpressionBinaryExpressionBooleanExpressionConstantExpressionEqualityExpressionEventVariableExpressionExistsExpression
ExpressionFunctionVariableExpressionImpExpressionIndividualVariableExpressionLambdaExpressionLogicParserNegatedExpressionOrExpressionTokensVariableis_eventvar
is_funcvar	is_indvarunique_variable)CanvasTk)Font)in_idlec                   @   sJ   e Zd ZdZdZdZdZdZdZeeeegZ	e
je	 Ze
jeg e	 ZdS )	DrtTokensDRS+PRO[]:N)__name__
__module____qualname__r"   DRS_CONCPRONOUNOPEN_BRACKETCLOSE_BRACKETCOLONPUNCTr   SYMBOLSTOKENS r3   r3   I/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/nltk/sem/drt.pyr!   5   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d Zd S )!	DrtParserz$A lambda calculus expression parser.c                 C   s   t |  tdd tjD dd tjD  tdfg dd tjtj	 D  tj
dfg tjdfg dd tjD  d	d tjD  d
g | _d S )Nc                 S      g | ]}|d fqS    r3   .0xr3   r3   r4   
<listcomp>K       z&DrtParser.__init__.<locals>.<listcomp>c                 S   r6   )   r3   r9   r3   r3   r4   r<   L   r=      c                 S   r6   )   r3   r9   r3   r3   r4   r<   N   r=         c                 S   r6   )   r3   r9   r3   r3   r4   r<   Q   r=   c                 S   r6   )   r3   r9   r3   r3   r4   r<   R   r=   )N	   )r   __init__dictr!   LAMBDA_LISTNOT_LISTr   EQ_LISTr   NEQ_LISTr/   r+   OR_LISTIMP_LISToperator_precedenceselfr3   r3   r4   rF   G   s(   



zDrtParser.__init__c                 C      t jS )z#This method exists to be overridden)r!   r1   rO   r3   r3   r4   get_all_symbolsV   s   zDrtParser.get_all_symbolsc                 C   s
   |t jvS N)r!   r2   )rP   tokr3   r3   r4   
isvariableZ      
zDrtParser.isvariablec                 C   s   |t jv r| ||S |t jv r| ||S |t jkr4| dr.| dt jkr.| 	||S | 
||S | t jkrG| t j | 	||S | |re| dr_| dt jkr_| ||S | ||S dS )zgThis method is intended to be overridden for logics that
        use different operators or expressionsr   N)r!   rI   handle_negationrH   handle_lambdaOPENinRangetokenr-   
handle_DRShandle_openupperr"   assertNextTokenrU   r/   handle_prophandle_variable)rP   rT   contextr3   r3   r4   handle]   s    



zDrtParser.handlec                 C      t |S rS   DrtNegatedExpression)rP   
expressionr3   r3   r4   make_NegatedExpressionv      z DrtParser.make_NegatedExpressionc                 C   sL   |   }| dr| dtjkr|   | |}| tj t||d S Nr   )	handle_refsrZ   r[   r!   COMMAhandle_condsr_   CLOSEr"   )rP   rT   rb   refscondsr3   r3   r4   r\   y   s   
zDrtParser.handle_DRSc                 C   s   |  tj g }| dr8| dtjkr8|r#| dtjkr#|   || d | dr8| dtjks|  tj |S )Nr   
quantified)	r_   r!   r-   rZ   r[   r.   rl   appendget_next_token_variable)rP   ro   r3   r3   r4   rk         zDrtParser.handle_refsc                 C   s   |  tj g }| dr8| dtjkr8|r#| dtjkr#|   || | | dr8| dtjks|  tj |S rj   )	r_   r!   r-   rZ   r[   r.   rl   rr   process_next_expression)rP   rb   rp   r3   r3   r4   rm      rt   zDrtParser.handle_condsc                 C   s*   |  |}| d | tj}t||S )Nr'   )make_VariableExpressionr_   ru   r!   r/   DrtProposition)rP   rT   rb   variabledrsr3   r3   r4   r`      s   


zDrtParser.handle_propc                 C   
   t ||S )zlThis method serves as a hook for other logic parsers that
        have different equality expression classesDrtEqualityExpressionrP   firstsecondr3   r3   r4   make_EqualityExpression   s   
z!DrtParser.make_EqualityExpressionc                 C   s:   |t jkr	dd S |t jv rtS |t jv rdd }|S dS )zbThis method serves as a hook for other logic parsers that
        have different boolean operatorsc                 S      t | |d S rS   DrtConcatenationr~   r   r3   r3   r4   <lambda>   s    z9DrtParser.get_BooleanExpression_factory.<locals>.<lambda>c                 S   s<   t | trt| j| j|S t | trt| j| j|S tdNz'Antecedent of implication must be a DRS)
isinstancer"   ro   rp   r   r~   r   	Exceptionr   r3   r3   r4   make_imp_expression   s
   

zDDrtParser.get_BooleanExpression_factory.<locals>.make_imp_expressionN)r!   r+   rL   DrtOrExpressionrM   )rP   rT   r   r3   r3   r4   get_BooleanExpression_factory   s   


z'DrtParser.get_BooleanExpression_factoryc                 C   s
   |||S rS   r3   )rP   factoryr~   r   r3   r3   r4   make_BooleanExpression   rV   z DrtParser.make_BooleanExpressionc                 C   rz   rS   DrtApplicationExpression)rP   functionargumentr3   r3   r4   make_ApplicationExpression   rV   z$DrtParser.make_ApplicationExpressionc                 C   s   t t|S rS   )DrtVariableExpressionr   )rP   namer3   r3   r4   rv         z!DrtParser.make_VariableExpressionc                 C   rz   rS   )DrtLambdaExpression)rP   	variablestermr3   r3   r4   make_LambdaExpression   rV   zDrtParser.make_LambdaExpressionN)r(   r)   r*   __doc__rF   rR   rU   rc   rh   r\   rk   rm   r`   r   r   r   r   rv   r   r3   r3   r3   r4   r5   D   s"    r5   c                   @   s   e Zd ZdZe Zedd Zdd Zdd Z	dd	 Z
d
d Zdd Zd*ddZedd Zd*ddZdd Zd+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 ),DrtExpressionz_
    This is the base abstract DRT Expression from which every DRT
    Expression extends.
    c                 C      | j |S rS   )_drt_parserparse)clssr3   r3   r4   
fromstring      zDrtExpression.fromstringc                 C   s
   t | |S rS   r   rP   otherr3   r3   r4   applyto   rV   zDrtExpression.applytoc                 C      t | S rS   re   rO   r3   r3   r4   __neg__   ri   zDrtExpression.__neg__c                 C   s   t S rS   )NotImplementedr   r3   r3   r4   __and__      zDrtExpression.__and__c                 C   s   t |tsJ t| |S rS   )r   r   r   r   r3   r3   r4   __or__      
zDrtExpression.__or__c                 C   sJ   t |tsJ t | trt| j| j|S t | tr!t| j| j|S tdr   )	r   r   r"   ro   rp   r   r~   r   r   r   r3   r3   r4   __gt__   s   

zDrtExpression.__gt__Nc                 C   s2   t |tsJ |   }|  }|||S )a<  
        Check for logical equivalence.
        Pass the expression (self <-> other) to the theorem prover.
        If the prover says it is valid, then the self and other are equal.

        :param other: an ``DrtExpression`` to check equality against
        :param prover: a ``nltk.inference.api.Prover``
        )r   r   simplifyfolequiv)rP   r   proverf1f2r3   r3   r4   r      s   	zDrtExpression.equivc                 C   s   t d| jj )Nz#'%s' object has no attribute 'type')AttributeError	__class__r(   rO   r3   r3   r4   type   s   
zDrtExpression.typec                 C      t  rS   NotImplementedError)rP   	signaturer3   r3   r4   	typecheck      zDrtExpression.typecheckc                 C   r   rS   r   r   r3   r3   r4   __add__   r   zDrtExpression.__add__Fc                 C   r   )z
        Return the set of discourse referents in this DRS.
        :param recursive: bool Also find discourse referents in subterms?
        :return: list of ``Variable`` objects
        r   rP   	recursiver3   r3   r4   get_refs  s   zDrtExpression.get_refsc                 C   s2   t | tot | jto| jjjtjkot | jt	S )zIs self of the form "PRO(x)"?)
r   r   r   DrtAbstractVariableExpressionrx   r   r!   r,   r   DrtIndividualVariableExpressionrO   r3   r3   r4   is_pronoun_function
  s   


z!DrtExpression.is_pronoun_functionc                 C   rz   rS   r{   r}   r3   r3   r4   r     rV   z%DrtExpression.make_EqualityExpressionc                 C   rd   rS   )r   )rP   rx   r3   r3   r4   rv     ri   z%DrtExpression.make_VariableExpressionc                 C   r   rS   )resolve_anaphorarO   r3   r3   r4   r     ri   zDrtExpression.resolve_anaphorac                 C   s   |  dd | jS )Nc                 S      |   S rS   )eliminate_equality)er3   r3   r4   r         z2DrtExpression.eliminate_equality.<locals>.<lambda>)visit_structuredr   rO   r3   r3   r4   r        z DrtExpression.eliminate_equalityc                 C   s   d |  S )zG
        Draw the DRS
        :return: the pretty print string
        
)join_prettyrO   r3   r3   r4   pretty_format  s   zDrtExpression.pretty_formatc                 C   s   t |   d S rS   )printr   rO   r3   r3   r4   pretty_print&     zDrtExpression.pretty_printc                 C   s   t |   d S rS   )	DrsDrawerdrawrO   r3   r3   r4   r   )  r   zDrtExpression.drawrS   F)r(   r)   r*   r   r5   r   classmethodr   r   r   r   r   r   r   propertyr   r   r   r   r   r   rv   r   r   r   r   r   r3   r3   r3   r4   r      s0    




	r   c                   @   s   e Zd ZdZdddZd ddZd	d
 Zd!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ejZdd ZdS )"r"   z%A Discourse Representation Structure.Nc                 C   s   || _ || _|| _dS )z
        :param refs: list of ``DrtIndividualVariableExpression`` for the
            discourse referents
        :param conds: list of ``Expression`` for the conditions
        N)ro   rp   
consequent)rP   ro   rp   r   r3   r3   r4   rF   0  s   
zDRS.__init__FTc                    sZ  | j v r@s	| S | j }| jr| jd }nd}t| j d| jg | j |d d   fdd| jD |S  rt| j  @ D ]@t	}t
|| j }| jrh| jd }nd}t| j d| |g | j |d d   fdd| jD |} qK| jr| j }nd}t| j  fdd| jD |S )_Replace all instances of variable v with expression E in self,
        where v is free in self.TNr8   c                       g | ]
}| d  qS Treplacer:   cond)alpha_convertrg   rx   r3   r4   r<   K      zDRS.replace.<locals>.<listcomp>c                    r   r   r   r   )r   newvarexrefr3   r4   r<   a  r   c                    s   g | ]
}|  qS r3   r   r   )r   rg   replace_boundrx   r3   r4   r<   q  r   )ro   indexr   r   r"   rx   rp   setfreer   r   )rP   rx   rg   r   r   ir   newvarr3   )r   rg   r   r   r   rx   r4   r   :  sZ   
&	$
zDRS.replacec                 C   s@   t tjdd | jD t }| jr|| j  |t| j S )z:see: Expression.free()c                 S      g | ]}|  qS r3   )r   r:   cr3   r3   r4   r<   z  r=   zDRS.free.<locals>.<listcomp>)	r   operatoror_rp   r   r   updater   ro   )rP   
conds_freer3   r3   r4   r   x  s   zDRS.freec                 C   sF   |r | j ttdd | jD  }| jr|| jd |S | j S )#:see: AbstractExpression.get_refs()c                 s   s    | ]}| d V  qdS TN)r   r   r3   r3   r4   	<genexpr>  s    zDRS.get_refs.<locals>.<genexpr>T)ro   listr   from_iterablerp   r   extendr   )rP   r   
conds_refsr3   r3   r4   r     s   zDRS.get_refsc                 C   s.   t t|| j}| jr||| j ||S z:see: Expression.visit())r   maprp   r   rr   )rP   r   
combinatorpartsr3   r3   r4   visit  s   z	DRS.visitc                 C   s.   | j r|| j nd}|| jtt|| j|S )#:see: Expression.visit_structured()N)r   ro   r   r   rp   )rP   r   r   r   r3   r3   r4   r     s   zDRS.visit_structuredc                 C   s0  | }d}|t |jk rd|j| }t|trYt|jtrYt|jtrYttt	|j
|jjh |jd | |j|d d   |j}|jj|jjkrU||jj|jdd}d}|d8 }|d7 }|t |jk sg }|jD ]}| }| }t|tr|j
s|js|jr|| qi|jr|j nd }t|j
||S )Nr   r8   F)lenrp   r   r   r~   r   r   r"   r   r   ro   rx   r   r   r   r   rr   )rP   ry   r   r   rp   new_condnew_cond_simpr   r3   r3   r4   r     sJ   




zDRS.eliminate_equalityc                 C   s   | j r5d }| jrttdd | jD }|rt|| j  }n| j  }| jd d d D ]}t||}q+|S | js<tdttdd | jD }t	t
| | jd d d D ]}t||}qU|S )Nc                 S   r   r3   r   r   r3   r3   r4   r<     r=   zDRS.fol.<locals>.<listcomp>z-Cannot convert DRS with no conditions to FOL.c                 S   r   r3   r   r   r3   r3   r4   r<     r=   )r   rp   r   r   r   r   ro   r   r   r   r   _order_ref_stringsr   )rP   accumr   r3   r3   r4   r     s    
 zDRS.folc                    s   d | | j}dd dd | jD D }tt|gttt|  dd   d d|  d	 d
d   d g fdd|D  dd   d g }| j	r\t
|tj| j	 S |S )N c                 S   s   g | ]	}|D ]}|qqS r3   r3   )r:   	cond_liner   r3   r3   r4   r<     s    zDRS._pretty.<locals>.<listcomp>c                 S   s   g | ]}t d d | qS )c                 S   r   rS   )strip)r   r3   r3   r4   r     r   z(DRS._pretty.<locals>.<listcomp>.<lambda>)filterr   r   r3   r3   r4   r<     s    z __z_ |  |z|--z-|c                    s   g | ]}d |   d qS )r	  r
  )ljustr:   linelengthr3   r4   r<         z|_z_|)r   r  ro   rp   maxr   r   r   r  r   DrtBinaryExpression_assemble_prettyr!   IMPr   )rP   	refs_line
cond_linesry   r3   r  r4   r     s*   	zDRS._prettyc                 C   s   dd |D }g }g }g }g }|D ]%}t |r|| qt|r'|| qt|r1|| q|| qt|t|dd d t|dd d t|dd d S )Nc                 S   s   g | ]}d | qS )%sr3   )r:   r   r3   r3   r4   r<     r=   z*DRS._order_ref_strings.<locals>.<listcomp>c                 S   s(   t | dd  dgt| dd  dk S )Nr>   r  r   intr   vr3   r3   r4   r     s   ( z(DRS._order_ref_strings.<locals>.<lambda>)keyc                 S   0   | d t | dd  dgt| dd  dk fS Nr   r8   r  r  r  r3   r3   r4   r        0 c                 S   r  r  r  r  r3   r3   r4   r      r   )r   rr   r   r   sorted)rP   ro   stringsind_vars	func_vars
event_vars
other_varsr   r3   r3   r4   r    s*   zDRS._order_ref_stringsc                 C   s   t |trNt| jt|jkrN|}t| j|jD ]\}}| |}|||d}q| j|jkrNt| jt|jkrNt| j|jD ]\}}||ksK dS q@dS dS z}Defines equality modulo alphabetic variance.
        If we are comparing \x.M  and \y.N, then check equality of M and N[x/y].TF)	r   r"   r   ro   ziprv   r   r   rp   )rP   r   converted_otherr1r2varexc1c2r3   r3   r4   __eq__  s"   

z
DRS.__eq__c                 C   
   | |k S rS   r3   r   r3   r3   r4   __ne__  rV   z
DRS.__ne__c                 C   s^   d d| | jddd | jD }| jr-tj| d tj d d| j  tj	 S |S )Nz([{}],[{}]),, c                 s       | ]}d | V  qdS r  Nr3   r   r3   r3   r4   r         zDRS.__str__.<locals>.<genexpr>r  r  )
formatr   r  ro   rp   r   r!   rY   r  rn   rP   ry   r3   r3   r4   __str__  s(   	zDRS.__str__rS   FTr   )r(   r)   r*   r   rF   r   r   r   r   r   r   r   r   r  r/  r1  r   __hash__r9  r3   r3   r3   r4   r"   -  s     


>
$r"   c                 C   s>   t | jr	t| S t| jrt| S t| jrt| S t| S )z
    This is a factory method that instantiates and returns a subtype of
    ``DrtAbstractVariableExpression`` appropriate for the given variable.
    )r   r   r   r   DrtFunctionVariableExpressionr   DrtEventVariableExpressionDrtConstantExpressionrx   r3   r3   r4   r   ,  s   


r   c                   @   s.   e Zd Zdd ZdddZdd Zdd	 Zd
S )r   c                 C      | S rS   r3   rO   r3   r3   r4   r   <  r   z!DrtAbstractVariableExpression.folFc                 C   s   g S r   r3   r   r3   r3   r4   r   ?  s   z&DrtAbstractVariableExpression.get_refsc                 C   s    d|  }dt | }||||gS Nr  r  r   rP   r   blankr3   r3   r4   r   C  s   z%DrtAbstractVariableExpression._prettyc                 C   r@  rS   r3   rO   r3   r3   r4   r   H  r   z0DrtAbstractVariableExpression.eliminate_equalityNr   )r(   r)   r*   r   r   r   r   r3   r3   r3   r4   r   ;  s
    
r   c                   @      e Zd ZdS )r   Nr(   r)   r*   r3   r3   r3   r4   r   L      r   c                   @   rF  )r<  NrG  r3   r3   r3   r4   r<  R  rH  r<  c                   @   rF  )r=  NrG  r3   r3   r3   r4   r=  X  rH  r=  c                   @   rF  )r>  NrG  r3   r3   r3   r4   r>  ^      r>  c                   @   sn   e Zd Zdd ZdddZdd Zdd	d
Zdd Zdd Ze	j
Z
dd Zdd Zdd Zdd Zdd ZdS )rw   c                 C   s   || _ || _d S rS   rx   ry   )rP   rx   ry   r3   r3   r4   rF   c  s   
zDrtProposition.__init__FTc                 C   sP   | j |krt|tsJ dt|j | j||||S t| j | j||||S )Nz4Can only replace a proposition label with a variable)rx   r   r   rw   ry   r   )rP   rx   rg   r   r   r3   r3   r4   r   g  s   
zDrtProposition.replacec                 C      t | j| j S rS   )rw   rx   ry   r   rO   r3   r3   r4   r   v  r   z!DrtProposition.eliminate_equalityc                 C   s   |r| j dS g S NT)ry   r   r   r3   r3   r4   r   y  s   zDrtProposition.get_refsc                 C   s$   | j |j ko| j|jko| j|jkS rS   )r   rx   ry   r   r3   r3   r4   r/  |  s
   

zDrtProposition.__eq__c                 C   r0  rS   r3   r   r3   r3   r4   r1    rV   zDrtProposition.__ne__c                 C   s
   | j  S rS   )ry   r   rO   r3   r3   r4   r     rV   zDrtProposition.folc                    sj   j  }dtdj    fdd|d d D fdd|dd D   fdd|dd  D  S )	Nr  r  c                       g | ]} d  | qS r  r3   r  rE  r3   r4   r<         z*DrtProposition._pretty.<locals>.<listcomp>r8   c                    s   g | ]}d  j  d | qS )r  r'   r?  r  rO   r3   r4   r<     r  r>   c                    rM  rN  r3   r  rO  r3   r4   r<     rP  )ry   r   r   rx   )rP   drs_sr3   )rE  rP   r4   r     s   
zDrtProposition._prettyc                 C   s   ||| j gS r   )ry   rP   r   r   r3   r3   r4   r     s   zDrtProposition.visitc                 C   s   || j || jS )r   rJ  rR  r3   r3   r4   r     s   zDrtProposition.visit_structuredc                 C   s   d| j  d| j dS )Nzprop(r3  )rJ  rO   r3   r3   r4   r9       zDrtProposition.__str__Nr:  r   )r(   r)   r*   rF   r   r   r   r/  r1  r   r;  r   r   r   r   r9  r3   r3   r3   r4   rw   b  s    

	rw   c                   @   &   e Zd Zdd Zd	ddZdd ZdS )
rf   c                 C   s   t | j S rS   )r   r   r   rO   r3   r3   r4   r     s   zDrtNegatedExpression.folFc                 C   r   rA  )r   r   r   r3   r3   r4   r     r   zDrtNegatedExpression.get_refsc                 C   sb   | j  }dd |d d D dd |dd D  dd |dd D  dd |dd  D  S )	Nc                 S      g | ]}d | qS z    r3   r  r3   r3   r4   r<     r=   z0DrtNegatedExpression._pretty.<locals>.<listcomp>r>   c                 S   rV  )z__  r3   r  r3   r3   r4   r<     r=   r?   c                 S   rV  )z  | r3   r  r3   r3   r4   r<     r=   r@   c                 S   rV  rW  r3   r  r3   r3   r4   r<     r=   )r   r   )rP   
term_linesr3   r3   r4   r     s   
zDrtNegatedExpression._prettyNr   r(   r)   r*   r   r   r   r3   r3   r3   r4   rf     s    
rf   c                   @   s.   e Zd Zdd Zdd Zdd Zddd	Zd
S )r   c                 C   s   |  || j| jt|dS )zRename all occurrences of the variable introduced by this variable
        binder in the expression to ``newvar``.
        :param newvar: ``Variable``, for the new variable
        T)r   r   r   rx   r   )rP   r   r3   r3   r4   r     s   z!DrtLambdaExpression.alpha_convertc                 C   rK  rS   )r   rx   r   r   rO   r3   r3   r4   r     r   zDrtLambdaExpression.folc                    s   | j g}| j}|j| jkr||j  |j}|j| jksddd |D tj | }dt   fdd|d d D  fdd|dd D  fd	d|dd
 D   fdd|d
d  D  S )Nr  c                 s   r4  r5  r3   )r:   r  r3   r3   r4   r     r6  z.DrtLambdaExpression._pretty.<locals>.<genexpr>c                       g | ]}d   | qS rW  r3   r  rO  r3   r4   r<     rP  z/DrtLambdaExpression._pretty.<locals>.<listcomp>r8   c                    rZ  )z \  r3   r  rO  r3   r4   r<     rP  r>   c                    rZ  )z /\ r3   r  )
var_stringr3   r4   r<     rP  r?   c                    rZ  rW  r3   r  rO  r3   r4   r<     rP  )	rx   r   r   rr   r   r!   DOTr   r   )rP   r   r   rX  r3   )rE  r[  r4   r     s"   zDrtLambdaExpression._prettyFc                 C   s    |r| j g| jd S | j gS r   T)rx   r   r   r   r3   r3   r4   r     s   zDrtLambdaExpression.get_refsNr   )r(   r)   r*   r   r   r   r   r3   r3   r3   r4   r     s
    
r   c                   @   s2   e Zd ZdddZdd Zedd Zdd	 Zd
S )r  Fc                 C       |r| j d| jd S g S r]  )r~   r   r   r   r3   r3   r4   r     s   zDrtBinaryExpression.get_refsc                 C   s"   t | | j|  | | jS rS   )r  r  _pretty_subexr~   getOpr   rO   r3   r3   r4   r     s
   

zDrtBinaryExpression._prettyc                    s   t t| t|}t| |} t||}dt  tt| |} fdd|d d D fdd|dd D   fdd|dd  D  S )Nr  c                    ,   g | ]\}}d | d    d  | d  qS rN  r3   r:   
first_linesecond_linerO  r3   r4   r<         z8DrtBinaryExpression._assemble_pretty.<locals>.<listcomp>r>   c                    s,   g | ]\}}d | d   d | d qS )(r  rS  r3   rb  )opr3   r4   r<     re  r?   c                    ra  rN  r3   rb  rO  r3   r4   r<     re  )r  r   _pad_verticallyr   r(  )first_linesrg  second_lines	max_linesfirst_second_linesr3   )rE  rg  r4   r    s"   







z$DrtBinaryExpression._assemble_prettyc                 C   s   |  S rS   r   rP   subexr3   r3   r4   r_    ri   z!DrtBinaryExpression._pretty_subexNr   )r(   r)   r*   r   r   staticmethodr  r_  r3   r3   r3   r4   r    s    

r  c                   @   rF  )DrtBooleanExpressionNrG  r3   r3   r3   r4   rq    rI  rq  c                   @   s   e Zd Zdd Zdd ZdS )r   c                 C      t | j | j S rS   )r   r~   r   r   rO   r3   r3   r4   r     rT  zDrtOrExpression.folc                 C   (   t |trdd | D S t| |S )Nc                 S      g | ]}|d d qS r8   r  r3   r  r3   r3   r4   r<   	  rP  z1DrtOrExpression._pretty_subex.<locals>.<listcomp>)r   r   r   rq  r_  rn  r3   r3   r4   r_       
zDrtOrExpression._pretty_subexN)r(   r)   r*   r   r_  r3   r3   r3   r4   r     s    r   c                   @   s   e Zd Zdd ZdS )r|   c                 C   rr  rS   )r   r~   r   r   rO   r3   r3   r4   r     rT  zDrtEqualityExpression.folN)r(   r)   r*   r   r3   r3   r3   r4   r|     s    r|   c                   @   s   e Zd ZdZd!ddZd"ddZd	d
 Zdd Zd#ddZdd Z	dd Z
dd ZejZdd Zdd Zdd Zdd Zdd Zdd  ZdS )$r   zDRS of the form '(DRS + DRS)'Nc                 C   s   t | || || _d S rS   )rq  rF   r   )rP   r~   r   r   r3   r3   r4   rF     r   zDrtConcatenation.__init__FTc           
      C   s   | j }| j}| j}||  v r,|r+|||||}|||||}|r+|||||}nJ|r\t| d| @ D ]"}tt|}	|||	d|}|||	d|}|r[|||	d|}q9|||||}|||||}|rv|||||}| 	|||S )r   T)
r~   r   r   r   r   r   r   r   r   r   )
rP   rx   rg   r   r   r~   r   r   r   r  r3   r3   r4   r     s>   zDrtConcatenation.replacec                 C   s   |   }t|trJ | S rS   )r   r   r   r   r8  r3   r3   r4   r   @  s   z#DrtConcatenation.eliminate_equalityc                 C   s   | j  }| j }| jr| j nd }t|trJt|trJt|dt|d@ D ]}tt	|}|
||d}q,t|j|j |j|j |S | |||S rL  )r~   r   r   r   r   r"   r   r   r   r   r   ro   rp   r   )rP   r~   r   r   r   r   r3   r3   r4   r   F  s   

 zDrtConcatenation.simplifyc                 C   s8   | j || j| }| jr|r|| jd |S r]  )r~   r   r   r   r   )rP   r   ro   r3   r3   r4   r   V  s   
zDrtConcatenation.get_refsc                 C   rQ   rS   )r!   r+   rO   r3   r3   r4   r`  ]  r   zDrtConcatenation.getOpc                 C   s   t |tr?|  }| }t|t|kr?|}t||D ]\}}| |}|||d}q| j|jko>| j|jko>| j	|j	kS dS r'  )
r   r   r   r   r(  rv   r   r~   r   r   )rP   r   	self_refs
other_refsr)  r*  r+  r,  r3   r3   r4   r/  `  s   



zDrtConcatenation.__eq__c                 C   r0  rS   r3   r   r3   r3   r4   r1  r  rV   zDrtConcatenation.__ne__c                 C   s0   t | j | j }| jrt|| j }|S rS   )r   r~   r   r   r   r   )rP   r   r3   r3   r4   r   w  s   zDrtConcatenation.folc                 C   sB   t | | j|  | | j}| jrt |tj| j	 }|S rS   )
r  r  r_  r~   r`  r   r   r!   r  r   r8  r3   r3   r4   r   }  s   

zDrtConcatenation._prettyc                 C   rs  )Nc                 S   rt  ru  r3   r  r3   r3   r4   r<     rP  z2DrtConcatenation._pretty_subex.<locals>.<listcomp>)r   r   r   rq  r_  rn  r3   r3   r4   r_    rv  zDrtConcatenation._pretty_subexc                 C   s>   | j r||| j|| j|| j gS ||| j|| jgS r   )r   r~   r   rR  r3   r3   r4   r     s
   zDrtConcatenation.visitc                 C   sn   |  | j}|  | j}tj| d |   d | tj }| jr5tj| d tj	 d d| j  tj S |S )Nr  r  )

_str_subexr~   r   r   rY   r`  rn   r   r!   r  )rP   r~   r   ry   r3   r3   r4   r9    s&   $	zDrtConcatenation.__str__c                 C   s,   d| }t |tr|jd u r|dd S |S )Nr  r8   r  )r   r   r   )rP   ro  r   r3   r3   r4   ry    s   zDrtConcatenation._str_subexrS   r:  r   )r(   r)   r*   r   rF   r   r   r   r   r`  r/  r1  rq  r;  r   r   r_  r   r9  ry  r3   r3   r3   r4   r     s"    

'
	r   c                   @   rU  )
r   c                 C   rr  rS   )r   r   r   r   rO   r3   r3   r4   r     rT  zDrtApplicationExpression.folFc                 C   r^  r]  )r   r   r   r   r3   r3   r4   r     s
   z!DrtApplicationExpression.get_refsc                    s   |   \}}| }dd |D }ttt|g|  t| } fdd|D }tt|tt| }dd |d d D dd |dd D  dd |dd  D  S )	Nc                 S   r   r3   rm  r:   argr3   r3   r4   r<     r=   z4DrtApplicationExpression._pretty.<locals>.<listcomp>c                    s   g | ]}t | qS r3   )rh  )r:   	arg_linesrk  r3   r4   r<     s    c                 S   &   g | ]\}}|d  d  | d  qS rN  r   r:   	func_line	args_liner3   r3   r4   r<         r>   c                 S   s&   g | ]\}}|d  d | d qS )rf  r2  rS  r  r  r3   r3   r4   r<     r  r?   c                 S   r~  rN  r  r  r3   r3   r4   r<     r  )uncurryr   r  r   r   rh  r   r(  )rP   r   argsfunction_lines
args_linesfunc_args_linesr3   r}  r4   r     s&   



z DrtApplicationExpression._prettyNr   rY  r3   r3   r3   r4   r     s    
r   c                 C   s&   dt | d  g}| ||t |    S )Nr  r   rC  )linesrk  pad_liner3   r3   r4   rh    s   rh  c                   @   s.   e Zd Zdd ZdddZdd Zd	d
 ZdS )PossibleAntecedentsc                 C   r   )zSet of free variables.)r   rO   r3   r3   r4   r     s   zPossibleAntecedents.freeFTc                 C   s2   t  }| D ]}||kr| | q| | q|S )r   )r  rr   )rP   rx   rg   r   r   resultitemr3   r3   r4   r     s   zPossibleAntecedents.replacec                 C   s   d|  }dt | }|||gS rB  rC  rD  r3   r3   r4   r     s   
zPossibleAntecedents._prettyc                 C   s   dd dd | D  d S )Nr%   r2  c                 s   r4  r5  r3   )r:   itr3   r3   r4   r     r6  z.PossibleAntecedents.__str__.<locals>.<genexpr>r&   r  rO   r3   r3   r4   r9    s   zPossibleAntecedents.__str__Nr:  )r(   r)   r*   r   r   r   r9  r3   r3   r3   r4   r    s
    
r  c                   @   rF  )AnaphoraResolutionExceptionNrG  r3   r3   r3   r4   r    rI  r  c                 C   sB  t | trZ|  rBt }|D ]}| D ]}| |}|j| jjkr,|| jks,|| qqt	|dkr9|d }n|}| 
| j|S t| j|| g }t| j|| g }| ||S t | trg }	| jD ]4}
t|
|| g }t |trt |jtr|j}|j|_||_t |jtr|jstd|j |	| qd| jrt| j|| g }nd }| | j|	|S t | tr| S t | tr| t| j|| g S t | tr| jrt| j|| g }nd }| t| j|| g t| j|| g |S t | tr| t| j|| g t| j|| g S t | tr| | jt| j|| g S d S )Nr8   r   z+Variable '%s' does not resolve to anything.)r   r   r   r  r   rv   r   r   rr   r   r   r   r   r"   rp   r   r~   r   r  r   ro   r   r   r   r   r	   r   rx   )rg   trailpossible_antecedentsancestorr   refex
resolution
r_function
r_argumentr_condsr   r_condtempr   r3   r3   r4   r     s   










r   c                   @   s   e Zd ZdZdZdZd%ddZdd	 Zeefd
dZdd Z	dd Z
dd Zd&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 )'r   r?   
   rB   TNc           
      C   s   d}|sOt  }|d tddd}|rAt|ddd}||_|| _| || j| j\}}t	|| j d}|| j }	t|||	d}nt|d	d	d}|
  ||_|| _|| _|| _dS )
a  
        :param drs: ``DrtExpression``, The DRS to be drawn
        :param size_canvas: bool, True if the canvas size should be the exact size of the DRS
        :param canvas: ``Canvas`` The canvas on which to draw the DRS.  If none is given, create a new canvas.
        NDRT	helvetica   )familysizer   )widthheightd   i,  )r   titler   r   fontcanvas_visit
OUTERSPACETOPSPACEr  packry   master)
rP   ry   size_canvasr  r  r  rightbottomr  r  r3   r3   r4   rF   L  s&   


zDrsDrawer.__init__c                 C   s   | j jdS )z Get the height of a line of text	linespace)r  r  metricsrO   r3   r3   r4   _get_text_heightl  s   zDrsDrawer._get_text_heightc                 C   s>   |  | j| j|| | jrt s| j  dS | | j||S )zDraw the DRSN)_handlery   _draw_commandr  r    mainloopr  rP   r;   yr3   r3   r4   r   p  s   zDrsDrawer.drawc                 C   s   |  || j||S )a!  
        Return the bottom-rightmost point without actually drawing the item

        :param expression: the item to visit
        :param x: the top of the current drawing area
        :param y: the left side of the current drawing area
        :return: the bottom-rightmost point
        )r  _visit_command)rP   rg   r;   r  r3   r3   r4   r  y  s   	zDrsDrawer._visitc                 C   s   t |tr| jj||d| jj|d n&t |tr9|\}}| j|||| ||   | jd  }| j	|||| | 
|||S )a   
        Draw the given item at the given location

        :param item: the item to draw
        :param x: the top of the current drawing area
        :param y: the left side of the current drawing area
        :return: the bottom-rightmost point
        nw)anchorr  textr>   )r   strr  create_textr  tuplecreate_rectangler  BUFFERcreate_liner  )rP   r  r;   r  r  r  horiz_line_yr3   r3   r4   r    s   
	
zDrsDrawer._draw_commandc                 C   s:   t |tr|| jj| ||   fS t |tr|S dS )a  
        Return the bottom-rightmost point without actually drawing the item

        :param item: the item to visit
        :param x: the top of the current drawing area
        :param y: the left side of the current drawing area
        :return: the bottom-rightmost point
        N)r   r  r  r  measurer  r  )rP   r  r;   r  r3   r3   r4   r    s
   
	
zDrsDrawer._visit_commandr   c                 C   s  || j krz|j| }|j| }||fW S  ty   Y nw t|tr'| j}nEt|tr0| j}n<t|t	r9| j
}n3t|trB| j}n*t|trK| j}n!t|trT| j}nt|tr]| j}nt|trf| j}nt|jj|||||\}}|| |_|| |_||fS )a1  
        :param expression: the expression to handle
        :param command: the function to apply, either _draw_command or _visit_command
        :param x: the top of the current drawing area
        :param y: the left side of the current drawing area
        :return: the bottom-rightmost point
        )r  _drawing_width_drawing_heightr   r   r   _handle_VariableExpressionr"   _handle_DRSrf   _handle_NegatedExpressionr   _handle_LambdaExpressionr	   _handle_BinaryExpressionr   _handle_ApplicationExpressionr  rw   _handle_DrtPropositionr   r   r(   )rP   rg   commandr;   r  r  r  r   r3   r3   r4   r    s:   













zDrsDrawer._handlec                 C   s   |d| ||S )Nr  r3   )rP   rg   r  r;   r  r3   r3   r4   r    r   z$DrsDrawer._handle_VariableExpressionc              	   C   sR   |  tj||d }| |j|||\}}|tj|| ||| |   ||fS rj   )r  r!   NOTr  r   _get_centered_topr  rP   rg   r  r;   r  r  r  r3   r3   r4   r    s   z#DrsDrawer._handle_NegatedExpressionc                 C   s   || j  }|| j  }|jrddd |jD }nd}||||\}}|| j d 7 }|jrH|jD ]}	| |	|||\}
}t||
}|| j 7 }q0n	||  | j  7 }|| j 7 }|||f||S )Nr  c                 s   r4  r5  r3   )r:   rr3   r3   r4   r     r6  z(DrsDrawer._handle_DRS.<locals>.<genexpr>z     r>   )r  ro   r   rp   r  r  r  )rP   rg   r  r;   r  leftr  ro   	max_rightr   r  r3   r3   r4   r    s    




zDrsDrawer._handle_DRSc                    s  |  \}}t|ts|j}|jg} |d }t|g fdd|D  }| }	 |	|j}
 	|||
d } |	 
 }|tj||d }t|D ])\}} |	|j} 	||||d }|d t|k r|tjd ||d }qW|tj||d }||fS )Nr8   c                    s   g | ]}  |d  qS r7   )r  rz  r  r3   r4   r<     r  z;DrsDrawer._handle_ApplicationExpression.<locals>.<listcomp>r   r  )r  r   r   r   r   r  r  r  r  r  r  r!   rY   	enumerater   rl   rn   )rP   rg   r  r;   r  r   r  function_bottom
max_bottomline_heightfunction_drawing_topr  centred_string_topr   r{  arg_drawing_topr3   r  r4   r    s6   

z'DrsDrawer._handle_ApplicationExpressionc              	   C   sd   t jd|j  t j }| |||d }| |j|||\}}|||| ||| |   ||fS )Nr  r   )	r!   LAMBDArx   r\  r  r  r   r  r  )rP   rg   r  r;   r  r   r  r  r3   r3   r4   r  -  s   z"DrsDrawer._handle_LambdaExpressionc              
   C   s   |  |jddd }|  |jddd }t||}| |||  }|tj||d }	|jj}| 	|j||	| |||\}	}
|d|
  |	|d }	|jj}| 	|j||	| |||\}	}|tj|	|d }	|	t|
|fS )Nr   r8   z %s )r  r~   r   r  r  r  r!   rY   r  r  r`  rn   )rP   rg   r  r;   r  first_heightsecond_heightr  r  r  first_bottomsecond_bottomr3   r3   r4   r  <  s0   

z"DrsDrawer._handle_BinaryExpressionc                 C   s0   ||j ||d }| |j|||\}}||fS rj   )rx   r  r   r  r3   r3   r4   r  b  s   z DrsDrawer._handle_DrtPropositionc                 C   s   ||| d  S )zGet the y-coordinate of the point that a figure should start at if
        its height is 'item_height' and it needs to be centered in an area that
        starts at 'top' and is 'full_height' tall.r>   r3   )rP   topfull_heightitem_heightr3   r3   r4   r  k  s   zDrsDrawer._get_centered_topr   )r   r   )r(   r)   r*   r  r  r  rF   r  r   r  r  r  r  r  r  r  r  r  r  r  r  r3   r3   r3   r4   r   G  s&    
 	
.+&	r   c                  C   sL  t d tj} t | d t | d t | d t | d t | d t | d t | d t | d	 t | d
 t d t | d  t d | d}t | |td}t | t ||k t d t t| d t t| d t t| d t d | d  | d  | d  | d  | d  d S )Nz2====================TEST PARSE====================([x,y],[sees(x,y)])([x],[man(x), walks(x)])z\x.\y.([],[sees(x,y)])z\x.([],[walks(x)])(john)z$(([x],[walks(x)]) + ([y],[runs(y)]))z#(([],[walks(x)]) -> ([],[runs(x)]))z([x],[PRO(x), sees(John,x)]) ([x],[man(x), -([],[walks(x)])])*([],[(([x],[man(x)]) -> ([],[walks(x)]))])z2====================Test fol()====================z\====================Test alpha conversion and lambda expression equality====================z\x.([],[P(x)])zz?====================Test resolve_anaphora()====================z,([x,y,z],[dog(x), cat(y), walks(z), PRO(z)])z3([],[(([x],[dog(x)]) -> ([y],[walks(y), PRO(y)]))])z(([x,y],[]) + ([],[PRO(x)]))z;====================Test pretty_print()====================([],[])z@([],[([x],[big(x), dog(x)]) -> ([],[bark(x)]) -([x],[walk(x)])])z'([x,y],[x=y]) + ([z],[dog(z), walk(z)])z4([],[([x],[]) | ([y],[]) | ([z],[dog(z), walk(z)])])z0\P.\Q.(([x],[]) + P(x) + Q(x))(\x.([],[dog(x)])))r   r   r   r   r   r   r   r   )dexpre1e2r3   r3   r4   demor  sD   
r  c               
   C   sZ   zddl m}  W n ty } ztdd }~ww g d}|D ]}t|}|  qd S )Nr   )r   z,tkinter is required, but it's not available.)r;   r  z([x],[])z([x],[man(x)])r  r  z\x.([],[man(x), walks(x)])z\x y.([],[sees(x,y)])z)([],[(([],[walks(x)]) + ([],[runs(x)]))])r  r  )tkinterr   ImportError
ValueErrorr   r   r   )r   r   expressionsdr3   r3   r4   	test_draw  s   

r  __main__)Dr   	functoolsr   	itertoolsr   nltk.sem.logicr   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r   r   tkinter.fontr   	nltk.utilr    r  r!   r5   r   r"   r   r   r   r<  r=  r>  rw   rf   r   r  rq  r   r|   r   r   rh  r   r  r   r  r   r   r  r  r(   r3   r3   r3   r4   <module>   sh   l g  


>%(
 $S  -(

