o
    oh/                     @  s   U d dl mZ d dlmZ d dlZddlmZmZmZm	Z	 ddl
mZ d dlZG dd deZd	d
 ZG dd dZdd Ze Zded< dgZdd ZefddZG dd dZdd ZG dd deZdd Zdd ZdS )     )annotations)warnN   )orderingambiguitiessuper_signatureAmbiguityWarning)expand_tuplesc                   @  s   e Zd ZdZdS )MDNotImplementedErrorz- A NotImplementedError for multiple dispatch N)__name__
__module____qualname____doc__ r   r   u/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/multipledispatch/dispatcher.pyr
   
   s    r
   c                 C  s   t t| j|t dS )aC   Raise warning when ambiguity is detected

    Parameters
    ----------
    dispatcher : Dispatcher
        The dispatcher on which the ambiguity was detected
    ambiguities : set
        Set of type signature pairs that are ambiguous within this dispatcher

    See Also:
        Dispatcher.add
        warning_text
    N)r   warning_textnamer   )
dispatcherr   r   r   r   ambiguity_warn   s   r   c                   @  s    e Zd ZdZdd Zdd ZdS )RaiseNotImplementedErrorz*Raise ``NotImplementedError`` when called.c                 C  s
   || _ d S N)r   )selfr   r   r   r   __init__$      
z!RaiseNotImplementedError.__init__c                 O  s*   t dd |D }td| jjt|f )Nc                 s  s    | ]}t |V  qd S r   type).0ar   r   r   	<genexpr>(   s    z4RaiseNotImplementedError.__call__.<locals>.<genexpr>z Ambiguous signature for %s: <%s>)tupleNotImplementedErrorr   r   str_signature)r   argskwargstypesr   r   r   __call__'   s   z!RaiseNotImplementedError.__call__N)r   r   r   r   r   r%   r   r   r   r   r   !   s    r   c                 C  s@   |D ]}t t|}tt|dkrq| j|t| td qdS )a  
    If super signature for ambiguous types is duplicate types, ignore it.
    Else, register instance of ``RaiseNotImplementedError`` for ambiguous types.

    Parameters
    ----------
    dispatcher : Dispatcher
        The dispatcher on which the ambiguity was detected
    ambiguities : set
        Set of type signature pairs that are ambiguous within this dispatcher

    See Also:
        Dispatcher.add
        ambiguity_warn
    r   on_ambiguityN)r   r   lensetaddr   #ambiguity_register_error_ignore_dup)r   r   amb	signaturer   r   r   r+   .   s   r+   zset[Dispatcher]_unresolved_dispatchersTc                   C  s   dt d< d S )NFr   )_resolver   r   r   r   halt_orderingN   s   r0   c                 C  s,   dt d< trt }|j| d tsd S d S )NTr   r&   )r/   r.   popreorder)r'   r   r   r   r   restart_orderingR   s
   r3   c                   @  s   e Zd ZdZdZd(ddZdd Zedd	 Zed
d Z	e
fddZe
fddZdd Zdd ZeZdd Zdd Zdd Zdd Zdd Zedd Zd d! Zd"d# Zd$d% Zd&d' ZdS ))
Dispatcheraj   Dispatch methods based on type signature

    Use ``dispatch`` to add implementations

    Examples
    --------

    >>> from sympy.multipledispatch import dispatch
    >>> @dispatch(int)
    ... def f(x):
    ...     return x + 1

    >>> @dispatch(float)
    ... def f(x): # noqa: F811
    ...     return x - 1

    >>> f(3)
    4
    >>> f(3.0)
    2.0
    )r   r   funcsr   _cachedocNc                 C  s(   | | _ | _i | _i | _g | _|| _d S r   )r   r   r5   r6   r   r7   )r   r   r7   r   r   r   r   q   s
   
zDispatcher.__init__c                   s    fdd}|S )a#   Register dispatcher with new implementation

        >>> from sympy.multipledispatch.dispatcher import Dispatcher
        >>> f = Dispatcher('f')
        >>> @f.register(int)
        ... def inc(x):
        ...     return x + 1

        >>> @f.register(float)
        ... def dec(x):
        ...     return x - 1

        >>> @f.register(list)
        ... @f.register(tuple)
        ... def reverse(x):
        ...     return x[::-1]

        >>> f(1)
        2

        >>> f(1.0)
        0.0

        >>> f([1, 2, 3])
        [3, 2, 1]
        c                   s   j | fi   | S r   )r*   )funcr#   r   r$   r   r   _   s   zDispatcher.register.<locals>._r   )r   r$   r#   r:   r   r9   r   registerx   s   zDispatcher.registerc                 C  s"   t tdrt|}|j S d S )Nr-   )hasattrinspectr-   
parametersvaluesclsr8   sigr   r   r   get_func_params   s   


zDispatcher.get_func_paramsc                   sZ   |  |}|r)tj  fdd|D }tdd |D }t fdd|D s+|S dS dS )z; Get annotations of function positional parameters
        c                 3  s&    | ]}|j  j jfv r|V  qd S r   )kindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORDr   param	Parameterr   r   r      s    z2Dispatcher.get_func_annotations.<locals>.<genexpr>c                 s      | ]}|j V  qd S r   )
annotationrG   r   r   r   r      s
    
c                 3  s    | ]}| j u V  qd S r   )empty)r   annrI   r   r   r          N)rC   r=   rJ   r   any)rA   r8   paramsr   r   rI   r   get_func_annotations   s   
zDispatcher.get_func_annotationsc                 C  s   |s|  |}|r|}tdd |D r$t|D ]	}| ||| qdS |D ]}t|tsAddd |D }td||| jf q&|| j	|< | j
|d | j  dS )a   Add new types/method pair to dispatcher

        >>> from sympy.multipledispatch import Dispatcher
        >>> D = Dispatcher('add')
        >>> D.add((int, int), lambda x, y: x + y)
        >>> D.add((float, float), lambda x, y: x + y)

        >>> D(1, 2)
        3
        >>> D(1, 2.0)
        Traceback (most recent call last):
        ...
        NotImplementedError: Could not find signature for add: <int, float>

        When ``add`` detects a warning it calls the ``on_ambiguity`` callback
        with a dispatcher/itself, and a set of ambiguous type signature pairs
        as inputs.  See ``ambiguity_warn`` for an example.
        c                 s  s    | ]}t |tV  qd S r   )
isinstancer   )r   typr   r   r   r      rO   z!Dispatcher.add.<locals>.<genexpr>N, c                 s  s(    | ]}t |tr|jnt|V  qd S r   )rS   r   r   str)r   cr   r   r   r      s    
zDTried to dispatch on non-type: %s
In signature: <%s>
In function: %sr&   )rR   rP   r	   r*   rS   r   join	TypeErrorr   r5   r2   r6   clear)r   r-   r8   r'   r   typsrT   str_sigr   r   r   r*      s(   




zDispatcher.addc                 C  sB   t d rt| j| _t| j}|r|| | d S d S t|  d S )Nr   )r/   r   r5   r   r.   r*   )r   r'   r,   r   r   r   r2      s   
zDispatcher.reorderc                 O  s   t dd |D }z| j| }W n  ty0   | j| }|s)td| jt|f || j|< Y nw z||i |W S  tyn   | j| }t	| |D ]}z||i |W    Y S  tyb   Y qKw td| jt|f w )Nc                 S     g | ]}t |qS r   r   r   argr   r   r   
<listcomp>       z'Dispatcher.__call__.<locals>.<listcomp>%Could not find signature for %s: <%s>zFMatching functions for %s: <%s> found, but none completed successfully)
r   r6   KeyErrordispatchr    r   r!   r
   dispatch_iternext)r   r"   r#   r$   r8   r5   r   r   r   r%      s8   

zDispatcher.__call__c                 C  s
   d| j  S )Nz<dispatched %s>r   r   r   r   r   __str__  r   zDispatcher.__str__c                 G  s:   || j v r
| j | S zt| j| W S  ty   Y dS w )a`   Deterimine appropriate implementation for this type signature

        This method is internal.  Users should call this object as a function.
        Implementation resolution occurs within the ``__call__`` method.

        >>> from sympy.multipledispatch import dispatch
        >>> @dispatch(int)
        ... def inc(x):
        ...     return x + 1

        >>> implementation = inc.dispatch(int)
        >>> implementation(3)
        4

        >>> print(inc.dispatch(float))
        None

        See Also:
            ``sympy.multipledispatch.conflict`` - module to determine resolution order
        N)r5   rf   re   StopIterationr   r$   r   r   r   rd     s   

zDispatcher.dispatchc                 g  sF    t |}| jD ]}t ||kr ttt||r | j| }|V  qd S r   )r(   r   allmap
issubclassr5   )r   r$   nr-   resultr   r   r   re   #  s   

zDispatcher.dispatch_iterc                 C  s   t dt | j| S )z Deterimine appropriate implementation for this type signature

        .. deprecated:: 0.4.4
            Use ``dispatch(*types)`` instead
        z-resolve() is deprecated, use dispatch(*types))r   DeprecationWarningrd   rk   r   r   r   resolve*  s   
zDispatcher.resolvec                 C  s   | j | jdS )Nr   r5   rs   rh   r   r   r   __getstate__5  s   zDispatcher.__getstate__c                 C  s*   |d | _ |d | _t| j| _i | _d S )Nr   r5   )r   r5   r   r6   )r   dr   r   r   __setstate__9  s   


zDispatcher.__setstate__c                 C  s   d| j  g}| jr|| j g }| jd d d D ].}| j| }|jr@dt| }|dt| d 7 }||j 7 }|| q|t| q|rT|dd	|  d	|S )	NzMultiply dispatched method: %szInputs: <%s>
-
zOther signatures:
    z
    

)
r   r7   appendr   r5   r   r!   r(   striprX   )r   docsotherrB   r8   sr   r   r   r   ?  s   

zDispatcher.__doc__c                 G  s   | j tt| jS r   )rd   rm   r   r   )r   r"   r   r   r   _helpV  s   zDispatcher._helpc                 O     t | j|  dS )z: Print docstring for the function corresponding to inputs N)printr   r   r"   r#   r   r   r   helpY     zDispatcher.helpc                 G  s$   | j tt| }|stdt|S )NzNo function found)rd   rm   r   rY   source)r   r"   r8   r   r   r   _source]  s   zDispatcher._sourcec                 O  r   )z< Print source code for the function corresponding to inputs N)r   r   r   r   r   r   r   c  r   zDispatcher.sourcer   )r   r   r   r   	__slots__r   r;   classmethodrC   rR   r   r*   r2   r%   ri   __repr__rd   re   rr   rt   rv   propertyr   r   r   r   r   r   r   r   r4   Y   s2    
 

,	
r4   c                 C  s    dt |  }|t |  }|S )Nz
File: %s

)r=   getsourcefile	getsource)r8   r   r   r   r   r   h  s   r   c                   @  s,   e Zd ZdZedd Zdd Zdd ZdS )	MethodDispatcherzP Dispatch methods based on type signature

    See Also:
        Dispatcher
    c                 C  s,   t tdrt|}t|j dd S d S )Nr-   r   )r<   r=   r-   itlislicer>   r?   r@   r   r   r   rC   u  s   

z MethodDispatcher.get_func_paramsc                 C  s   || _ || _| S r   )objrA   )r   instanceownerr   r   r   __get__{  s   zMethodDispatcher.__get__c                 O  sN   t dd |D }| j| }|std| jt|f || jg|R i |S )Nc                 S  r]   r   r   r^   r   r   r   r`     ra   z-MethodDispatcher.__call__.<locals>.<listcomp>rb   )r   rd   r    r   r!   r   )r   r"   r#   r$   r8   r   r   r   r%     s   
zMethodDispatcher.__call__N)r   r   r   r   r   rC   r   r%   r   r   r   r   r   n  s    
r   c                 C  s   d dd | D S )z String representation of type signature

    >>> from sympy.multipledispatch.dispatcher import str_signature
    >>> str_signature((int, float))
    'int, float'
    rU   c                 s  rK   r   )r   )r   rA   r   r   r   r     s    z str_signature.<locals>.<genexpr>rX   )rB   r   r   r   r!     s   r!   c                   sb   d  }|d7 }|D ]}|dd dd |D  d 7 }q
|d7 }|d	  fd
d|D 7 }|S )z! The text for ambiguity warnings z.
Ambiguities exist in dispatched function %s

z;The following signatures may result in ambiguous behavior:
	rU   c                 s  s     | ]}d t | d V  qdS )[]N)r!   r   r   r   r   r   r     s    zwarning_text.<locals>.<genexpr>ry   z,

Consider making the following additions:

rz   c                   s$   g | ]}d t t| d   qS )z
@dispatch(z)
def %s(...))r!   r   r   rg   r   r   r`     s
    z warning_text.<locals>.<listcomp>r   )r   r,   textpairr   rg   r   r     s   
r   )
__future__r   warningsr   r=   conflictr   r   r   r   utilsr	   	itertoolsr   r    r
   r   r   r+   r)   r.   __annotations__r/   r0   r3   r4   r   r   r!   r   r   r   r   r   <module>   s*      
