
    xKgR                        d dl Z d dlZd dl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 d dlmZmZmZmZmZ d dlmZmZ d dlmZ d d	lmZ d d
lmZ d dlmZ d dlm Z   G d dejB                        Z" G d dejB                        Z# ejH                  ejJ                  e"        ejH                  ejL                  e#        ejH                  ejN                  ejP                         d Z)dZ*d Z+e G d de,             Z-d Z.d Z/d Z0d Z1 G d dejd                        Z3d Z4 G d de5      Z6ejn                   G d d ejp                               Z9e6jt                  jw                  ejJ                        d!        Z<e6jt                  j{                  ejJ                        d"        Z>d# Z?e6jt                  j                  ejN                   ej                  ej                              d$        ZCy)%    N)OrderedDict)Sequence)ir)njit)cgutilserrorsimputilstypesutils)default_managermodels)
cpu_target)	templates)as_numba_type)disable_pickling)_boxc                        e Zd Z fdZ xZS )InstanceModelc                     t        j                  |      }t        j                  dt        |      z         }dt        j                  |      fdt        j
                  |      fg}t        t        | #  |||       y )NzOpaque.meminfodata)	r
   ClassDataTypeOpaquestrMemInfoPointerCPointersuperr   __init__)selfdmmfe_typcls_data_tydtypemembers	__class__s         d/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/numba/experimental/jitclass/base.pyr   zInstanceModel.__init__   sm    ))&1
 Y[)99:,,U34U^^K01
 	mT+CA    __name__
__module____qualname__r   __classcell__r%   s   @r&   r   r      s    B Br'   r   c                        e Zd Z fdZ xZS )InstanceDataModelc                     |j                   }|j                  j                         D cg c]  \  }}t        |      |f }}}t        t
        |   |||       y c c}}w N)
class_typestructitems_mangle_attrr   r/   r   )r   r    r!   clstykvr$   r%   s          r&   r   zInstanceDataModel.__init__&   sX    !!49LL4F4F4HI4HDAqLOQ'4HI/VWE Js   Ar(   r-   s   @r&   r/   r/   %   s    F Fr'   r/   c                     d| z   S )zZ
    Mangle attributes.
    The resulting name does not startswith an underscore '_'.
    m_ )names    r&   r5   r5   1   s    
 $;r'   z3
def ctor({args}):
    return __numba_cls_({args})
c                    | j                   }g }|j                         D ]`  \  }}|j                  |j                  z  |j                  k(  r|j	                  |       >d|j                  z  }t        j                  |       |S )zI
    Returns list of positional and keyword argument names in order.
    z(%s argument type unsupported in jitclass)
parametersr4   kindPOSITIONAL_OR_KEYWORDappendr   UnsupportedError)fn_sigparamsargsr7   r8   msgs         r&   _getargsrG   B   sv     FD1FFQ,,,1H1HHKKN<qvvEC))#..  Kr'   c                   (    e Zd ZdZd Zd Zd Zd Zy)JitClassTypez#
    The type of any jitclass.
    c                     t        |      dk7  rt        d      |\  }t        |t              rt        d      d|v sJ d       t        j                  | |||      }|j                          |S )N   z must have exactly one base classzcannot subclass from a jitclassr2   zmissing "class_type" attr)len	TypeError
isinstancerI   type__new__	_set_init)clsr<   basesdctbaseoutclss         r&   rP   zJitClassType.__new__V   so    u:?>??dL)=>>s"?$??"c44r'   c                 2   | j                   j                  j                  d   }t        j                  |      }t        |      dd }|| _        t        j                  dj                  |            }d| i}t        ||       |d   }t        |      | _        y)z
        Generate a wrapper for calling the constructor from pure Python.
        Note the wrapper will only accept positional arguments.
        r   rK   N, rE   __numba_cls_ctor)r2   instance_typemethodsr   pysignaturerG   	_ctor_sig_ctor_templateformatjoinexecr   _ctor)rR   initinit_sigrE   ctor_sourceglblsr[   s          r&   rQ   zJitClassType._set_inita   s    
 ~~++33J?$$T* !!"% $++4+A%[% V}J	r'   c                 |    t        |t        j                        r"|j                  j                  | j                  u S y)NF)rN   r   Box_numba_type_r2   )rR   instances     r&   __instancecheck__zJitClassType.__instancecheck__r   s.    h)((33s~~EEr'   c                      | j                   j                  d g|i |}|j                           | j                  |j                  dd  i |j
                  S )NrK   )r_   bindapply_defaultsrd   rE   kwargs)rR   rE   rq   ro   s       r&   __call__zJitClassType.__call__w   sT     "s}}!!$888syy$))AB-74;;77r'   N)r)   r*   r+   __doc__rP   rQ   rm   rr   r;   r'   r&   rI   rI   Q   s    	"
8r'   rI   c                     | j                         D ]K  \  }}t        |t              st        d|      t        |t        j
                        r?t        d|       y )Nz!spec keys should be strings, got z0spec values should be Numba type instances, got )r4   rN   r   rM   r
   Type)specr7   r8   s      r&   _validate_specrw      sQ    

1!S!QHII!UZZ( # $ $	 r'   c                     t               }|j                         D ]4  \  }}|j                  d      r|j                  d      sd| z   |z   }|||<   6 |S )zB
    Apply the same changes to dunder names as CPython would.
    ___)r   r4   
startswithendswith)clsnamerv   outr7   r8   s        r&   _fix_up_private_attrr      sT     -C

1<<ajj&6g!AA  Jr'   c                 F    t        |dd      }|r| j                  |       yy)zC
    Add the required libs for the callable to allow inlining.
    libsr;   N)getattradd_linking_libs)contextcallr   s      r&   _add_linking_libsr      s(     4$D  & r'   c                 p   |t               }nt        |t              rt        |      }t        j                  |       j                         D ]  \  }}||vst        |      ||<    t        |       t        | j                  |      }i }t        t        j                  |             D ]  }|j                  |j                          i i i i f\  }}	}
}|j                         D ]V  \  }}t        |t        j                         r|||<   &t        |t"              r||	|<   <t        |t$              r||
|<   R|||<   X t'        |      t'        |	      z  t'        |
      z  t'        |      z  }|r)t)        dj+                  dj-                  |                  |j/                  dd      }t1        |       |r;d}dj-                  |j3                               }t5        |j+                  |            |	j                         D ]+  \  }}|j6                  t5        dj+                  |             |j                         D ci c]  \  }}|t9        |       }}}i }|	j                         D ]T  \  }}i }|j:                  rt9        |j:                        |d<   |j<                  rt9        |j<                        |d<   |||<   V |
j                         D ci c]  \  }}|t9        |j>                         }}} || t@        ||||      }tC        ||	      }|j                  |       tE        | j                  | f|      } tF        jH                  }|jK                  | |       tF        jL                  } ||||      jO                          t        jN                  | |jP                         | S c c}}w c c}}w )
a$  
    Internal function to create a jitclass.

    Args
    ----
    cls: the original class object (used as the prototype)
    spec: the structural specification contains the field types.
    class_ctor: the numba type to represent the jitclass
    builder: the internal jitclass builder
    zname shadowing: {0}rX   rs    z(class members are not yet supported: {0}zdeleter is not supported: {0}getset)r2   rs   ))r   rN   r   ptget_type_hintsr4   r   rw   r   r)   reversedinspectgetmroupdate__dict__pytypesFunctionTypepropertystaticmethodr   	NameErrorra   rb   pop_drop_ignored_attrskeysrM   fdelr   fgetfset__func__ConstructorTemplatedictrI   r   typing_contextinsert_globaltarget_contextregisterr\   )rR   rv   
class_ctorbuilderattrpy_typeclsdctbaseclsr]   propsstatic_methodsothersr7   r8   shadowed	docstringrF   r$   jit_methods	jit_propsrT   jit_static_methodsr2   jit_class_dct	typingctx	targetctxs                             r&   register_class_typer      sW    |}	D(	#4  **3/557gt&w/DJ 8 4  d3D FGNN3/0g&&' 1 .0R^*GUNF1a--.GAJ8$E!H<( !N1F1I  Gs5z)C,??3t9LH-44TYYx5HIJJ

9b)I8))FKKM*

7+,,166;BB1EFF  +2--/:/$!Q1d1g:/K:I166affCJ66affCJ	!  )7(<(<(>@(>14

(>  @ J J	BM+,
s||cV]
;C ))IC, ))IJ	9-6683
 8 89JI ;@s   N, N2c                       e Zd ZdZd Zy)r   z8
    Base class for jitclass constructor templates.
    c                    | j                   j                  }|j                  d   }|j                         f|z   }t	        j
                  |      }|j                  | j                  ||      }t        |j                  t        j                        s#t        j                  d|j                   d      t        j                  |g|j                  dd   }|S )Nr   z$__init__() should return None, not ''rK   )keyr\   r   get_reference_typer
   
Dispatcherget_call_typer   rN   return_typeNoneTyper   NumbaTypeErrorr   	signaturerE   )	r   rE   kwsr\   r[   	boundargs	disp_typesigr~   s	            r&   genericzConstructorTemplate.generic  s    ..((4"5579D@	$$T*	%%dllIsC#//5>>:''6s6GqIK K !!-?#((12,?
r'   N)r)   r*   r+   rs   r   r;   r'   r&   r   r     s    r'   r   c                    t        g d      }d| v r|j                  d       | j                         D ]f  \  }}t        |t        j
                  t        j                  f      r|j                  |       Bt        |dd       t        u sV|j                  |       h d| v r| d   |j                  d       |D ]  }| |=  y )N)__weakref__r*   r   __annotations____objclass____hash__)	r   addr4   rN   r   BuiltinFunctionTypeBuiltinMethodTyper   object)rT   dropr7   r8   s       r&   r   r     s      D C"#		1a'55!335 6HHQKQ-7HHQK  SS_4F r'   c                   Z    e Zd ZdZ ej
                  d      Z e       Zd Z	d Z
d Zd Zy)ClassBuilderz
    A jitclass builder for a mutable jitclass.  This will register
    typing and implementation hooks to the given typing and target contexts.
    zjitclass builderc                 .    || _         || _        || _        y r1   )r2   r   r   )r   r2   r   r   s       r&   r   zClassBuilder.__init__:  s    $""r'   c                     | j                  | j                  | j                  j                         | j                  j                  | j                         y)z7
        Register to the frontend and backend.
        N)_register_methodsclass_impl_registryr2   r\   r   install_registry)r   s    r&   r   zClassBuilder.register?  sA    
 	t77#<<	> 	''(@(@Ar'   c                     t        |j                        t        |j                        z   }|D ]>  }|| j                  vs| j	                  ||       | j                  j                  |       @ y)z
        Register method implementations.
        This simply registers that the method names are valid methods.  Inside
        of imp() below we retrieve the actual method to run from the type of
        the receiver argument (i.e. self).
        N)listr   r   implemented_methods_implement_methodr   )r   registryr\   to_registermeths        r&   r   zClassBuilder._register_methodsJ  se     =4451123D
 4333&&x6((,,T2  r'   c                    fdfd}j                  d      }|dv r	 ||       y  |j                  t        j                  ft        j                  t        j                  t        j
                                             y )Nc                      fd} | S )Nc                    |j                   d   }	|j                  v r|j                  	   }nA	|j                  v r3|j                  	   }|j                  |j                   dd        }|dd  }t	        j
                        }| j                  ||      } |||      }t        | |       t        j                  | ||j                  |      S )Nr   rK   rY   )rE   r   r   replacer
   r   get_functionr   r	   impl_ret_new_refr   )
r   r   r   rE   r\   methodr   r   r~   r   s
            r&   impz<ClassBuilder._implement_method.<locals>.get_imp.<locals>.imp_  s     #=444*66t<F]===*==dCF ++388AB<+8C8D!,,V4	++Is;7D)!'4000'14#G Gr'   r;   )r   r   s    r&   get_impz/ClassBuilder._implement_method.<locals>.get_imp^  s    G$ Jr'   c                    d| z  t        t        |       }t        j                  |       G fddt        j                               } t        j                  t        j                  ft        j                  t        j                  t        j                                              t        j                  |t        j                  t        j                  t        j                                             y )Nz__%s__c                       e Zd Z fdZy)KClassBuilder._implement_method.<locals>._getsetitem_gen.<locals>.GetSetItemc                     |d   }t        |t        j                        rR|j                  v rC|j                     }t        j                  |      }|j                  | j                  ||      }|S y y )Nr   )rN   r
   ClassInstanceTyper   r   r   r   )r   rE   r   rl   r   r   r   _dunder_meths          r&   r   zSClassBuilder._implement_method.<locals>._getsetitem_gen.<locals>.GetSetItem.genericy  ss    #AwH!(E,C,CD(H,@,@@'33LA$)$4$4T$:	'55dllD#N"
	 A Er'   N)r)   r*   r+   r   )r   s   r&   
GetSetItemr   w  s    #r'   r   )r   operatorr   infer_globalAbstractTemplater	   lower_builtinr
   r   VarArgAny)getsetopr   r   r   s      @r&   _getsetitem_genz7ClassBuilder._implement_method.<locals>._getsetitem_gens  s    #f,L6*B##B'#Y77 # (#<H""E$;$;\#J#(#:#:#(<<		#:<<CIG<H""2#(#:#:#(<<		#:<<CIGr'   rz   )getitemsetitem)striplowerr
   r   r   r   )r   r   r   r   dunder_strippedr   s     `  @r&   r   zClassBuilder._implement_method\  sn    	*	G0 **S/44O,4HNNE33T: 22 <<		244;I?r'   N)r)   r*   r+   rs   r	   Registryr   r   r   r   r   r   r   r;   r'   r&   r   r   2  s:     ,(++,>?%#
	B3$5?r'   r   c                   *    e Zd Zej                  Zd Zy)ClassAttributec                    	 j                   v rj                      S j                  v rXj                     }t        j                  |      	 G 	 fddt        j
                        }t        j                  |      S j                  v rXj                     }t        j                  |      	 G 	 fddt        j
                        }t        j                  |      S j                  v rSj                     }|d   }t        j                  |      		j                   j                  fi       }|j                  S y )Nc                   :    e Zd ZW j                  W  fZfdZy)6ClassAttribute.generic_resolve.<locals>.MethodTemplatec                 |    ft        |      z   }j                  | j                  ||      }|j                         S r1   )tupler   r   	as_methodr   rE   r   r   r   rl   s       r&   r   z>ClassAttribute.generic_resolve.<locals>.MethodTemplate.generic  s7    $;t4D#11$,,cJC==?*r'   Nr)   r*   r+   r   r   r   r   rl   r   s   r&   MethodTemplater    s    xx&+r'   r  c                   :    e Zd ZW j                  W  fZfdZy)<ClassAttribute.generic_resolve.<locals>.StaticMethodTemplatec                 b    j                  | j                  ||      }|j                        S )N)recvr)r   r   r   r  s       r&   r   zDClassAttribute.generic_resolve.<locals>.StaticMethodTemplate.generic  s0     $11$,,cJC
 ;;X;66r'   Nr  r  s   r&   StaticMethodTemplater
    s    xx&7r'   r  r   )r3   r   r
   r   r   r   BoundFunctionr   r   r   r   r   )
r   rl   r   r   r  r  impdctgetterr   r   s
   ```      @r&   generic_resolvezClassAttribute.generic_resolve  s3   8??"??4((X)))''-D((.I+ +!;!; + &&~x@@X000..t4D((.I7 7y'A'A 7 &&';XFFX'''''-FE]F((0I))$,,RHC??" (r'   N)r)   r*   r+   r
   r   r   r  r;   r'   r&   r   r     s    

!
!C.#r'   r   c                    ||j                   v rz| j                  |||      }|j                  }| j                  ||j	                         |      }t        j                  | ||j                   |   t        |t        |                  S ||j                  v r|j                  |   d   }t        j                  d|      }	t        j                  |      }
|
j                  | j                  |gi       }	| j!                  |
|	      } |||g      }t#        | |       t        j$                  | ||	j&                  |      S t)        dj+                  |            )z4
    Generic getattr() for @jitclass instances.
    valuerefr   Nattribute {0!r} not implemented)r3   make_helperr   make_data_helperget_data_typer	   impl_ret_borrowedr   r5   r   r   r   r
   r   r   r   r   r   r   r   NotImplementedErrorra   )r   r   typr  r   instdata_pointerr   r  r   
dispatcherr   r~   s                r&   get_attr_implr!    sD   
 szz""7Cu"=yy''1B1B1D,8 ( :))'7*-**T*:*1$T8J*KM 	M 
	t$U+!!$,%%f-
&&w'='=ubI##J47UG$'4((('3??CPP
?FFtL
MMr'   c                    |j                   \  }}|\  }}||j                  v r| j                  |||      }	|	j                  }
| j	                  ||j                         |
      }|j                  |   }t        |t        |            }t        |t        |      |       | j                  j                  |||       | j                  j                  |||       y||j                  v rp|j                  |   d   }t        j                  |      }|j                  | j                   ||fi       }| j#                  ||      } ||||f       t%        | |       yt'        dj)                  |            )z4
    Generic setattr() for @jitclass instances.
    r  r  r   r  N)rE   r3   r  r   r  r  r   r5   setattrnrtincrefdecrefr   r
   r   r   r   r   r   r  ra   )r   r   r   rE   r   r  valtytargetvalr  data_ptrr   	attr_typeoldvaluesetterr   r   s                    r&   set_attr_implr.    sb   
 JCKFCszz""7Cv">99''1B1B1D,4 ( 6 JJt$	4d!34 	l4(#.7Is3 	7Ix8		t$U+$$V,	%%g&<&<'*ElB8##Is3Wvsm$'4(!-44T:< 	<r'   c                    | j                  t        j                        }| j                  t        j                        }t	        j
                  t	        j                         |||g      }dj                  |j                        }t        j                  |||      }|j                  rt	        j                  |j                               }|j                         }	| j                  |	      }
|j                  |j                   d   |
j#                               }| j%                  ||	|      }| j&                  j)                  ||	|j+                                |j-                          |S )Nz	_Dtor.{0}r   r  )get_value_typer
   voidptruintpllvmirr   VoidTypera   r<   r   get_or_insert_functionis_declaration	IRBuilderappend_basic_blockr  bitcastrE   
as_pointerr  r$  r&  	_getvalueret_void)r   moduler\   	llvoidptrllsize
dtor_ftypefnamedtor_fnr   alloc_fe_type
alloc_typeptrr   s                r&   imp_dtorrF    s    &&u}}5I##EKK0F$$V__%6&/%CEJ }112E,,VZGG""7#=#=#?@%335++M:
oogll1oz/D/D/FG""7Ms"C7M4>>3CDNr'   c           	         |j                   }| j                  |j                               }| j                  |      }| j                  j	                  || j                  t        j                  |      t        | |j                  |            }| j                  j                  ||      }|j                  ||j                               }|j                  t        j                  |      |       | j!                  ||      }	||	_        ||	_        |j                   f|j&                  z   }
|j(                  d   }t        j*                  |      }| j-                  |t        j.                  |
       }t1        | |       |	j3                         gt5        |      z   } |||       |	j3                         }t7        j8                  | |||      S )z7
    Generic constructor (__new__) for jitclasses.
    r   )r   r  get_abi_sizeofr$  meminfo_alloc_dtorget_constantr
   r2  rF  r=  meminfo_datar9  r:  storer   get_null_valuer  r   r   rE   r   r   r   voidr   r;  r   r	   r   )r   r   r   rE   inst_typrD  
alloc_sizer   r  inst_structrf   re   r   r   realargsrets                   r&   	ctor_implrT  &  s    H&&x'='='?@J''
3Jkk,,U[[*5'..(3G
 ;;++GW=L??<#-#8#8#:<L MM'((4  %%gx8K!K#K !CHH,H
+D  &I	5::x+@ADgt$%%'(4:5H( 


!C$$WgxEEr'   )Dr   r   r
   r   typingr   collectionsr   collections.abcr   llvmliter   r3  numbar   
numba.corer   r   r	   r   numba.core.datamodelr   r   numba.core.registryr   numba.core.typingr   numba.core.typing.asnumbatyper   numba.core.serializer   numba.experimental.jitclassr   StructModelr   r/   r   r   r   	ClassTypeOpaqueModelr5   r`   rG   rO   rI   rw   r   r   r   r   r   r   r   r   infer_getattrAttributeTemplater   r   lower_getattr_genericr!  lower_setattr_genericr.  rF  r   r   r   rT  r;   r'   r&   <module>rh     s       # $ !  > > 8 * ' 7 1 ,BF&& BF** F   00- @   ,,.? @   &*<*< = *84 *8 *8`$	'_D)44 ,4_?6 _?D 1#Y00 1# 1#h !!778O8OPN QN6 !!778O8OP$< Q$<N2 !!''(4UYY(?A(FA(Fr'   