-PhddlmZddlmZddlZddlmZddlmZddlmZddlm Z dd lm Z dd l m Z m Z dd lmZmZmZdd lmZdd lmZddlmZddlmZmZddlmZdadZdZGddeeZGddZ GddZ!e!Z"GddZ#dZ$dZ%dZ&dZ'dZ(d Z)d!Z*d"Z+d#Z,d$Z-Gd%d&ej.Z/d'Z0dS)() OrderedDict)dedentN) ExprNodes)Nodes) PyrexTypes)Builtin)Naming)errorwarning) UtilityCodeTempitaUtilityCode PyxCodeWriter)VisitorTransform) EncodedString) TreeFragment) NormalizeTreeSkipDeclarations)copy_inherited_directivesc0tsUtjdd}t|j}t jddd|datj |dtj tj gtg S) NDataclasses_fallbackzDataclasses.pySpecificModuleLoader Dataclasses.c dataclasses)cnamepy_code)context__Pyx_Load_dataclasses_Module) utility_codeargs) _dataclass_loader_utilitycoder load_cachedrimplrloadas_c_string_literalrPythonCapiCallNoder CFuncTypepy_object_type)pospython_utility_codes Y/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/Cython/Compiler/Dataclass.py make_dataclasses_module_callnoder,s (d)56LN^__+,?,DEE(:(? "O+8K8_8_8a8abb)d)d)d%  ' ,Z6;;2     c tjdd}tjtjtjdtjdtjdtjdg}t j|d||||gS)NDataclassesCallHelperrcallablekwds__Pyx_DataclassesCallHelper) function_name func_typerr )r r"rr'r( CFuncTypeArgrr&)r)r0r1rr4s r+make_dataclass_call_helperr6%s*+BOTTL$!  #J 0I4 P P  #FJ,Et L L$ I  ' 3!     r-c@eZdZdZfdZdZdZdZdZdZ xZ S)RemoveAssignmentsToNamesa Cython (and Python) normally treats class A: x = 1 as generating a class attribute. However for dataclasses the `= 1` should be interpreted as a default value to initialize an instance attribute with. This transform therefore removes the `x=1` assignment so that the class attribute isn't generated, while recording what it has removed so that it can be used in the initialization. cdt||_i|_dSN)super__init__namesremoved_assignments)selfr= __class__s r+r<z!RemoveAssignmentsToNames.__init__Bs.  #%   r-c0|||Sr: visitchildrenr?nodes r+visit_CClassNodez)RemoveAssignmentsToNames.visit_CClassNodeG 4    r-c|Sr:rDs r+visit_PyClassNodez*RemoveAssignmentsToNames.visit_PyClassNodeK r-c|Sr:rIrDs r+visit_FuncDefNodez*RemoveAssignmentsToNames.visit_FuncDefNodeNrKr-c|jjrd|jj|jvrQ|jj|jvr#t |jd|jjzd|j|j|jj<gS|S)Nz=Multiple assignments for '%s' in dataclass; using most recentr)lhsis_namenamer=r>r r)rhsrDs r+visit_SingleAssignmentNodez3RemoveAssignmentsToNames.visit_SingleAssignmentNodeQs| 8    ; ;x} 888$7:>(-#HIJLLL6:hD $TX] 3I r-c0|||Sr:rBrDs r+ visit_Nodez#RemoveAssignmentsToNames.visit_Node]rGr-) __name__ __module__ __qualname____doc__r<rFrJrMrSrU __classcell__r@s@r+r8r86s  &&&&& r-r8cheZdZdZdZddZdZdZdZdZ d Z d Z d Z d Z d ZdZddZdZdS) TemplateCodez Adds the ability to keep track of placeholder argument names to PyxCodeWriter. Also adds extra_stats which are nodes bundled at the end when this is converted to a tree. rNc`|tn||_|in||_|gn||_dSr:)rwriter placeholders extra_stats)r?r_r`ras r+r<zTemplateCode.__init__ks=)/moooV "."6BBL!,!422+r-c:|j|dSr:)r_putln)r? code_lines r+ add_code_linezTemplateCode.add_code_lineps )$$$$$r-c:|j|dSr:)r_ put_chunk)r? code_chunks r+add_code_chunkzTemplateCode.add_code_chunkss j)))))r-c8|jdSr:)r_resetr?s r+rkzTemplateCode.resetvs r-c4|jSr:)r_emptyrls r+rnzTemplateCode.empty{s{  """r-c8|jdSr:)r_indentrls r+rpzTemplateCode.indent~ r-c8|jdSr:)r_rrls r+rzTemplateCode.dedentrqr-c6|j|Sr:)r_indenter)r?block_opener_lines r+rtzTemplateCode.indenters{##$5666r-cD||}||j|<|Sr:)_new_placeholder_namer`)r? field_namesvaluerQs r+new_placeholderzTemplateCode.new_placeholders'))+66"'$ r-c\|j Jd|j|dS)NFz5Can only use add_extra_statements on top-level writer)raextend)r? statementss r+add_extra_statementsz!TemplateCode.add_extra_statementss7   # QQ Q Q Q  +++++r-c\ d|jd}||jvr||vrn|xjdz c_*|S)NTDATACLASS_PLACEHOLDER_dr)_placeholder_countr`)r?rxrQs r+rwz"TemplateCode._new_placeholder_namesX )GD,CGGGDD---K//  # #q ( # # ) r-c_classct|j|tdg|j}|xj|jz c_|S)Nlevelpipeline)rr_getvaluer substituter`statsra)r?rstat_list_nodes r+ generate_treezTemplateCode.generate_treesl% K " "#D))*    *T& ' '   00r-cl|j}t||j|jS)N)r_r`ra)r_insertion_pointr]r`ra)r? new_writers r+rzTemplateCode.insertion_points;[0022 *(    r-)NNN)r)rVrWrXrYrr<rerirkrnrprrtrzr~rwrrrIr-r+r]r]bs FFFF %%%*** ###777 ,,,        r-r]ceZdZdS) _MISSING_TYPEN)rVrWrXrIr-r+rrsDr-rc BeZdZdZeZeZdZdZeedddddddf dZ dZ dS)Fieldar Field is based on the dataclasses.field class from the standard library module. It is used internally during the generation of Cython dataclasses to keep track of the settings for individual attributes. Attributes of this class are stored as nodes so they can be used in code construction more readily (i.e. we store BoolNode rather than bool) F)reprhashinitcomparemetadataNc  R|tur||_|tur||_|ptj|d|_|ptj||_|ptj|d|_|ptj|d|_ |ptj||_ | |_ | |_ | D]\} } t| jd| z|jD]1}t#||}|jst|jd|z2dS)NTryzBcython.dataclasses.field() got an unexpected keyword argument '%s'z?cython.dataclasses.field parameter '%s' must be a literal value)MISSINGdefaultdefault_factoryrBoolNoderNoneNoderrrr is_initvar is_classvaritemsr r) literal_keysgetattr is_literal)r?r)rrrrrrrrradditional_kwdskv field_name field_values r+r<zField.__init__sU ' ! !"DL ' ) )#2D ?I.s$??? 3I.s33 ?I.s$??? E)"4S"E"E"E  ;I$6s$;$; $&#))++ c cDAq !%]`aa b b b b+ f fJ!$ 33K) fkoWZddfff f fr-c#bK|jdzD]!}t||}|tur||fV"dS)Nrr)rrr)r?keyrys r+iterate_record_node_argumentsz#Field.iterate_record_node_argumentssS%(FF ! !CD#&&EG##5j    ! !r-) rVrWrXrYrrrprivaterr<rrIr-r+rrssGOGBL%,WD!uffff6!!!!!r-rcR|jj}t|tjd}d|D}t |}|||j}|j}t}|rS|j s |jj st|j dd|j r|j }n |j}|S|D]K}|j}|d} |d} ||vr||} t#| t$jrB| jdks$t-j| j|jdkrt#| t$joSt#| jt$jo4| jj o'| jdupt#| jt$j} t#| t$jo| j } | s| st?| j d H| r | jr| j ni}d |vrd |vrt?| j d tC|j fi|}n| j"t,j#t,j$t,j%fvr3t?| j d &| j"j|tC|j | }ntC|j }| |_'| |_(|j)dkrd|_*|||<M||j+j"_ |S)Nr))rcg|] }|j SrIrQ).0entrys r+ z,process_class_get_fields..s555555r-zCannot reliably handle Cython dataclasses with base types in external modules since it is not possible to tell what fields they havezdataclasses.InitVarztyping.ClassVarzdataclasses.fieldzVCall to 'cython.dataclasses.field' must only consist of compile-time keyword argumentsrrz/cannot specify both default and default_factoryzMmutable default for field {} is not allowed: use default_factory)rrT),scope var_entriessortedoperator attrgetterr8r> base_typer is_external implementedr r)dataclass_fieldscopyrQdeclared_with_pytyping_modifier isinstancerCallNodefunctionas_cython_attributer 'exprnode_to_known_standard_library_nameGeneralCallNodepositional_args TupleNoder keyword_argsDictNodeSimpleCallNoder as_python_dictrtype list_type dict_typeset_typeformatrr visibilityrr)rEr var_names transformdefault_value_assignmentsrfieldsrrQrr assignmentvalid_general_callvalid_simple_callrfields r+process_class_get_fieldsrs*(K(*=e*D*DEEEK55555I)33I IdOOO ) =I ]]F (   a (C a DH]^_ a a a  % /4466F '  (++z::;PQQ ;;???K] Bblby Bz6EEGGG@B  ,,1Bl1R1R*.*[\\\dh77,77?w'8':KWM]&^^^*.+006z7KT0R0RTTTdh ;;;$(OOE%'  y ( ( EMt '-DJO$ Mr-c tdddddddd}||drtjd|dD]Z\}}||vrtjd|zt |t jstjd|j||<[|d }t}tj}t j j|td  } t j jfd |Dfd d |fddfDz} tj| | } tjjt jjtd| } t%||} tjj| g| z}t)}t+||d||t-||d||t/||d|t1||d|t3||d|t5||d|d|d||xj|jz c_tjjt=jj d|}|!j|"j|#||$j%j&|dS)NTF)rreqorder unsafe_hashfrozenkw_only match_argsrz:cython.dataclasses.dataclass takes no positional argumentsrzFcython.dataclasses.dataclass() got an unexpected keyword argument '%s'zFArguments passed to cython.dataclasses.dataclass must be True or Falser_DataclassParamsobj attributecg|]H\}}tjjt|tjj|fISrrIdentifierStringNoder)rrrrrrEs r+rz+handle_cclass_dataclass..Jsa ' ' 'a  )$(-:J:J K K K  dha 0 0 0 2 ' ' 'r-cg|]H\}}tjjt|tjj|fISrrrs r+rz+handle_cclass_dataclass..Msa   a  )$(-:J:J K K K  dha 0 0 0 2   r-)slotsF) weakref_slotF__dataclass_params__rrOrR)rrrrrrrr)annotation_typing) directivesbody)'dictr r)rrrrryrr, AttributeNoderr from_pairsr6rSingleAssignmentNodeNameNode_set_up_dataclass_fields StatListNoder]generate_init_codegenerate_match_argsgenerate_repr_codegenerate_eq_codegenerate_order_codegenerate_hash_coderrCompilerDirectivesNoderrranalyse_declarations enter_scopevisit exit_scoperappend)rEdataclass_argsanalyse_decs_transformkwargsrrrrdataclass_moduledataclass_params_funcdataclass_params_keywordsdataclass_paramsdataclass_params_assignmentdataclass_fields_statsrcodecomp_directivess` r+handle_cclass_dataclassr,s t$45$@@@F! !  Z $(X Y Y Y"1%++--  DAqdh^abbddda!344 `dh^```F1IIYG %d + +F7AA &3DHBR>KL^>_>_aaa ) 2 = =  ' ' ' 'llnn ' ' '    !7+')@B     ! ! 2 ')BDD"'"<   >T0U0UVVV# # #  6dFDTUU  tx&A%BE[%[ ] ] ]E >>DtVF^T67CCCf\2D&'JJJtVF^T6:::T6$<v666fWotV<<<tVM2F4L&BRTXZ`aaa KK4%%''--KK 248,TZ-BV[\\\ O((444&&tTZ888  111%%'''IO?+++++r-c|r|jdrdSd|vrdnd}|g}|r|d|}|}|t |j}tj|j|td} | || } d} | D]\} } |j | }|j rd |j jj}nd }d }| jt"us| jt"ur@| jjrd } | jt"ur| }n| || j}d |}n?| r=|s;| jjr/t)|jd | z|dS| jjr|| ||| jr | jt"urK| jjr||d| d | D|r||d| |d| || j}| jjr(||d| d |d| d| d| ||d| d |d|j drLdd| D}||d|d|r|dd|}|d|ddS)a  Notes on CPython generated "__init__": * Implemented in `_init_fn`. * The use of the `dataclasses._HAS_DEFAULT_FACTORY` sentinel value as the default argument for fields that need constructing with a factory function is copied from the CPython implementation. (`None` isn't suitable because it could also be a value for the user to pass.) There's no real reason why it needs importing from the dataclasses module though - it could equally be a value generated by Cython when the module loads. * seen_default and the associated error message are copied directly from Python * Call to user-defined __post_init__ function (if it exists) is copied from CPython. Cython behaviour deviates a little here (to be decided if this is right...) Because the class variable from the assignment does not exist Cython fields will return None (or whatever their type default is) if not initialized while Python dataclasses will fall back to looking up the class variable. r<Nr?__dataclass_self__*_HAS_DEFAULT_FACTORYrFz: Tz = zHnon-default argument '%s' follows default argument in dataclass __init__.z() if z is z else z() __post_init__, c3.K|]\}}|j |VdSr:)rrrQrs r+ z%generate_init_code..sA#8#8KD%&+&6#84#8#8#8#8#8#8r-z.__post_init__()passz def __init__(z):)r lookup_hererrrpr,r)rrrrzrlookup annotationstringryrrrrr rkrrejoinrn)rrrErrselfnamer function_start_pointr has_default_factorydefault_factory_placeholder seen_defaultrQrrr#rph_namepost_init_varss r+rrxs1& 4:))*55(.'7'7##VH :D C//11    ! !DKKMMM8AA#1   677 #'"6"6v?R"S"SL||~~+G+G e !!$''   =e.5;==JJJ = ' '5+@+O+Oz $# $G335..vu}EE(wJJ  ' ej.>  %)69=> ? ? ? JJLLL FF :  ; KK499Z99 : : :   G   "g - -z E""h#@#@#@#@$#@#@AAAA E""h#C#C#Cz#C#CDDD**653HIIGz G""mm$mm7mm$mmD_mmgkmm ""h#E#E#E#E'#E#E#EFFFF z))J#8#86<<>>#8#8#888 hHH~HHHIII zz||# 6""" 99T??D&&'?t'?'?'?@@@@@r-cH|r|jdrdSg}|D]:\}}|pt|do |jj}|s||;|dtt|zdS)z Generates a tuple containing what would be the positional args to __init__ Note that this is generated even if the user overrides init __match_args__Nrz__match_args__ = %s) rr!rhasattrrryrrestrtuple) rrrErglobal_kw_onlypositional_arg_namesrrfield_is_kw_onlys r+rrs //0@AA#\\^^44 E) E9 % % =%-*=   4 ' ' 3 3 3,s59M3N3N/O/OOPPPPPr-c |r|jdrdSd}|D]D}|j|}|j}|jr|j}|js9|jsd}nE|r|d| d5|r)|d| d| D}d |} |d | d |rV| | d 5|d dddn #1swxYwYddddS#1swxYwYdS)a The core of the CPython implementation is just: ['return self.__class__.__qualname__ + f"(' + ', '.join([f"{f.name}={{self.{f.name}!r}}" for f in fields]) + ')"'], The only notable difference here is self.__class__.__qualname__ -> type(self).__name__ which is because Cython currently supports Python 2. However, it also has some guards for recursive repr invocations. In the standard library implementation they're done with a wrapper decorator that captures a set (with the set keyed by id and thread). Here we create a set as a thread local variable and key only by id. __repr__NFTz __pyx_recursive_repr_guard = __import__('threading').local() __pyx_recursive_repr_guard.running = set() zdef __repr__(self):z key = id(self) guard_set = self.__pyx_recursive_repr_guard.running if key in guard_set: return '...' guard_set.add(key) try: cJg|] \}}|jj|j|d|d!S)z={self.z!r})rryrrs r+rz&generate_repr_code.."sN>>>D%:#>,1,<>DDD$$$/>>>r-rzq name = getattr(type(self), "__qualname__", None) or type(self).__name__ return f'{name}(z )' zfinally:zguard_set.remove(key))rr"keysris_memoryviewslicedtype is_pyobject is_gc_simplerirtrprr%rre) rrrErneeds_recursive_guardrQrtype_strs format_strings r+rrsk 4:$$Z00"   !!$''   # KE   ! $( ! E       , - -<<     !    KKMMM>>#)<<>>>>> $   ,       ! < KKMMMz** < <""#:;;; < < < < < < < < < < < < < < <-<<<<<<<<<<<<<<<<<g|]\}}|jj|j|SrI)rryrrs r+rz%generate_cmp_code..5s/ f f fkdE 8K fTYTd fT f f fr-zdef z(self, other):z_ if other.__class__ is not self.__class__: return NotImplemented cdef z& other_cast other_cast = other =r==zif self. z other_cast.z : return Truez != other_cast.z: return Falsezreturn TrueFalse)rr!rrtri class_namereplacere) ropfuncnamerErr=checksop_without_equalsrQs r+generate_cmp_coderN1s zh'' f fV\\^^ f f fE 6h666 7 7II  /   ?       "JJsB// U UDTzz""#gd#g#g5F#g#gTX#g#g#ghhh   S$SStSSS T T T T GsbyyVVgGGHHH5IIIIIIIIIIIIIIIIIIsB#DD Dc4|sdSt|dd||dS)NrD__eq__rN)rrrErs r+rrTs+ dD(D&99999r-cD|sdSdD]\}}t|||||dS)N))<__lt__)z<=__le__)>__gt__)z>=__ge__rQ)rrrErrJrQs r+rrZsI '88D $D$7777 88r-c |jd}|r!|rt|jd|jzdS|su|sdS|so|t j|jtj |jtdtj |jgdSd| D}d d|D}|r|d z }|d 5|d |d ddddS#1swxYwYdS) a Copied from CPython implementation - the intention is to follow this as far as is possible: # +------------------- unsafe_hash= parameter # | +----------- eq= parameter # | | +--- frozen= parameter # | | | # v v v | | | # | no | yes | <--- class has explicitly defined __hash__ # +=======+=======+=======+========+========+ # | False | False | False | | | No __eq__, use the base class __hash__ # +-------+-------+-------+--------+--------+ # | False | False | True | | | No __eq__, use the base class __hash__ # +-------+-------+-------+--------+--------+ # | False | True | False | None | | <-- the default, not hashable # +-------+-------+-------+--------+--------+ # | False | True | True | add | | Frozen, so hashable, allows override # +-------+-------+-------+--------+--------+ # | True | False | False | add | raise | Has no __eq__, but hashable # +-------+-------+-------+--------+--------+ # | True | False | True | add | raise | Has no __eq__, but hashable # +-------+-------+-------+--------+--------+ # | True | True | False | add | raise | Not frozen, but hashable # +-------+-------+-------+--------+--------+ # | True | True | True | add | raise | Frozen, so hashable # +=======+=======+=======+========+========+ # For boxes that are blank, __hash__ is untouched and therefore # inherited from the base class. If the base is object, then # id-based hashing is used. The Python implementation creates a tuple of all the fields, then hashes them. This implementation creates a tuple of all the hashes of all the fields and hashes that. The reason for this slight difference is to avoid to-Python conversions for anything that Cython knows how to hash directly (It doesn't look like this currently applies to anything though...). __hash__z/Cannot overwrite attribute __hash__ in class %sNrrcpg|]3\}}|js'|jj |jj$n |jj1|4Sr:)rrryrrs r+rz&generate_hash_code..sU   u $):#3#;EM #;#;AQ#; #;#;#;r-rc3 K|] }d|zV dS)zself.%sNrI)rrQs r+rz%generate_hash_code..s' D DdT!1 D D D D D Dr-,zdef __hash__(self):z return hash((z)))rr!r r)rHr~rrrrrrrr%rtre) rrrrrEr hash_entryr=hash_tuple_itemss r+rresL'' 33J  a $(MPTP__ ` ` `    F   % %*H!*48- :S:STTT!*4844'    F   &    Eyy D De D D DDD C , - -AA ?+;???@@@AAAAAAAAAAAAAAAAAAsD55D9<D9c|jr |jjSt|jdd}t j||S)z sets the .type attribute for a field Returns the annotation if possible (since this is what the dataclasses module does). If not (for example, attributes defined with cdef) then it creates a string fallback. rr) for_displayr)r#r$rrdeclaration_coder UnicodeNode)r)rss r+get_field_typeresW 3 &&" %*55ba5HH I I$S2222r-c@eZdZdZdgZfdZdZdZdZdZ xZ S)FieldRecordNodean __dataclass_fields__ contains a bunch of field objects recording how each field of the dataclass was initialized (mainly corresponding to the arguments passed to the "field" function). This node is used for the attributes of these field objects. If possible, coerces `arg` to a Python object. Otherwise, generates a sensible backup string. argcNt||dS)Nrh)r;r<)r?r)rhr@s r+r<zFieldRecordNode.__init__s& #&&&&&r-c\|j||jj|_|Sr:)rh analyse_typesrr?envs r+rlzFieldRecordNode.analyse_typess( s###HM  r-c|jj|r|j|S|Sr:)rhrcan_coerce_to_pyobjectcoerce_to_pyobject _make_stringrms r+rqz"FieldRecordNode.coerce_to_pyobjectsF 8= / / 4 4 '8..s33 3 $$&& &r-cddlm}|d}||j}t j|jt|S)Nr)AnnotationWriterzDataclass field) descriptionr)AutoDocTransformsrtwriterhrrcr)r)r?rtr_r$s r+rrzFieldRecordNode._make_strings[777777!!.?@@@dh''$TX]65J5JKKKKr-c6|j|Sr:)rhgenerate_evaluation_code)r?rs r+ryz(FieldRecordNode.generate_evaluation_codesx00666r-) rVrWrXrYsubexprsr<rlrqrrryrZr[s@r+rgrgswH''''' '''LLL 7777777r-rgcg}|D]6\}}|jrdD]$}t||}|tus|js|jr+j}||tj j |} tj |jt| } || j|jp t&j|j| jd| _t-||| |t1j|j| |&8i} tjj|td} tjjg} g}|D]\}}|jrd |z}t9jjj|| |<d |z}|jr-tjj|td | |<n`|jr-tjj|td | |<n,tjj|td | |<tj jfd|!D}tEj| |}| j#tj$jtj%jt|||tMd|d|d|d|d|d|d t1jjtj jtd| }d'|}tQ|dtSdg}|*| }||gz|j+zS)NrrT)rr)ris_cdefrrr)key_value_pairszPLACEHOLDER_%szPLACEHOLDER_FIELD_TYPE_%s_FIELD_INITVAR_FIELD_CLASSVAR_FIELDcg|]C\}}tjjt|t j|fDS)rrj)rrr)rrgrs r+rz,_set_up_dataclass_fields..Bsd A A A!Q,TX]1=M=MNNNtxQ///1 A A Ar-r)rryz% __dataclass_fields__[z ].name = z& __dataclass_fields__[z ].type = z]._field_type = z __dataclass_fields__ rr),rrrrrrPr global_scopemangler dataclass_field_default_cnamerHrrr)r declare_varrQrrunspecified_typersetattrrrrrrreentriesrrrrr6r} DictItemNoderrr%rrrr)rErr variables_assignment_statsrQrattrname field_defaultrmodule_field_name field_noder` field_func dc_fieldsdc_fields_namevalue_assignmentstype_placeholder_namefield_type_placeholder_namedc_field_keywords dc_field_calldataclass_fields_assignments` r+rrs"$||~~bb e =  8 b bH#E844M''=+C'}G\':2244L , 3 3##F$H$/ZZ!! #+M,=MRcDdDdeeeJ+77m&8&WJrs$#####""""""""@@@@@@@@@@%%%%%%))))))&&&&&&@@@@@@@@...... $   ")))))/1A)))XJ J J J J J J J Z        -///!/!/!/!/!/!/!/!dCCCLI,I,I,XbAbAbAJQQQ&><><>