
    sh                     x    S SK Jr  S SKJrJr   " S S\5      r " S S\5      rS rSr	S	r
S
rSr " S S\5      rg)    )deque)typescgutilsc                   :    \ rS rSrSrS rS rS
S jrS rS r	S	r
g)
DataPacker   z
A helper to pack a number of typed arguments into a data structure.
Omitted arguments (i.e. values with the type `Omitted`) are automatically
skipped.
c                    Xl         X l        U Vs/ s H  o1R                  U5      PM     snU l        / U l        / U l        [        U5       Hw  u  pC[        U[        R                  5      (       a  M&  U R                  R                  U5        U R
                  R                  U R                  U   R                  5       5        My     g s  snf N)_dmm	_fe_typeslookup_models	_pack_map	_be_types	enumerate
isinstancer   Omittedappendget_data_type)selfdmmfe_typestyis        o/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/numba/core/datamodel/packer.py__init__DataPacker.__init__   s    	!19:2

2:x(EAb%--00%%a(%%dll1o&C&C&EF )	 ;s   Cc                     U R                    Vs/ s H$  nU R                  U   R                  XU   5      PM&     nn[        R                  " X5      $ s  snf )z5
Return the given values packed as a data structure.
)r   r   as_datar   make_anonymous_struct)r   buildervaluesr   elemss        r   r   DataPacker.as_data   sU    
 ..*(Q a(()<( 	 *,,W<<*s   +ANc                    / n[        U R                  5       Hd  u  pV[        R                  " XSU5      nU R                  U   R                  X5      nUc"  UR                  U R                  U   U45        M`  XU'   Mf     U$ Nr   )r   r   r   gep_inboundsr   load_from_data_pointerr   r   )	r   r!   ptrformal_listresr   i_formalelem_ptrvals	            r   _do_loadDataPacker._do_load#   sx    $T^^4KA++G!Q?H,,x(??RC"

DNN84c:;(+H% 5 
    c                 $    U R                  X5      $ )z;
Load the packed values and return a (type, value) tuples.
r/   )r   r!   r)   s      r   loadDataPacker.load.   s     }}W**r1   c                 (    U R                  XU5        g)zk
Load the packed values into a sequence indexed by formal
argument number (skipping any Omitted position).
Nr3   )r   r!   r)   r*   s       r   	load_intoDataPacker.load_into4   s    
 	gK0r1   )r   r   r   r   r   r
   )__name__
__module____qualname____firstlineno____doc__r   r   r/   r4   r7   __static_attributes__ r1   r   r   r      s!    
G=	+1r1   r   c                   J    \ rS rSrSrS rS rS rS rSS jr	\
S 5       rS	rg
)	ArgPacker<   a  
Compute the position for each high-level typed argument.
It flattens every composite argument into primitive types.
It maintains a position map for unflattening the arguments.

Since struct (esp. nested struct) have specific ABI requirements (e.g.
alignment, pointer address-space, ...) in different architecture (e.g.
OpenCL, CUDA), flattening composite argument types simplifes the call
setup from the Python side.  Functions are receiving simple primitive
types and there are only a handful of these.
c                 \   Xl         X l        [        U5      U l        / U l        / nU HX  nU R                   R                  U5      nU R                  R                  U5        UR                  UR                  5       5        MZ     [        U5      U l	        [        [        U5      5      U l        g r
   )r   _fe_argslen_nargs_dm_argsr   r   get_argument_type_Unflattener_unflattenerlist_flatten_be_args)r   r   fe_argsargtysr   dms         r   r   ArgPacker.__init__I   s    	'lB!!"%BMM  $MM"..01  )0Xf-.r1   c                 4   [        U5      U R                  :w  a#  [        SU R                  [        U5      4-  5      eU(       d  g[        U R                  U5       VVs/ s H  u  p4UR                  X5      PM     nnn[        [        U5      5      nU$ s  snnf )z$Flatten all argument values
        z+invalid number of args: expected %d, got %dr?   )rE   rF   	TypeErrorziprG   as_argumenttuplerL   )r   r!   r"   rP   r.   argss         r   as_argumentsArgPacker.as_argumentsW   s     v;$++%I#{{CK89 : :   #4==&99GB w,9 	  Xd^$s   Bc                     U R                   R                  U5      n[        U R                  U5       VVs/ s H  u  pEUR	                  X5      PM     nnnU$ s  snnf )z&Unflatten all argument values
        )rJ   	unflattenrT   rG   from_argument)r   r!   rW   valtreerP   r.   r"   s          r   from_argumentsArgPacker.from_argumentsh   s^     ##--d3!$T]]G!<!<gb ""70!< 	  	s   Ac                     U R                   R                  U5      n[        X25       H  u  pEU R                  XE5        M     g)z9Assign names for each flattened argument values.
        N)rJ   r[   rT   _assign_names)r   rW   namesr]   avalanames         r   assign_namesArgPacker.assign_namess   s9     ##--d3w.KDt+ /r1   c                    [        U[        [        45      (       a(  [        U5       H  u  pEU R	                  XRX44-   S9  M     g SR                  [        [        U5      5      nX&/nSR                  [        [        U5      5      Ul
        g )N)depth.)r   rV   rK   r   ra   joinmapstrfilterboolname)r   val_or_nestedro   rh   posrc   postfixpartss           r   ra   ArgPacker._assign_names{   sp    meT]33&}5	""4UV^"D 6 hhs3/GOE!$&u*=!>Mr1   c                 :    [        S U R                   5       5      $ )zLReturn a list of LLVM types that are results of flattening
composite types.
c              3   4   #    U  H  oS :w  d  M
  Uv   M     g7f)r?   Nr?   ).0r   s     r   	<genexpr>+ArgPacker.argument_types.<locals>.<genexpr>   s     <-B8RR-s   		)rV   rM   )r   s    r   argument_typesArgPacker.argument_types   s    
 <$--<<<r1   )rM   rG   r   rD   rF   rJ   N)r?   )r9   r:   r;   r<   r=   r   rX   r^   re   ra   propertyrz   r>   r?   r1   r   rA   rA   <   s4    
/"	,? = =r1   rA   c                     ^ U4S jmT" U 5      $ )z+
Flatten nested iterable of (tuple, list).
c              3      >#    U  H7  n[        U[        [        45      (       a  T" U5       H  nUv   M	     M3  Uv   M9     g 7fr
   )r   rV   rK   )iterabler   jrecs      r   r   _flatten.<locals>.rec   s;     A!eT]++QAG    s   ?Ar?   )r   r   s    @r   rL   rL      s     x=r1               c                   *    \ rS rSrSrS rS rS rSrg)rI      z
An object used to unflatten nested sequences after a given pattern
(an arbitrarily nested sequence).
The pattern shows the nested sequence shape desired when unflattening;
the values it contains are irrelevant.
c                 0    U R                  U5      U l        g r
   )_build_unflatten_code_code)r   patterns     r   r   _Unflattener.__init__   s    //8
r1   c                 ,   ^^ / mUU4S jmT" U5        T$ )zjBuild the unflatten opcode sequence for the given *iterable* structure
(an iterable of nested sequences).
c                 ,  > U  H  n[        U[        [        45      (       aZ  [        U5      S:  a4  TR	                  [
        5        T" U5        TR	                  [        5        Ma  TR	                  [        5        Mx  TR	                  [        5        M     g r&   )	r   rV   rK   rE   r   
_PUSH_LIST_POP_APPEND_EMPTY_TUPLE_APPEND_NEXT_VALUE)r   r   coder   s     r   r   /_Unflattener._build_unflatten_code.<locals>.rec   sb    a%//1vzJ/AD)$78KK 23 r1   r?   )r   r   r   r   s     @@r   r   "_Unflattener._build_unflatten_code   s     
	4 	Hr1   c                    [        U5      n/ nUn/ nU R                   H  nU[        L a)  UR                  U5        UR                  / 5        US   nM5  U[        L a!  UR                  UR                  5       5        M_  U[        L a  UR                  S5        M{  U[        L d  M  UR                  5       nM     U(       a   U5       eU(       a   U5       eU$ )z*Rebuild a nested tuple structure.
        r?   )	r   r   r   r   r   popleftr   r   pop)r   flatitervalsr+   curstackops          r   r[   _Unflattener.unflatten   s     X**BZS!

2"g))

4<<>***

2tiik  %yx
r1   )r   N)	r9   r:   r;   r<   r=   r   r   r[   r>   r?   r1   r   rI   rI      s    9(r1   rI   N)collectionsr   
numba.corer   r   objectr   rA   rL   r   r   r   r   rI   r?   r1   r   <module>r      sP     %21 21jM= M=` 
  66 6r1   