
    J/PhS                        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j!                  Z" G d dej!                  Z# ej$        ej%        e"            ej$        ej&        e#            ej$        ej'        ej(                   d Z)dZ*d Z+e G d de,                      Z-d Z.d Z/d Z0d Z1 G d dej2                  Z3d Z4 G d de5          Z6ej7         G d d ej8                              Z9e6j:        ;                    ej%                  d!             Z<e6j:        =                    ej%                  d"             Z>d# Z?e6j:        @                    ej'         ejA        ejB                            d$             ZCdS )%    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          |                               |||           d S )NzOpaque.meminfodata)	r   ClassDataTypeOpaquestrMemInfoPointerCPointersuperr   __init__)selfdmmfe_typcls_data_tydtypemembers	__class__s         `/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/numba/experimental/jitclass/base.pyr   zInstanceModel.__init__   s    )&11
 Y[)9)99::,U334U^K001
 	mT""++CAAAAA    __name__
__module____qualname__r   __classcell__r&   s   @r'   r   r      sA        B B B B B B B B Br(   r   c                        e Zd Z fdZ xZS )InstanceDataModelc                     |j         }d |j                                        D             }t          t          |                               |||           d S )Nc                 6    g | ]\  }}t          |          |fS  )_mangle_attr.0kvs      r'   
<listcomp>z.InstanceDataModel.__init__.<locals>.<listcomp>(   s'    IIIDAqLOOQ'IIIr(   )
class_typestructitemsr   r0   r   )r    r!   r"   clstyr%   r&   s        r'   r   zInstanceDataModel.__init__&   sU    !IIEL4F4F4H4HIII&&//VWEEEEEr(   r)   r.   s   @r'   r0   r0   %   sA        F F F F F F F F Fr(   r0   c                     d| z   S )zZ
    Mangle attributes.
    The resulting name does not startswith an underscore '_'.
    m_r3   )names    r'   r4   r4   1   s    
 $;r(   z3
def ctor({args}):
    return __numba_cls_({args})
c                     | j         }g }|                                D ]P\  }}|j        |j        z  |j        k    r|                    |           3d|j        z  }t          j        |          |S )zI
    Returns list of positional and keyword argument names in order.
    z(%s argument type unsupported in jitclass)
parametersr<   kindPOSITIONAL_OR_KEYWORDappendr	   UnsupportedError)fn_sigparamsargsr7   r8   msgs         r'   _getargsrK   B   sw     FD / /1FQ,,1HHHKKNNNN<qvEC)#...Kr(   c                   *    e Zd ZdZd Zd Zd Zd ZdS )JitClassTypez#
    The type of any jitclass.
    c                    t          |          dk    rt          d          |\  }t          |t                    rt          d          d|v s
J d            t                              | |||          }|                                 |S )N   z must have exactly one base classzcannot subclass from a jitclassr:   zmissing "class_type" attr)len	TypeError
isinstancerM   type__new__	_set_init)clsr@   basesdctbaseoutclss         r'   rT   zJitClassType.__new__V   s    u::??>???dL)) 	?=>>>s"""$?"""c444r(   c                 T   | j         j        j        d         }t          j        |          }t          |          dd         }|| _        t                              d	                    |                    }d| i}t          ||           |d         }t          |          | _        dS )z
        Generate a wrapper for calling the constructor from pure Python.
        Note the wrapper will only accept positional arguments.
        r   rO   N, rI   __numba_cls_ctor)r:   instance_typemethodsr   pysignaturerK   	_ctor_sig_ctor_templateformatjoinexecr   _ctor)rV   initinit_sigrI   ctor_sourceglblsr_   s          r'   rU   zJitClassType._set_inita   s    
 ~+3J?$T** !!!""% $++4+AA%[%   V}JJ			r(   c                 `    t          |t          j                  r|j        j        | j        u S dS )NF)rR   r   Box_numba_type_r:   )rV   instances     r'   __instancecheck__zJitClassType.__instancecheck__r   s/    h)) 	F(3s~EEur(   c                      | j         j        d g|R i |}|                                  | j        |j        dd          i |j        S )NrO   )rc   bindapply_defaultsrh   rI   kwargs)rV   rI   ru   rs   s       r'   __call__zJitClassType.__call__w   s]     "s}!$888888sy$)ABB-74;777r(   N)r*   r+   r,   __doc__rT   rU   rq   rv   r3   r(   r'   rM   rM   Q   sZ         	 	 	  "  
8 8 8 8 8r(   rM   c                     |                                  D ]X\  }}t          |t                    st          d|          t          |t          j                  st          d|          Yd S )Nz!spec keys should be strings, got z0spec values should be Numba type instances, got )r<   rR   r   rQ   r   Type)specr7   r8   s      r'   _validate_specr{      s    

 $ $1!S!! 	J)QQHIII!UZ(( 	$) q# $ $ $	$$ $r(   c                     t                      }|                                D ]<\  }}|                    d          r|                    d          sd| z   |z   }|||<   =|S )zB
    Apply the same changes to dunder names as CPython would.
    ___)r   r<   
startswithendswith)clsnamerz   outr7   r8   s        r'   _fix_up_private_attrr      sm     --C

  1<< 	"ajj&6&6 	"g!AAJr(   c                 Z    t          |dd          }|r|                     |           dS dS )zC
    Add the required libs for the callable to allow inlining.
    libsr3   N)getattradd_linking_libs)contextcallr   s      r'   _add_linking_libsr      sA     4$$D '  &&&&&' 'r(   c                    |t                      }n$t          |t                    rt          |          }t          j        |                                           D ]\  }}||vrt          |          ||<   t          |           t          | j	        |          }i }t          t          j        |                     D ]}|                    |j                   i i i i f\  }}	}
}|                                D ]`\  }}t          |t          j                  r|||<   %t          |t"                    r||	|<   @t          |t$                    r||
|<   [|||<   at'          |          t'          |	          z  t'          |
          z  t'          |          z  }|r5t)          d                    d                    |                              |                    dd          }t1          |           |rKd}d                    |                                          }t5          |                    |                    |	                                D ].\  }}|j        "t5          d                    |                    /d |                                D             }i }|	                                D ]H\  }}i }|j        rt;          |j                  |d	<   |j        rt;          |j                  |d
<   |||<   Id |
                                D             } || t>          ||||          }tA          ||          }|                    |           tC          | j	        | f|          } tD          j#        }|$                    | |           tD          j%        } ||||          &                                 t          j&        | |j'                   | S )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
    Nzname shadowing: {0}r\   rw    z(class members are not yet supported: {0}zdeleter is not supported: {0}c                 4    i | ]\  }}|t          |          S r3   r   r5   s      r'   
<dictcomp>z'register_class_type.<locals>.<dictcomp>   s$    :::$!Q1d1gg:::r(   getsetc                 >    i | ]\  }}|t          |j                  S r3   )r   __func__r5   s      r'   r   z'register_class_type.<locals>.<dictcomp>   s;     @ @ @ $14
@ @ @r(   )r:   rw   )(r   rR   r   ptget_type_hintsr<   r   r{   r   r*   reversedinspectgetmroupdate__dict__pytypesFunctionTypepropertystaticmethodr   	NameErrorre   rf   pop_drop_ignored_attrskeysrQ   fdelfgetr   fsetConstructorTemplatedictrM   r   typing_contextinsert_globaltarget_contextregisterr`   )rV   rz   
class_ctorbuilderattrpy_typeclsdctbaseclsra   propsstatic_methodsothersr7   r8   shadowed	docstringrJ   r%   jit_methods	jit_propsrX   jit_static_methodsr:   jit_class_dct	typingctx	targetctxs                             r'   register_class_typer      s    |}}	D(	#	# !4   *3//5577 0 0gt&w//DJ4  d33D FGN3//00 ( (g&''''-/R^*GUNF  1a-.. 	GAJJ8$$ 	E!HH<(( 	 !N1F1II Gs5zz)C,?,??3t99LH K-44TYYx5H5HIIJJJ

9b))I -8))FKKMM**

7++,,, G G16;BB1EEFFF  ;:'--//:::KI  16 	&afCJ6 	&afCJ	!@ @(6(<(<(>(>@ @ @  J J	BBBM+,,,
s|cV]
;
;C )IC,,, )IGJ	9--668883
 8999Jr(   c                       e Zd ZdZd ZdS )r   z8
    Base class for jitclass constructor templates.
    c                 ~   | j         j        }|j        d         }|                                f|z   }t	          j        |          }|                    | j        ||          }t          |j	        t          j
                  st          j        d|j	         d          t          j        |g|j        dd          R  }|S )Nr   z$__init__() should return None, not ''rO   )keyr`   r   get_reference_typer   
Dispatcherget_call_typer   rR   return_typeNoneTyper	   NumbaTypeErrorr   	signaturerI   )	r    rI   kwsr`   r_   	boundargs	disp_typesigr   s	            r'   genericzConstructorTemplate.generic  s    .(4"55779D@	$T**	%%dlIsCC#/5>:: 	K'IsIIIK K K !-?#(122,???
r(   N)r*   r+   r,   rw   r   r3   r(   r'   r   r     s-             r(   r   c                    t          g d          }t          j        dk    r|t          ddg          z  }d| v r|                    d           |                                 D ]n\  }}t          |t          j        t          j        f          r|                    |           At          |dd           t          u r|                    |           od| v r| d         |                    d           |D ]}|                     |           d S )N)__weakref__r+   r   )      __firstlineno____static_attributes____annotations____objclass____hash__)r   r   	PYVERSIONaddr<   rR   r   BuiltinFunctionTypeBuiltinMethodTyper   objectr   )rX   dropr7   r8   s       r'   r   r     s/        D '!!&(?@AAAC"###		  1a'5!35 6 6 	HHQKKKKQ--77HHQKKK
 SS_4  



 r(   c                   ^    e Zd ZdZ ej        d          Z e            Zd Z	d Z
d Zd ZdS )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                 0    || _         || _        || _        d S N)r:   r   r   )r    r:   r   r   s       r'   r   zClassBuilder.__init__=  s    $""r(   c                     |                      | j        | j        j                   | j                            | j                   dS )z7
        Register to the frontend and backend.
        N)_register_methodsclass_impl_registryr:   r`   r   install_registry)r    s    r'   r   zClassBuilder.registerB  sJ    
 	t7#<	> 	> 	> 	''(@AAAAAr(   c                     t          |j                  t          |j                  z   }|D ];}|| j        vr0|                     ||           | j                            |           <dS )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_methodsM  s~     =4551223 	3 	3D
 4333&&x666(,,T222	3 	3r(   c                    fdfd}                     d          }|dv r ||           d S  |                    t          j        ft          j        t          j        t          j                                                    d S )Nc                      fd} | S )Nc                    |j         d         }	|j        v r|j        	         }nC	|j        v r:|j        	         }|                    |j         dd                    }|dd          }t	          j        |          }|                     ||          } |||          }t          | |           t          j	        | ||j
        |          S )Nr   rO   r]   )rI   r   r   replacer   r   get_functionr   r
   impl_ret_new_refr   )
r   r   r   rI   r`   methodr   r   r   r   s
            r'   impz<ClassBuilder._implement_method.<locals>.get_imp.<locals>.impb  s     #=444*6t<FF]===*=dCF ++38ABB<+88C8D!,V44	++Is;;d7D))!'40000'14#G G Gr(   r3   )r   r   s    r'   get_impz/ClassBuilder._implement_method.<locals>.get_impa  s(    G G G G 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
                                                    d S )Nz__%s__c                       e Zd Z fdZdS )KClassBuilder._implement_method.<locals>._getsetitem_gen.<locals>.GetSetItemc                     |d         }t          |t          j                  rH|j        v rA|j                 }t          j        |          }|                    | j        ||          }|S d S d S )Nr   )rR   r   ClassInstanceTyper   r   r   r   )r    rI   r   rp   r   r   r   _dunder_meths          r'   r   zSClassBuilder._implement_method.<locals>._getsetitem_gen.<locals>.GetSetItem.generic|  sz    #AwH!(E,CDD #(H,@@@'3LA$)$4T$:$:	'55dlD#NN"
# #@@r(   N)r*   r+   r,   r   )r   s   r'   
GetSetItemr   z  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_genv  s
   #f,L6**B#B''# # # # # # #Y7 # # ('#<H"E$;\#J#(#:#(<	#:#:< <<CGIIG G G<H"2#(#:#(<	#:#:< <<CGIIG G G G Gr(   r~   )getitemsetitem)striplowerr   r   r   r   )r    r   r   r  dunder_strippedr   s     `  @r'   r   zClassBuilder._implement_method_  s    	 	 	 	 	*	G 	G 	G 	G 	G0 **S//444OO,,,,,4HNNE3T: 2 <	224 44;GII? ? ? ? ?r(   N)r*   r+   r,   rw   r
   Registryr   r   r   r   r   r   r   r3   r(   r'   r   r   5  s          ,(+,>??#%%# # #
	B 	B 	B3 3 3$5? 5? 5? 5? 5?r(   r   c                   "    e Zd Zej        Zd ZdS )ClassAttributec                 V   	 j         v rj                  S j        v rSj                 }t          j        |          	 G 	 fddt          j                  }t          j        |          S j        v rSj                 }t          j        |          	 G 	 fddt          j                  }t          j        |          S j        v rMj                 }|d         }t          j        |          			                     j
        fi           }|j        S d S )Nc                   .    e Zd Zj         fZfdZdS )6ClassAttribute.generic_resolve.<locals>.MethodTemplatec                     ft          |          z   }                    | j        ||          }|                                S r   )tupler   r   	as_methodr    rI   r   r   r   rp   s       r'   r   z>ClassAttribute.generic_resolve.<locals>.MethodTemplate.generic  s<    $;t4D#11$,cJJC==??*r(   Nr*   r+   r,   r   r   r   r   rp   r    s   r'   MethodTemplater    s?        x&+ + + + + + + +r(   r  c                   .    e Zd Zj         fZfdZdS )<ClassAttribute.generic_resolve.<locals>.StaticMethodTemplatec                 h                         | j        ||          }|                              S )N)recvr)r   r   r   r  s       r'   r   zDClassAttribute.generic_resolve.<locals>.StaticMethodTemplate.generic  s4     $11$,cJJC
 ;;X;666r(   Nr  r  s   r'   StaticMethodTemplater    s?        x&7 7 7 7 7 7 7 7r(   r  r   )r;   r   r   r   r   r   BoundFunctionr   r   r   r   r   )
r    rp   r   r   r  r  impdctgetterr   r   s
   ```      @r'   generic_resolvezClassAttribute.generic_resolve  s   8?""?4((X)))'-D(..I+ + + + + + + + + +!; + + + &~x@@@X000.t4D(..I7 7 7 7 7 7 7 7 7 7y'A 7 7 7 &';XFFFX''''-FE]F(00I))$,RHHC?" ('r(   N)r*   r+   r,   r   r   r   r  r3   r(   r'   r  r    s+        

!C.# .# .# .# .#r(   r  c                    ||j         v r|                     |||          }|j        }|                     ||                                |          }t          j        | ||j         |         t          |t          |                              S ||j	        v r|j	        |         d         }t          j        d|          }	t          j        |          }
|
                    | j        |gi           }	|                     |
|	          } |||g          }t#          | |           t          j        | ||	j        |          S t)          d                    |                    )z4
    Generic getattr() for @jitclass instances.
    valuerefr   Nattribute {0!r} not implemented)r;   make_helperr   make_data_helperget_data_typer
   impl_ret_borrowedr   r4   r   r   r   r   r   r   r   r   r   r   r   NotImplementedErrorre   )r   r   typr!  r   instdata_pointerr   r  r   
dispatcherr   r   s                r'   get_attr_implr.    sf   
 sz""7Cu"==y''1B1B1D1D,8 ( : :)'7*-*T*:*1$T8J8J*K*KM M 	M 
		t$U+!$,,%f--
&&w'=ubII##J44d7UG$$'4(((('3?CPPP
?FFtLL
M
MMr(   c                    |j         \  }}|\  }}||j        v r|                     |||          }	|	j        }
|                     ||                                |
          }|j        |         }t          |t          |                    }t          |t          |          |           | j	        
                    |||           | j	                            |||           dS ||j        v r{|j        |         d         }t          j        |          }|                    | j        ||fi           }|                     ||          } ||||f           t%          | |           dS t'          d                    |                    )z4
    Generic setattr() for @jitclass instances.
    r   r"  r   r$  N)rI   r;   r%  r   r&  r'  r   r4   setattrnrtincrefdecrefr   r   r   r   r   r   r   r)  re   )r   r   r   rI   r   r*  valtytargetvalr+  data_ptrr   	attr_typeoldvaluesetterr   r   s                    r'   set_attr_implr;    s   
 JCKFCsz""7Cv">>9''1B1B1D1D,4 ( 6 6 Jt$	4d!3!344 	l4((#...7Is333 	7Ix88888			t$U+$V,,	%%g&<'*ElB8 8##Is33Wvsm$$$'4(((((!-44T::< < 	<r(   c                    |                      t          j                  }|                      t          j                  }t	          j        t	          j                    |||g          }d                    |j                  }t          j
        |||          }|j        rt	          j        |                                          }|                                }	|                      |	          }
|                    |j        d         |
                                          }|                     ||	|          }| j                            ||	|                                           |                                 |S )Nz	_Dtor.{0}r   r"  )get_value_typer   voidptruintpllvmirr   VoidTypere   r@   r   get_or_insert_functionis_declaration	IRBuilderappend_basic_blockr'  bitcastrI   
as_pointerr%  r1  r3  	_getvalueret_void)r   moduler`   	llvoidptrllsize
dtor_ftypefnamedtor_fnr   alloc_fe_type
alloc_typeptrr   s                r'   imp_dtorrS    sE   &&u}55I##EK00F$V_%6%6&/%CE EJ }122E,VZGGG "7#=#=#?#?@@%3355++M::
oogl1oz/D/D/F/FGG""7Ms"CC7M4>>3C3CDDDNr(   c           	         |j         }|                     |                                          }|                     |          }| j                            ||                     t          j        |          t          | |j	        |                    }| j        
                    ||          }|                    ||                                          }|                    t          j        |          |           |                     ||          }	||	_        ||	_        |j         f|j        z   }
|j        d         }t          j        |          }|                     |t          j        |
           }t1          | |           |	                                gt5          |          z   } |||           |	                                }t7          j        | |||          S )z7
    Generic constructor (__new__) for jitclasses.
    r   )r   r'  get_abi_sizeofr1  meminfo_alloc_dtorget_constantr   r?  rS  rJ  meminfo_datarF  rG  storer   get_null_valuer%  r   r   rI   r   r   r   voidr   rH  r   r
   r   )r   r   r   rI   inst_typrQ  
alloc_sizer   r,  inst_structrj   ri   r   r   realargsrets                   r'   	ctor_implra  )  s    H&&x'='='?'?@@J''
33Jk,,U[*55'.(33 G
 ;++GW==L??<#-#8#8#:#:< <L MM'(44      %%gx88K!K#K !CH,H
+D &&I	5:x+@AADgt$$$%%''(4::5HD( 


!
!C$WgxEEEr(   )Dr   r   r   r   typingr   collectionsr   collections.abcr   llvmliter   r@  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   r0   r   r   r   	ClassTypeOpaqueModelr4   rd   rK   rS   rM   r{   r   r   r   r   r   r   r   r   infer_getattrAttributeTemplater  r   lower_getattr_genericr.  lower_setattr_genericr;  rS  r  r   r   ra  r3   r(   r'   <module>ru     s             # # # # # # $ $ $ $ $ $ ! ! ! ! ! !       > > > > > > > > > > > > > > 8 8 8 8 8 8 8 8 * * * * * * ' ' ' ' ' ' 7 7 7 7 7 7 1 1 1 1 1 1 , , , , , ,B B B B BF& B B BF F F F F* F F F  0- @ @ @  ,.? @ @ @  &*< = = =     *8 *8 *8 *8 *84 *8 *8 *8`$ $ $	 	 	' ' '_ _ _D    )4   ,  :_? _? _? _? _?6 _? _? _?D 1# 1# 1# 1# 1#Y0 1# 1# 1#h !778OPPN N QPN6 !778OPP$< $< QP$<N  2 !''(4UY(?(?A A(F (FA A(F (F (Fr(   