[;jSddlmZddlmZddlZddlmZddlmZddlmZddlm Z dd lm Z dd l m Z m Z dd lmZmZdd lmZdd lmZddlmZddlmZmZddlmZdZdZGddeeZGddZGddZeZ GddZ!dZ"dZ#dZ$dZ%dZ&d Z'd!Z(d"Z)d#Z*d$Z+Gd%d&ejXZ-d'Z.y)() OrderedDict)dedentN) ExprNodes)Nodes) PyrexTypes)Builtin)Naming)errorwarning) UtilityCode PyxCodeWriter)VisitorTransform) EncodedString) TreeFragment) NormalizeTreeSkipDeclarations)copy_inherited_directivesctjdd}tj|dt j tj g|gS)NLoadDataclassesModule Dataclasses.c__Pyx_Load_dataclasses_Module) utility_codeargs)r load_cachedrPythonCapiCallNoder CFuncTypepy_object_type)posdataclass_loader_utilitycodes bG:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\Cython/Compiler/Dataclass.py make_dataclasses_module_callnoder"sM#.#:#: #_$6  ' ' ,Z66;1   c >tjdd}tjtjtj dtjdtj dtjdg}t j|d||||gS)NDataclassesCallHelperrcallablekwds__Pyx_DataclassesCallHelper) function_name func_typerr)r rrrr CFuncTypeArgrr)rr&r'rr*s r!make_dataclass_call_helperr,s**+BOTL$$!!  # #J 0I0I4 P  # #FJ,E,Et 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. c>t|||_i|_yN)super__init__namesremoved_assignments)selfr3 __class__s r!r2z!RemoveAssignmentsToNames.__init__;s  #% r#c(|j||Sr0 visitchildrenr5nodes r!visit_CClassNodez)RemoveAssignmentsToNames.visit_CClassNode@ 4  r#c|Sr0r:s r!visit_PyClassNodez*RemoveAssignmentsToNames.visit_PyClassNodeD r#c|Sr0r?r:s r!visit_FuncDefNodez*RemoveAssignmentsToNames.visit_FuncDefNodeGrAr#ct|jjr|jj|jvr|jj|jvr.t |j d|jjzd|j|j|jj<gS|S)Nz=Multiple assignments for '%s' in dataclass; using most recentr)lhsis_namenamer3r4r rrhsr:s r!visit_SingleAssignmentNodez3RemoveAssignmentsToNames.visit_SingleAssignmentNodeJs 88    ;xx}} 8 88$7:>((--#HIJL6:hhD $ $TXX]] 3I r#c(|j||Sr0r8r:s r! visit_Nodez#RemoveAssignmentsToNames.visit_NodeVr=r#) __name__ __module__ __qualname____doc__r2r<r@rCrIrK __classcell__r6s@r!r.r./s& & r#r.cfeZdZdZdZddZdZdZdZdZ d Z d Z d Z d Z d ZdZddZdZy) 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. rNcb| tn||_|in||_|g|_y||_yr0)rwriter placeholders extra_stats)r5rUrVrWs r!r2zTemplateCode.__init__ds4)/moV "."6BL!,!42+r#c:|jj|yr0)rUputln)r5 code_lines r! add_code_linezTemplateCode.add_code_lineis )$r#c:|jj|yr0)rU put_chunk)r5 code_chunks r!add_code_chunkzTemplateCode.add_code_chunkls j)r#c8|jjyr0)rUresetr5s r!razTemplateCode.resetos r#c6|jjSr0)rUemptyrbs r!rdzTemplateCode.emptyts{{  ""r#c8|jjyr0)rUindentrbs r!rfzTemplateCode.indentw r#c8|jjyr0)rUrrbs r!rzTemplateCode.dedentzrgr#c8|jj|Sr0)rUindenter)r5block_opener_lines r!rjzTemplateCode.indenter}s{{##$566r#cF|j|}||j|<|Sr0)_new_placeholder_namerV)r5 field_namesvaluerGs r!new_placeholderzTemplateCode.new_placeholders'))+6"'$ r#c`|jJd|jj|y)Nz5Can only use add_extra_statements on top-level writer)rWextend)r5 statementss r!add_extra_statementsz!TemplateCode.add_extra_statementss-    # QQ Q5  +r#cz d|jd}||jvr||vr |S|xjdz c_;)NDATACLASS_PLACEHOLDER_dr)_placeholder_countrV)r5rnrGs r!rmz"TemplateCode._new_placeholder_namesR+D,C,CA+FGDD---K/   # #q ( #r#ct|jj|tdgj |j }|xj |jz c_|S)Nlevelpipeline)rrUgetvaluer substituterVstatsrW)r5r{stat_list_nodes r! generate_treezTemplateCode.generate_trees^% KK "#D)*  *T&& '   0 00r#cz|jj}t||j|jS)N)rUrVrW)rUinsertion_pointrSrVrW)r5 new_writers r!rzTemplateCode.insertion_points6[[002 **((  r#)NNN)c_class)rLrMrNrOrxr2r[r_rardrfrrjrprtrmrrr?r#r!rSrS[sQ F %* #7 ,  r#rSc eZdZy) _MISSING_TYPEN)rLrMrNr?r#r!rrsr#rc @eZdZdZeZeZdZdZeedddddddf dZ dZ y)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  ||tur||_|tur||_|xstj|d|_|xstj ||_|xstj|d|_|xstj|d|_ |xstj ||_ | |_ | |_ | jD]\} } t| jd| z |j D]4}t#||}|j$rt|jd|z6y)NTrozBcython.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)r5rrrrrrrrrradditional_kwdskv field_name field_values r!r2zField.__init__s ' !"DL ' )#2D ?I..s$? 3I..s3 ?I..s$? E)"4"4S"E  ;I$6$6s$; $&#))+DAq !%%]`aa b,++J!$ 3K))kooWZddf,r#c#jK|jdzD]}t||}|tus||fyw)Nrr)rrr)r5keyros r!iterate_record_node_argumentsz#Field.iterate_record_node_argumentss;%%(FFCD#&EG#5j Gs'3 3) rLrMrNrOrrrprivaterr2rr?r#r!rrs@GOGBL%,WD!uf6!r#rc~|jj}t|tjd}|Dcgc]}|j }}t |}|||j}|j}t}|ro|js|jjst|jdd|jr|jj}n|j}|ro|D]}|j }|j!d} |j!d} ||vr-||} t#| t$j&r| j(j+dk(s.t-j.| j(|jdk(r5t#| t$j0xrst#| j2t$j4xrM| j2j6 xr4| j8duxs$t#| j8t$j:} t#| t$j<xr | j6 } | s| st?| jdv| r&| j8r| j8jAni}d |vrd |vrt?| jd tC|jfi|}n| jDt,jFt,jHt,jJfvr:t?| jd jM| jDj |tC|j| }ntC|j}| |_'| |_(|jRdk(rd|_*|||<||jVjD_|Scc}w)Nr)rzCannot 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 attrgetterrGr.r4 base_typer is_external implementedr rdataclass_fieldscopydeclared_with_pytyping_modifier isinstancerCallNodefunctionas_cython_attributer 'exprnode_to_known_standard_library_nameGeneralCallNodepositional_args TupleNoder keyword_argsDictNodeSimpleCallNoder as_python_dictrtype list_type dict_typeset_typeformatrr visibilityrentry)r;rr var_names transformdefault_value_assignmentsrfieldsrGrr assignmentvalid_general_callvalid_simple_callrfields r!process_class_get_fieldsrs;**((K(*=*=e*DEK)45I5)3I dO ) = =I ]F   (C(C DHH]^_ a  % %//446F ''  zz::;PQ ;;?K]blbybyz66EEG@B  ,1Bl1R*..*[\dhh7,7??w'8'8':K:KWM]M]&^^*..+006z7K7KT0RTdhh ;$((OE%'   y ( EMt WX(.DJJOO$ M6sN:cftdddddddd}||drt|jd|djD]\}}||vr*t |t j r|j||<4||vrt|jd|zt |t j rlt|jd|d }t|}t|j}t j|j|td  } t jj|j|jDcgc]_\}}t j|jt| t j |j|tj fac}}d |fddfDcgc]_\}}t j|jt| t j |j|tj fac}}z} t#|j| | } t%j&|jt j(|jtd| } t+|||} t%j,|j| g| z}t/}t1||d|||t3||d|||t5||d||t7||d||t9||d||t;||d|d|d|||xj<|j?j<z c_t%j@|jtC|jDjFd|}|jI|jD|jK||jD|jM||jO|jPj<jS|ycc}}wcc}}w)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 attributer)ror)slotsF) weakref_slotF__dataclass_params__rGrErH)rrrrrrrr)annotation_typing) directivesbody)*dictr rrrrrrorr" AttributeNoderr from_pairsIdentifierStringNoder bool_typer,rSingleAssignmentNodeNameNode_set_up_dataclass_fields StatListNoderSgenerate_init_codegenerate_match_argsgenerate_repr_codegenerate_eq_codegenerate_order_codegenerate_hash_coderrCompilerDirectivesNoderrranalyse_declarations enter_scopevisit exit_scoperappend)r;dataclass_argsanalyse_decs_transformkwargsrrrrdataclass_moduledataclass_params_funcdataclass_params_keywordsdataclass_paramsdataclass_params_assignmentdataclass_fields_statsrcodecomp_directivess r!handle_cclass_dataclassr%s t$45$@F! !  $((X Y"1%++-DAqF{z!Y-?-?@GGq dhh^abbda!3!34dhh^`.YG %d +F7A &33DHHBR>KL^>_a ) 2 2 = = lln '$da  ) )$((-:J K   dhhag6G6G H J$ ' "7+')@B Bda  ) )$((-:J K   dhhag6G6G H JB   ! 2 ')BD"'"<"<    >T0UV#  6dFDTU   txx&A%BE[%[ ]E >DtVF^T67Cf\2D&'JtVF^T6:T6$<v6fWotV<tVM2F4L&BRTXZ`a KK4%%'---K 22488,TZZ-B-BV[\ O((4&&tTZZ8  1%%'IIOO?+W ' sA$P' A$P-c|r|jjdryd|vrdnd}|g}|r|jd|j}|j}|j t |j }tj|j |td} |j|| } d} |jD]\} } |jj| }|jr$d |jjj}nd }d }| j t"us| j$t"urO| j&jrd } | j$t"ur| }n|j|| j }d |}nE| rC|sA| j&jr+t)|j d | z|j+y| j&jr|j| ||| j,rI| j$t"urO| j&jr|j/|d| d | |s|j/|d| ||j|| j$}| j&jr$|j/|d| d |d| d| d| |j/|d| d |d|jjdr=dj1d|jD}|j/|d|d|j3r|j/ddj1|}|j/d|dy)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. r2Nr5__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|]\}}|jr|ywr0)r).0rGrs r! z%generate_init_code..s##8>KD%&+&6&6$(>sz.__post_init__()passz def __init__(z):)r lookup_hererrrfr"rrrrrprlookup annotationstringrorrrrr rarr[joinrd)rrr;rrselfnamerfunction_start_pointrhas_default_factorydefault_factory_placeholder seen_defaultrGrrrrph_namepost_init_varss r!rrtsE& 4::))*5(.'7#VH :D C//1    !DKKM8A#11   67 #'"6"6v?R"SL||~ e !!$'   e..55;;<=JJ == '5+@+@+Ozz# $$G35..vu}}EwiJ 'ejj.>.> %))69=> ? JJL  ::   KK4& ZL9 :      " "g -zz""hZqc$#@A""hZqzl#CD**653H3HIGzz""j$s7)6$tD_C``fgkflm ""hZqc'"#EFW&Z zz)#86<<>#88 hZ~6FaHI zz| 6" 99T?D&&tfB'?@r#c8|r|jjdryg}|jD]A\}}|xs$t|dxr|jj }|r1|j |C|jdtt|zy)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) rrrhasattrrrorr[strtuple) rrr;rglobal_kw_onlypositional_arg_namesrrfield_is_kw_onlys r!rrs //0@A#\\^ E) E9 % =%--*=*=  ' ' 3 , ,s59M3N/OOPr#c \|r|jjdryd}|jD]^}|jj|}|j}|jr |j }|j sO|jr\d}n|r|jd|jd5|r!|jd|j|jDcgc]/\}}|jjr|js|d|d 1} }}d j| } |jd | d |r;|j!|jd 5|j#dddddddycc}}w#1swYxYw#1swYyxYw)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: z={self.z!r}r zq name = getattr(type(self), "__qualname__", None) or type(self).__name__ return f'{name}(z )' zfinally:zguard_set.remove(key))rrkeysris_memoryviewslicedtype is_pyobject is_gc_simpler_rjrfrrrorrrr[) rrr;rneeds_recursive_guardrGrtype_rstrs format_strings r!rrs 4::$$Z0"  !!$'   # #KKE  !!$( !    , -   !  KKM$*<<>>#1KD%::##E,<,<%)$/#1 > $  !,o.    ! KKMz*""#:;+- . ->+*- . -s767F"-4F!A F"-F?F"F"F F""F+c Z|jj|ry|jDcgc]+\}}|jjs|j r*|-}}}|j d|d5|jd|jd|jdg}|jdd} |D]:}|dk7r|jd |d | d |d |jd |d |d<|jdd|vrdnddddycc}}w#1swYyxYw)Nzdef 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) rrrrrorrjr_ class_namereplacer[) ropfuncnamer;rrGrr3checksop_without_equalss r!generate_cmp_coder;-s: zzh'%+\\^ f^kdE 8K8KTYTdTdT^E f hZ~6 7 !//"#??+,   "JJsB/DTz""XdV15F4G|TXSYYf#gh   $tfNS T  WsbyVg$FGH5 8 7 g 7 7sD DD8BD!!D*c(|syt|dd||y)Nr1__eq__r;)rrr;rs r!rrPs dD(D&9r#c<|sydD]\}}t|||||y)N))<__lt__)z<=__le__)>__gt__)z>=__ge__r>)rrr;rr7rGs r!rrVs* 'D $D$7 'r#c *|jjd}|r&|r#t|jd|jzy|s}|sy|sx|j t j|jtj|jtdtj|jgy|jDcgc]V\}}|jsE|jj|j jrn|jjr|X} }}dj#d| D} | r| dz } |j%d 5|j'd | d dddycc}}w#1swYyxYw) 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 %sNrrr c3&K|] }d|z yw)zself.%sNr?)r rGs r!r z%generate_hash_code..s DedT!1es,zdef __hash__(self):z return hash((z)))rrr rr5rtrrrrrrrrrrorrrjr[) rrrrr;r hash_entryrGrr3hash_tuple_itemss r!rrasbL'' 3J  $((MPTP_P__ `    % %**HH!**488- :ST!**4884'  !'   .u#(::#3#3#;EMM  AQAQ   yy De DDC , - ]+;* 88== / / 488..s3 3 $$& &r#cddlm}|d}|j|j}t j |j t|S)Nr)AnnotationWriterzDataclass field) descriptionr)AutoDocTransformsr`writerTrrOrr)r5r`rUrs r!r^zFieldRecordNode._make_strings>7!.?@dhh'$$TXX]65JKKr#c8|jj|Sr0)rTgenerate_evaluation_code)r5rs r!rez(FieldRecordNode.generate_evaluation_codesxx0066r#) rLrMrNrOsubexprsr2rXr]r^rerPrQs@r!rSrSs+wH' 'L 7r#rSc( g}|jD]Z\}}|jrdD]A}t||}|tus|js |j r1|j j}|j|jtj|j|} tj|jt| } |j!| j"|j$xst&j(|j| j"d| _t-||| |j/t1j2|j| |D]i} tj4|j|td} tj6|jg} g}|jD]"\}}|jrd |z}t9|j|j j:|| |<d |z}|j<r/tj4|j|td | |<ni|j>r/tj4|j|td | |<n.tj4|j|td | |<tj6jA|j|jCDcgc]F\}}tjD|jt|tG|j|fHc}}}tI|j| |}| jJj/tjL|jtjD|jt|||j/tOd|d|d|d|d|d|d %t1j2|jtj|jtd| }djQ|}tS|dtUdg}|jW| }||gz|jXzScc}}w)NrrT)rrcnameis_cdefrrr)key_value_pairszPLACEHOLDER_%szPLACEHOLDER_FIELD_TYPE_%s_FIELD_INITVAR_FIELD_CLASSVAR_FIELDrrV)rroz% __dataclass_fields__[z ].name = z& __dataclass_fields__[z ].type = z]._field_type = z __dataclass_fields__ rrz)-rrrrrrFr global_scopemangler dataclass_field_default_cnamer5rrrr declare_varrGrrunspecified_typersetattrrrrrrrQentriesrrrrrrSr,rj DictItemNoderrrrr~r)r;rrvariables_assignment_statsrGrattrname field_defaultrpmodule_field_name field_noderV field_func dc_fieldsdc_fields_namevalue_assignmentstype_placeholder_namefield_type_placeholder_namerrdc_field_keywords dc_field_calldataclass_fields_assignments r!rrsA"$||~ e == 8H#E84M'=+C+C}G\G\::224L , 3 3##F$H$H$//Z! #++M,=,=MRcDdeJ+77m&8&8&WJY=Z[   U&d ""488'00-:;Q-RT' ) '+ii0O&P#&23R9B=J4=Prs$",%)&@.")/1A)XJ J Z  //!/!dCLL,^bAJQ&>