
    @ܶi^                         d Z ddlmZ ddlZddlmZmZmZ ddlZddl	m
Z
 ddlmZ ddlmZ dd	lmZ erdd
lmZ d1dZ G d d          Zd2d3dZd2d4dZd5dZ	 	 	 	 	 d6d7d*Z	 	 d8d9d0ZdS ):zM
Python implementation of function wrapping functionality for functorch.dim.
    )annotationsN)AnyOptionalTYPE_CHECKING)tree_map   )DimEntry)EnableAllLayers)
TensorInfo)Callabletensortorch.Tensorreturnc                    | S )z8Handle tensor conversion for torch function integration. )r   s    X/root/projects/openclaw-proxy/venv/lib64/python3.11/site-packages/functorch/dim/_wrap.pyhandle_from_tensorr      s    M    c                  &    e Zd ZdZ	 dddZdd
ZdS )WrappedOperatorzP
    This class wraps PyTorch operations to support first-class dimensions.
    dimorigr   wrapper_implementationdim_namestrc                    || _         || _        t          |dd          | _        t          |dd           | _        || _        d| _        d| _        d| _        d| _	        d| _
        | j        r | j        r| j         d| j         d	| _        d S d S d S )
N__name__ __doc__Fr   r   Tz
Argument 'z5' can be either an integer or a torchdim.Dim object.
)r   r   getattrnamedocr   is_pointwise
dim_offsetkeepdim_offset
single_dimreduce)selfr   r   r   s       r   __init__zWrappedOperator.__init__    s     	&<#D*b11	4D11 ! 8 	v 	v(uuuuuDHHH	v 	v 	v 	vr   r   c                f     d	 fd}t          j        | j        dd            j        |_        |S )
z@Create a wrapped function that calls our wrapper implementation.argsr   kwargsr   c                 &     j         g| R i |S )N)r   )r+   r,   r(   s     r   wrapped_funcz.WrappedOperator.function.<locals>.wrapped_func6   s&    .4.tEdEEEfEEEr   )r   r   )assignedupdated)r+   r   r,   r   r   r   )	functoolsupdate_wrapperr   r"   r   )r(   r.   s   ` r   functionzWrappedOperator.function3   s`    	F 	F 	F 	F 	F 	F 	 $)mR	
 	
 	
 	
  $xr   N)r   )r   r   r   r   r   r   )r   r   )r   
__module____qualname__r   r)   r3   r   r   r   r   r      sW         
 QVv v v v v&     r   r   Fr   r   ndimintkeepdimboolr	   c                    ddl m} t          | |          r |rt          d          t	          |           S t          | t
                    r"| }|dk    r||z  }|dk    t	          |          S t	                      S )z:Convert single dimension specification to DimEntry object.r   )Dimz8cannot preserve first-class dimensions with keepdim=Truer   )r   r;   
isinstance
ValueErrorr	   r7   )r   r6   r8   r;   is        r   	_wrap_dimr?   B   s    #s 
 	YWXXX}}	C		 1ffIA 1ff{{zzr   list[DimEntry]c                    t          | ||          }g }|                                s|                    |           n)| D ]&}|                    t          |||                     '|S )z<Convert dimension specification to list of DimEntry objects.)r?   is_noneappend)r   r6   r8   deresultds         r   
_wrap_dimsrG   S   sr    	3g	&	&BF::<< 7b 	7 	7AMM)AtW556666Mr   wrapperr+   r,   c                   |st          d          |                    | j                  }|=| j        t	          |          k     r%| j        dz   }|t	          |          k     r||         }|t          j        |d         dd          s | j        |i |S t          j	                  5 }j
        J |                    j
        j	                   t          |          }t          j
                  |d<    | j        |i |}|                    |j                  cddd           S # 1 swxY w Y   t          j        |d                   s | j        |i |S d}| j        re|                    d          }	|	=| j        t	          |          k     r%| j        dz   }
|
t	          |          k     r||
         }	|	t%          |	          }                                }t)          |||          }g }dgt	          j	                  z  }|D ]}d}t+          j	                  D ]\  }}||k    r|} n|kt+          j	                  D ].\  }}t-          |d	          r|                    |          r|} n/|&d
 j	        D             }t          d| d|           d||<   |                    |           g | j        r:|s8t+          j	                  D ]"\  }}||         s                    |           #nj	        dd         t	          |          dk    r	|d         }nt3          |          }t          |          }|                                }j        J t          j                  |d<   | j        |v r||| j        <   n1| j        dz   }|t	          |          k     rt          |          }|||<    | j        |i |}dfd}t9          ||          S )zJ
    This is the core method that handles dimension-aware operations.
    z%Expected at least one argument (self)Nr   r   TF)ensure_batchedensure_presentr8   matchesc                ,    g | ]}t          |          S r   )r   ).0levels     r   
<listcomp>z&patched_dim_method.<locals>.<listcomp>   s    BBBUc%jjBBBr   zTensor with dimensions z does not contain objr   r   c                    t          | t          j                  r"ddlm} |                    | j                  S | S )Nr   )Tensor)r<   torchrS   r   from_positional
has_device)rQ   rS   info
new_levelss     r   wrap_resultz'patched_dim_method.<locals>.wrap_result   sI    c5<(( 	L      ))#z4?KKK
r   )rQ   r   r   r   )r=   getr   r$   lenr   creater   r
   levelsbatchedtensorinplace_update_layerslistr   from_batchedrV   r'   r%   r9   r6   rG   	enumeratehasattrrL   rC   tuplecopyr   r   )rH   r+   r,   dim_argdim_idxguardnew_argsrE   r8   keepdim_argkeepdim_idxr6   dimsdim_indicesseenrF   midxr>   rO   
level_strs
py_indices
new_kwargsrY   rW   rX   s                          @@r   patched_dim_methodrs   _   s     B@AAA jj)**G7-D		99$q(SYY7mG  aeTTT 	17<0000T[)) 	?U%111''(:DKHHHDzzH,T-?@@HQK!W\86v66F%%fdo>>	? 	? 	? 	? 	? 	? 	? 	? 	? 	? 	? 	? 	? 	? 	? 	? T!W%%D -w|T,V,,, G~ (jj++7#9CII#E#E!014KSYY&&";/";''G 99;;DgtW--D  K7S%%%D ! !!$+.. 	 	HAuzz  <%dk22  55),, q1A1A DE|BBdkBBB
 OjOOAOO   T
4     J~ $g $!$+.. 	) 	)HAu7 )!!%(((	) [^
 ;1%a.

;''
 DzzHJ;"""$T[11HQK :%%'1
7#$$$q(S]]""H~~H *HW W\82z22F       K(((s   /A7D33D7:D7r   r   r$   Optional[int]r%   r   Optional[str]r&   Optional[bool]r'   c                    |pd}t          | t          |          }|||_        |||_        |||_        |||_        |                                S )a  
    Wrap a PyTorch function to support first-class dimensions.

    Args:
        orig: Original function to wrap
        dim_offset: Offset for dimension argument (default: 0)
        keepdim_offset: Offset for keepdim argument (default: 1)
        dim_name: Name of dimension parameter (default: "dim")
        single_dim: Whether function takes single dimension (default: False)
        reduce: Whether function reduces dimensions (default: True)
    r   )r   rs   r$   r%   r&   r'   r3   )r   r$   r%   r   r&   r'   rH   s          r   _wraprx      si    &  5Hd$6AAG'!!/'r   r   functypesrd   Optional[dict]c                F    |i }ddl m} |                    ||||          S )z@
    Handle __torch_function__ calls for wrapped operators.
    Nr   )_Tensor)r   r}   __torch_function__)rH   ry   rz   r+   r,   r}   s         r   call_torch_functionr      s>     ~  %%dE4@@@r   )r   r   r   r   )F)r   r   r6   r7   r8   r9   r   r	   )r   r   r6   r7   r8   r9   r   r@   )rH   r   r+   r   r,   r   r   r   )NNNNN)r   r   r$   rt   r%   rt   r   ru   r&   rv   r'   rv   r   r   )r   N)rH   r   ry   r   rz   rd   r+   rd   r,   r{   r   r   )r   
__future__r   r1   typingr   r   r   rT   torch.utils._pytreer   
_dim_entryr	   _enable_all_layersr
   _tensor_infor   collections.abcr   r   r   r?   rG   rs   rx   r   r   r   r   <module>r      s    # " " " " "     / / / / / / / / / /  ( ( ( ( ( (             / / / / / / $ $ $ $ $ $  )((((((   
$ $ $ $ $ $ $ $N    "	 	 	 	 	u) u) u) u)t !%$("!%!         N !A A A A A A Ar   