a ~gt @sUdZddlmZddlZddlZddlmZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddl$Z$ddl%m&Z&ddl%m'Z'ddl(m)Z)ddlm*Z*ddl%m+Z+e"d Z,e"d!d"d#Z-e"d$ed%efd&Z.e"d'd(d&Z/e"d)d*d&Z0e"d+d,d&Z1e"d-d.d&Z2e'j3rd/d0d1d2d3Z4nd/d0d1d4d3Z4d/d5d6d7d8Z5Gd9d:d:Z6d;dd?Z7d/d5d@dAdBZ8d6dCdDd5dEdFdGZ9dHdIdJdKdLdMZ:dNdOdPdQdRZ;dSd5dTdUdVdWZdId_d`dadbZ?dcddZ@dedfd5dIdgdhdiZAe"djZBe"dkZCGdldmdmZDdndoZEedd%dpdqdrdsdtdudvdwZFeddxdpdqdrdJdrdudydwZFddxdpdqdrdJdrdudzdwZFdId{d|d}d~ZGd7dIdJdJddddZHd8ddJddddZId9ddZJd:dCd5d5dSdSdSdSddddZKddZLddZMd;d/dddSd5dddZNGdddZOddZPddZQddfd5dCdJddddd„Zfd/dCdOdÜddńZgd d;d/d/d dƜddȄZhddʜdd̄Zid?d/dddΜddЄZjd/dd5d/dҜddԄZkddքZlGdd؄de[ZmGddڄdee,ZnGdd܄dee,ZoGddބdee,ZpGdddeqZrGdddesZtGdddetdZue!rBddlmvZvevZwneuZwe"dejxd&Zyd@d/dd5dJddddZzda{d/ddddZ|dId/d/d/dddZ}dAddZ~GdddeZdBd5dDddddZd5dddddZiZded<d5dddddZe dZdCdddYdd d d Zd dJd dddZe dZe dZeefd{ddd{dddZesdZddZe dZGdddZGdddZddZd d!Zd/d5dd"d#d$Zd5d5dd%d&ZdDd5dYd5d'd(d)Ze d*Zd5d+d5d,d-d.Zd{dDd/d0d1ZdDd2d3ZGd4d5d5ejxZejZe#e,e*ejfZdS(EzRoutines to help with the creation, loading and introspection of modules, classes, hierarchies, attributes, functions, and methods. ) annotationsNupdate_wrapper)CodeType)Any)Callable)cast)Dict) FrozenSet)Generic)Iterator)List)Mapping)NoReturn)Optional)overload)Sequence)Set)Tuple)Type) TYPE_CHECKING)TypeVar)Union) _collections)compat)HAS_CYEXTENSION)Literal)exc_T_T_coT) covariant_F.)bound_MPzmemoized_property[Any]_MAz#HasMemoized.memoized_attribute[Any]_HPzhybridproperty[Any]_HMzhybridmethod[Any]rMapping[str, Any]objreturncCs t|SN)inspectget_annotationsr+r1`/var/www/html/emsaiapi.evdpl.com/venv/lib/python3.9/site-packages/sqlalchemy/util/langhelpers.pyr/Asr/cCsBt|tr|jdd}n t|dd}|dur4tjStd|SdS)N__annotations__r)) isinstancetype__dict__getgetattrr EMPTY_DICTr)r+annr1r1r2r/Fs   str)xr,cCs*|d}t}||tt|S)Nzutf-8)encodermd5_not_for_securityupdaterr; hexdigest)r<mr1r1r2md5_hexWs  rBc@s@eZdZUdZdZded<ddddZd d d d d ddZdS) safe_reraiseaReraise an exception after invoking some handler code. Stores the existing exception info before invoking so that it is maintained across a potential coroutine context switch. e.g.:: try: sess.commit() except: with safe_reraise(): sess.rollback() TODO: we should at some point evaluate current behaviors in this regard based on current greenlet, gevent/eventlet implementations in Python 3, and also see the degree to which our own asyncio (based on greenlet also) is impacted by this. .rollback() will cause IO / context switch to occur in all these scenarios; what happens to the exception context from an "except:" block if we don't explicitly store it? Original issue was #2703. ) _exc_infozdUnion[None, Tuple[Type[BaseException], BaseException, types.TracebackType], Tuple[None, None, None]]rDNoner,cCst|_dSr-)sysexc_inforDselfr1r1r2 __enter__szsafe_reraise.__enter__zOptional[Type[BaseException]]zOptional[BaseException]zOptional[types.TracebackType]r)type_value tracebackr,cCs`|jdusJ|dur@|j\}}}|dus.Jd|_||nd|_|dusRJ||dSr-)rDwith_traceback)rJrLrMrNexc_type exc_valueexc_tbr1r1r2__exit__s    zsafe_reraise.__exit__N)__name__ __module__ __qualname____doc__ __slots__r3rKrSr1r1r1r2rC^s  rCzType[_T]zIterator[Type[_T]])clsr,ccsHt}|g}|rD|}||vr$q n |||||Vq dSr-)setpopaddextend__subclasses__)rYseenstackr1r1r2walk_subclassess ra)elementr,cCs8t|tr|Sz t|WSty2d|YS0dS)Nzunprintable element %r)r4r; Exception)rbr1r1r2string_or_unprintables    rdz Type[Any] Optional[str])rYuse_namer,cCs&|p|j}dddtd|DS)N css|]}|VqdSr-)lower).0nr1r1r2 z(clsname_as_plain_name..z([A-Z][a-z]+|SQL))rTjoinrefindall)rYrfnamer1r1r2clsname_as_plain_names rqzUnion[Type[Any], object]Callable[..., Any]bool)instance_or_clsagainst_methodr,cCs.t|ts|j}n|}|j}t||}||kS)z1Return True if the two class methods don't match.)r4r5 __class__rTr8)rtruZ current_cls method_nameZcurrent_methodr1r1r2method_is_overriddens   rxslicezTuple[Any, ...])slcr,cCs>g}|j|j|jfD] }t|dr*|}||qt|S)zrdecode a slice object as sent to __getitem__. takes into account the 2.5 __index__() method, basically. __index__)startstopstephasattrr{appendtuple)rzretr<r1r1r2 decode_slices   rz Sequence[str]z Iterator[str])usedbasesr,c'sht|}|D]Vtftfddtd}|D] }||vr4|||Vq q4tdq dS)Ncs t|Sr-r;)ibaser1r2rlz!_unique_symbols..iz&exhausted namespace for symbol base %s)rZ itertoolschainmapranger\ NameError)rrZused_setpoolsymr1rr2_unique_symbolss rzCallable[[int], Any]intz Iterator[Any])fnrjr,ccs*|r&||d@}||V||N}qdS)z6Call the given function given each nonzero bit from n.rNr1)rrjbr1r1r2map_bitss r_FnzCallable[[_Fn], _Fn])targetr,csdddfdd }t|S)z'A signature-matching decorator factory.rrr,c sNt|st|stdt|}i}t||}ttd|dtd|dd|j f}t |dd\}}t ||d}| t |d d |j |d <t|rd |d <d|d<nd|d <d|d<dt|dvrd|}nd|}tj|j}| t|| |||d|jittjt|||j } t|d|j| _|| _t| |S)Nznot a decoratable functionzTuple[str, ...]rrrr)rrFgroupedrpzasync prefixzawait Z target_prefix__zf%(prefix)sdef %(name)s%(grouped_args)s: return %(target_prefix)s%(target)s(%(fn)s, %(apply_pos)s) ze%(prefix)sdef %(name)s%(grouped_args)s: return %(target_prefix)s%(target)s(%(fn)s, %(apply_kw)s) rT__func__)r. isfunctionismethodrcrinspect_getfullargspec!_update_argspec_defaults_into_envrrrTrdictr?format_argspec_plusiscoroutinefunctionreprrGmodulesrUvarstypes FunctionType_exec_code_in_envr8 __defaults__ __wrapped__r) rspecenvnamesZ targ_namefn_namemetadatacodemodZ decoratedrr1r2decoratesN          zdecorator..decorater)rrr1rr2 decoratorsArcCs||jrtg}d}|jD]@}t|jdvrJd|}|||<|||d7}q||qt|}t||d<tj|S|SdS)zCgiven a FullArgSpec, convert defaults to be symbol names in an env.r)builtins __builtin__zx%drrN)defaultsr5rUrlistrr FullArgSpec)rr new_defaultsrargrpelemr1r1r2r=s      rzUnion[str, types.CodeType]Dict[str, Any])rrrr,cCst||||Sr-)exec)rrrr1r1r2rRs r_PF_TEc@sJeZdZddddddZddZdd d d d Zdddd dddZdS) PluginLoaderNr;zOptional[Callable[..., Any]])groupauto_fncCs||_i|_||_dSr-)rimplsr)rJrrr1r1r2__init__^szPluginLoader.__init__cCs|jdSr-)rclearrIr1r1r2reszPluginLoader.clearr)rpr,cCs||jvr|j|S|jr:||}|r:||j|<|St|jD]&}|j|krF|j|j|<|SqFtd|j|fdS)NzCan't load plugin: %s:%s) rrrimportlib_metadata_getrrploadrNoSuchModuleError)rJrploaderimplr1r1r2rhs       zPluginLoader.loadrE)rp modulepathobjnamer,csfdd}||j|<dS)Ncs4t}dddD]}t||}qt|S)N.r) __import__splitr8)rtokenrrr1r2r|s z#PluginLoader.register..load)r)rJrprrrr1rr2register{szPluginLoader.register)N)rTrUrVrrrrr1r1r1r2r]s rcCslz tj}Wn0ty:t|}|dt|dfYS0|j}|j}t|j d|t|j |@fSdS)Nrr) r.CO_VARKEYWORDSAttributeErrorrrrs__code__ co_argcountr co_varnamesco_flags)rZco_varkeywordsrconargsr1r1r2_inspect_func_argss    r)_setraiseerrr5zOptional[Set[str]]z Literal[True]zSet[str])rYrrr,cCsdSr-r1rYrrr1r1r2get_cls_kwargssrFcCsdSr-r1rr1r1r2rsc Cs|du}|rt}|dusJ|jdd}|oHt|tjoHt|jtj}|rt|\}}| ||s|s|rt d|dqdSnd}|r|r|j D]}t ||ddurqq| d|S)aeReturn the full set of inherited kwargs for the given `cls`. Probes a class's __init__ method, collecting all named arguments. If the __init__ defines a \**kwargs catch-all, then the constructor is presumed to pass along unrecognized keywords to its base classes, and the collection process is repeated recursively on each of the bases. Uses a subset of inspect.getfullargspec() to cut down on method overhead, as this is used within the Core typing system to create copies of type objects which is a performance-sensitive operation. No anonymous tuple arguments please ! NrFz given cls z doesn't have an __init__ method)rrJ)rZr6r7r4rrrrrr? TypeError __bases__rdiscard) rYrrtoplevelZctrZhas_initrZhas_kwcr1r1r2rs4        z List[str]funcr,cCst|dS)zReturn the set of legal kwargs for the given `func`. Uses getargspec so is safe to call for methods, functions, etc. r)rrrr1r1r2get_func_kwargssrzcompat.FullArgSpec)rno_self_is_initr,c CsDt|rtd|n&t|rn|rb|rbt|}t|jdd|j|j |j |j |j |j St|Snt|r|r|s|jrt|j}t|jdd|j|j |j |j |j |j St|jSntt|rt|j|ddSt|drt|jSt|dr4t|jr&t|j|dStd |n td |dS) zReturn the argument signature for any callable. All pure-Python callables are accepted, including functions, methods, classes, objects with __call__; builtins and other edge cases like functools.partial() objects raise a TypeError. zCan't inspect builtin: %srNT)rrr__call__)rzCan't inspect callable: %s)r. isbuiltinrrrrrargsvarargsvarkwr kwonlyargskwonlydefaultsrr__self__risclassget_callable_argspecrrr)rrrrr1r1r2rsN             rz-Union[Callable[..., Any], compat.FullArgSpec]zDict[str, Optional[str]])rrr,c Cst|rt|}n|}tj|}t|d|d|dd|d}|dr|dd}t|ddd|d|dd|d}n"|drd|d}|}nd}|}d}|dr|tttt|d7}|dr|t|d7}|d|d}|r |d|d} nd} tj||d|d| d d d } |drdtj|dd|d|d| d d d } n| } |rt|||| || d St|||dd| dd|dd| ddd SdS)aReturns a dictionary of formatted, introspected function arguments. A enhanced variant of inspect.formatargspec to support code generation. fn An inspectable callable or tuple of inspect getargspec() results. grouped Defaults to True; include (parens, around, argument) lists Returns: args Full inspect.formatargspec for fn self_arg The name of the first positional argument, varargs[0], or None if the function defines no positional arguments. apply_pos args, re-written in calling rather than receiving syntax. Arguments are passed positionally. apply_kw Like apply_pos, except keyword-ish args are passed as keywords. apply_pos_proxied Like apply_pos but omits the self/cls argument Example:: >>> format_argspec_plus(lambda self, a, b, c=3, **d: 123) {'grouped_args': '(self, a, b, c=3, **d)', 'self_arg': 'self', 'apply_kw': '(self, a, b, c=c, **d)', 'apply_pos': '(self, a, b, c, **d)'} rrrNz%s[0]rr1cSs dt|SN=rr<r1r1r2rsrlz%format_argspec_plus..) formatvaluecSs dt|Srrrr1r1r2r|rl) grouped_argsself_arg apply_posapply_kwapply_pos_proxiedapply_kw_proxied) callablerrinspect_formatargspeclenrrrr) rrrrrrr num_defaultsZ name_argsZdefaulted_valsrrr1r1r2r sv$   "        rcCsz|tjur(d}|rdnd}|r"dnd}n>zt||dWStydd}|rP|nd}|r\dnd }Yn0td|||||d S) a$format_argspec_plus with considerations for typical __init__ methods Wraps format_argspec_plus with error handling strategies for typical __init__ cases: .. sourcecode:: text object.__init__ -> (self) other unreflectable (usually C) -> (self, *args, **kwargs) z(self)rJz()rrz(self, *args, **kwargs)zself, *args, **kwargsz(*args, **kwargs)z*args, **kwargs)rrrrrr)objectrrrr)methodrrrZproxiedr1r1r2format_argspec_inits$    r r1zCallable[[_T], _T]) target_clstarget_cls_sphinx_nameproxy_cls_sphinx_name classmethodsmethods attributesuse_intermediate_variabler,cCs dd}|S)aSA class decorator indicating attributes should refer to a proxy class. This decorator is now a "marker" that does nothing at runtime. Instead, it is consumed by the tools/generate_proxy_methods.py script to statically generate proxy methods and attributes that are fully recognized by typing tools such as mypy. cSs|Sr-r1)rYr1r1r2rsz&create_proxy_methods..decorater1)rrrrrrrrr1r1r2create_proxy_methodssrcCsRz t|WStyL|tjur6dgdddfYSdgdddfYSYn0dS)ainspect.getargspec with considerations for typical __init__ methods Wraps inspect.getargspec with error handling for typical __init__ cases: .. sourcecode:: text object.__init__ -> (self) other unreflectable (usually C) -> (self, *args, **kwargs) rJNrkwargs)rrrr r)r r1r1r2getargspec_inits    rcCs t|tjr|js|jS|SdS)zSAdjust the incoming callable such that a 'self' argument is not required. N)r4r MethodTyperr)Z func_or_clsr1r1r2unbound_method_to_callablesrzSequence[Tuple[str, Any]]z%Optional[Union[object, List[object]]])r+ additional_kw to_inspect omit_kwargr,c sP|durg}n t|}tg}t}d}t|D]\}}zt|j} WntyfYq8Yq80| j rxt | j nd} |dkr| j r| j }| r| | j d| q| | j ddn$|fdd| j d| D| r8| j sJ|ddt| j | d| j Dq8g} | fdd|D|durjt|rj| d dt|D|D]d\} } | |vrqrz6t| }|ur|| kr| d | |fWntyYn0qr|r:|D]V\} } z6t| }|ur|| kr| d | |fWnty4Yn0qd jjd | fS) z}Produce a __repr__() based on direct association of the __init__() specification vs. same-named attributes present. Nrrcsg|] }|fqSr1r1rir)missingr1r2 rlz generic_repr..cSsg|]\}}||fqSr1r1)rirdefaultr1r1r2rsc3s|]}tt|dVqdSr-)rr8rr0r1r2rk"rlzgeneric_repr..cSsg|] }t|qSr1r)rivalr1r1r2r%rlz%s=%rz%s(%s), )rto_listr  OrderedDict enumeraterrrrrr rr]rr?ziprr8itemsrrcrvrTrm)r+rrrZpos_argsZkw_argsZvargsrZinsprZ default_lenoutputrZdefvalr"r1)rr+r2 generic_reprsj           r*c@s6eZdZdZdZddZddZd dd Zd d Zd S)portable_instancemethodz_Turn an instancemethod into a (parent, name) pair to produce a serializable callable. )rrpr __weakref__cCs|j|j|jdS)Nrrprr-rIr1r1r2 __getstate__Esz$portable_instancemethod.__getstate__cCs&|d|_|d|_|dd|_dS)Nrrprr1)rrpr7r)rJstater1r1r2 __setstate__Ls  z$portable_instancemethod.__setstate__r1cCs|j|_|j|_||_dSr-)rrrTrpr)rJmethrr1r1r2rQsz portable_instancemethod.__init__cOs$||jt|j|j|i|Sr-)r?rr8rrp)rJrkwr1r1r2rVs z portable_instancemethod.__call__N)r1) rTrUrVrWrXr.r0rrr1r1r1r2r+=s  r+cs|ht|j}|r|}fdd|jD}|D]}|||q4|jdkst|dsdqfddt|t s| n| |DD]}|||qqtS)a'Return an unordered sequence of all classes related to cls. Traverses diamond hierarchies. Fibs slightly: subclasses of builtin types are not returned. Thus class_hierarchy(class A(object)) returns (A, object), not A plus every class systemwide that derives from object. c3s|]}|vr|VqdSr-r1ri_Zhierr1r2rkjrlz"class_hierarchy..rr^csg|]}|vr|qSr1r1r3r5r1r2rssz#class_hierarchy..) r__mro__r[rrr\rUr issubclassr5r^)rYprocessrrrsr1r5r2class_hierarchy[s$       r:ccs@t|}|D].}|jD]"}||jvr||j|fVq qq dS)ziterate all the keys and attributes associated with a class, without using getattr(). Does not use getattr() so that class-sensitive descriptors (i.e. property.__get__()) are not called. N)dirr6r6)rYkeyskeyrr1r1r2iterate_attributess   r> self.proxyc s4|r |}n$durdfddt|D}|D]}z4t||}t|dsPWq2t|d|}ttj|} WntyYq2Yn0z2t| } t | d} t | ddd} Wnt yd } d } Yn0d t } |dur||ipi}t | |z| j ||_ WntyYn0t|||q2dS) z9Automates delegation of __specials__ for a proxying type.N)rX__del____getattribute__ __metaclass__r.r0cs6g|].}|dr|drt|s|vr|qS)r) startswithendswithrrirAinto_clsskipr1r2rs    z0monkeypatch_proxied_specials..rrrrz(self, *args, **kw)z (*args, **kw)z?def %(method)s%(fn_args)s: return %(name)s.%(method)s%(d_args)s)r;r8rrrrrrrrrlocalsrrsetattr)rGZfrom_clsrHonlyrpZ from_instanceZdundersr Zmaybe_fnrrZfn_argsZd_argspyrr1rFr2monkeypatch_proxied_specialssF            rMcCst|d|t|d|uS)z;Return True if the two methods are the same implementation.r)r8)Zmeth1Zmeth2r1r1r2methods_equivalents rNc Csp|s|stdt|tr(t||r(|St|p>ddt|D}tt|}tj}t|trd|}n|svt}tj}nt|}||||r|St|t s|tjurdpd}td||d |fGdd d }|rd |j |_ t} t |D]R\} } | |vrtd | t | s*td | | ft|| t| | | q|| |rV|Std d || dS)aEnsure basic interface compliance for an instance or dict of callables. Checks that ``obj`` implements public methods of ``cls`` or has members listed in ``methods``. If ``required`` is not supplied, implementing at least one interface method is sufficient. Methods present on ``obj`` that are not in the interface are ignored. If ``obj`` is a dict and ``dict`` does not meet the interface requirements, the keys of the dictionary are inspected. Keys present in ``obj`` that are not in the interface will raise TypeErrors. Raises TypeError if ``obj`` does not meet the interface criteria. In all passing cases, an object with callable members is returned. In the simple case, ``obj`` is returned as-is; if dict processing kicks in then an anonymous class is returned. obj A type, instance, or dictionary of callables. cls Optional, a type. All public methods of cls are considered the interface. An ``obj`` instance of cls will always pass, ignoring ``required``.. methods Optional, a sequence of method names to consider as the interface. required Optional, a sequence of mandatory implementations. If omitted, an ``obj`` that provides at least one interface method is considered sufficient. As a convenience, required may be a type, in which case all public methods of the type are required. z2a class or collection of method names are requiredcSsg|]}|ds|qS)r4)rCrEr1r1r2rrlz as_interface..zany ofzall ofz%r does not implement %s: %sr#c@seZdZdZdS)z(as_interface..AnonymousInterfacezA callable-holding shell.NrTrUrVrWr1r1r1r2AnonymousInterfacesrPZ Anonymousz%r: unknown in this interfacez%r=%r is not callablez,dictionary does not contain required keys %sN)rr4r5rZr;operatorgegt intersectionrrmrTdictlike_iteritemsrrJ staticmethodr\) r+rYrrequiredZ interfaceZ implementedZcompliesZ qualifierrPfoundr rr1r1r2 as_interfacesP!          rY_GFDzgeneric_fn_descriptor[Any]c@seZdZUdZded<ded<ded<d$ddd d d Zed d dd dddZeddddddZd ddddddZerddd dddZ dd dddZ dd ddd Z e ddd d!d"d#Z dS)%generic_fn_descriptoragDescriptor which proxies a function when the attribute is not present in dict This superclass is organized in a particular way with "memoized" and "non-memoized" implementation classes that are hidden from type checkers, as Mypy seems to not be able to handle seeing multiple kinds of descriptor classes used for the same attribute. zCallable[..., _T_co]fgetrerWr;rTNr\doccCs||_|p|j|_|j|_dSr-r\rWrTrJr\r^r1r1r2rDs zgeneric_fn_descriptor.__init__rZrErrJr+rYr,cCsdSr-r1rJr+rYr1r1r2__get__Iszgeneric_fn_descriptor.__get__r r!r+rYr,cCsdSr-r1rbr1r1r2rcLszUnion[_GFD, _T_co]cCs tdSr-NotImplementedErrorrbr1r1r2rcOsinstancerMr,cCsdSr-r1rJrhrMr1r1r2__set__Trlzgeneric_fn_descriptor.__set__rhr,cCsdSr-r1)rJrhr1r1r2 __delete__Vrlz generic_fn_descriptor.__delete__r*cCs tdSr-rerJr+r1r1r2_resetXszgeneric_fn_descriptor._reset)r+rpr,cCs tdSr-rerYr+rpr1r1r2reset[szgeneric_fn_descriptor.reset)N)rTrUrVrWr3rrrcrrjrlrn classmethodrpr1r1r1r2r[5s  r[c@seZdZdZesddZdS)_non_memoized_propertyza plain descriptor that proxies a function. primary rationale is to provide a plain attribute that's compatible with memoized_property which is also recognized as equivalent by mypy. cCs|dur |S||Sr-r\rbr1r1r2rcksz_non_memoized_property.__get__N)rTrUrVrWrrcr1r1r1r2rr`srrc@s0eZdZdZesddZddZeddZdS) _memoized_propertyz2A read-only @property that is only evaluated once.cCs&|dur |S|||j|j<}|Sr-)r\r6rTrJr+rYresultr1r1r2rcvsz_memoized_property.__get__cCst||jdSr-)rtrprTrmr1r1r2rn|sz_memoized_property._resetcCs|j|ddSr-)r6r[ror1r1r2rpsz_memoized_property.resetN) rTrUrVrWrrcrnrqrpr1r1r1r2rtqs rtrcsfdd}t|S)zDecorate a method memoize its return value. Best applied to no-arg methods: memoization is not sensitive to argument values, and will always return the same value even when called with different arguments. csB|g|Ri|fdd}j|_j|_||jj<S)NcsSr-r1ar2rvr1r2memosz6memoized_instancemethod..oneshot..memo)rTrWr6rJrr2rzrryr2oneshots   z(memoized_instancemethod..oneshotr)rr}r1r|r2memoized_instancemethods r~c@s~eZdZUdZesdZeZded<ddddZ ddd d Z d d dd ddZ Gddde e ZedddddZdS) HasMemoizedzA mixin class that maintains the names of memoized elements in a collection for easy cache clearing, generative, etc. r1zFrozenSet[str]_memoized_keysrErFcCs|jD]}|j|dqdSr-)rr6r[rJrr1r1r2_reset_memoizationss zHasMemoized._reset_memoizationscCs|jD]}||jvsJqdSr-)rr6rr1r1r2_assert_no_memoizationss z#HasMemoized._assert_no_memoizationsr;r)r=rMr,cCs||j|<|j|hO_dSr-)r6r)rJr=rMr1r1r2_set_memoized_attributes z#HasMemoized._set_memoized_attributec@sreZdZUdZded<ded<ded<dddd d d Zed d dd dddZeddddddZddZdS)zHasMemoized.memoized_attributezTA read-only @property that is only evaluated once. :meta private: Callable[..., _T]r\rerWr;rTNr]cCs||_|p|j|_|j|_dSr-r_r`r1r1r2rs z'HasMemoized.memoized_attribute.__init__r&rErracCsdSr-r1rbr1r1r2rcsz&HasMemoized.memoized_attribute.__get__r rdcCsdSr-r1rbr1r1r2rcscCs8|dur |S|||j|j<}|j|jhO_|Sr-)r\r6rTrrur1r1r2rcs )N)rTrUrVrWr3rrrcr1r1r1r2memoized_attributes rr#rcs"dddddfdd }t|S)zMDecorate a method memoize its return value. :meta private: r)rJrr2r,csT|g|Ri|fdd}j|_j|_||jj<|jjhO_S)NcsSr-r1rwryr1r2rzszBHasMemoized.memoized_instancemethod..oneshot..memo)rTrWr6rr{r|ryr2r}s  z4HasMemoized.memoized_instancemethod..oneshotr)rYrr}r1r|r2r~s z#HasMemoized.memoized_instancemethodN)rTrUrVrWrrX frozensetrr3rrrmemoized_propertyr rrqr~r1r1r1r2rs rc@s,eZdZdZdZddZddddd Zd S) MemoizedSlotszApply memoized items to an object using a __getattr__ scheme. This allows the functionality of memoized_property and memoized_instancemethod to be available to a class using __slots__. r1cCs t|dSr-)r)rJr=r1r1r2_fallback_getattrszMemoizedSlots._fallback_getattrr;r)r=r,csdsdrtn|tjdrRtd}t||Stjdrtdfdd}j|_|SSdS)NZ_memoized_attr_Z_memoized_method_cs:|i|fdd}j|_j|_t|S)NcsSr-r1rwryr1r2rz)sz8MemoizedSlots.__getattr__..oneshot..memo)rTrWrJ)rr2rzrr=rJryr2r}&s   z*MemoizedSlots.__getattr__..oneshot)rCrrrvr8rJrWr)rJr=rMr}r1rr2 __getattr__s   zMemoizedSlots.__getattr__N)rTrUrVrWrXrrr1r1r1r2r srcCsBt|tr:|}|dvr"dS|dvr.dStd|t|S)N)trueyesonyt1T)falsenooffrjf0FzString is not true/false: %r)r4r;striprh ValueErrorrsr0r1r1r2asbool8s   rz!Callable[[str], Union[str, bool]])textr,csdddfdd }|S)zqReturn a callable that will evaluate a string as boolean, or one of a set of "alternate" string values. r;zUnion[str, bool]r*cs|vr |St|SdSr-)rr0rr1r2 bool_or_valueJsz"bool_or_str..bool_or_valuer1)rrr1rr2 bool_or_strDsr Optional[int])rMr,cCs|dur |St|S)zCoerce to integer.N)r)rMr1r1r2asintSsrzOptional[Dict[str, Any]]rE)r2r=rL flexi_booldestr,cCsj|dur |}||vrft|tr,t|||sf||durf|turV|rVt||||<n|||||<dS)zIf 'key' is present in dict 'kw', coerce its value to type 'type\_' if necessary. If 'flexi_bool' is True, the string '0' is considered false when coercing to boolean. N)r4r5rsr)r2r=rLrrr1r1r2coerce_kw_type[s    rrdcs$t|}|ftfdd|DS)zbProduce a tuple structure that is cacheable using the __dict__ of obj to retrieve values c3s&|]}|jvr|j|fVqdSr-r6rikr0r1r2rk{sz"constructor_key..)rr)r+rYrr1r0r2constructor_keyusr)r+rYrr2r,cs4t|}|fdd||D||i|S)zInstantiate cls using the __dict__ of obj as constructor arguments. Uses inspect to match the named arguments of ``cls``. c3s&|]}|jvr|j|fVqdSr-rrr0r1r2rksz#constructor_copy..)rr? difference)r+rYrr2rr1r0r2constructor_copys rzCallable[[], int]rFcs$ttdfdd}|S)z%Return a threadsafe counter function.rcs0tWdS1s"0YdSr-)nextr1counterlockr1r2_nextszcounter.._next) threadingLockrcount)rr1rr2rs rzOptional[Type[Any]])specimenr r,cCst|dr*|jdur$t|jtr$tS|jSt|tr8tnt}||trJtS||trXtS||trftSt|drttSt|drtSt|drtS|SdS)zGiven an instance or class, guess if it is or is acting as one of the basic collection types: list, set and dict. If the __emulates__ property is present, return that preferentially. __emulates__Nrr\rZ)rrr7rZr4r5rr)rr Zisar1r1r2duck_type_collections(        rz'Union[Tuple[Type[Any], ...], Type[Any]])rargtyperpr,cCs^t||r|St|trBtd|ddd|Dt|fntd||t|fdS)Nz8Argument '%s' is expected to be one of type %s, got '%s'z or css|]}d|VqdS)z'%s'Nr1)rirxr1r1r2rkrlz"assert_arg_type..z6Argument '%s' is expected to be of type '%s', got '%s')r4rr ArgumentErrorrmr5)rrrpr1r1r2assert_arg_types   rcstdrtStdtdddur>tdtdr\fdd}|Std rtfd d DStddS) z?Return a (key, value) iterator for almost any dict-like object.r( __getitem__r7NzObject '%r' is not dict-likeiterkeysc3s,D]}dusJ||fVqdSr-)r)r=dictlikegetterr1r2iterators  z$dictlike_iteritems..iteratorr<c3s|]}||fVqdSr-r1)rir=)rr1r2rkrlz%dictlike_iteritems..)rrr(r8riterr<)rrr1rr2rUs     rUcsHeZdZUdZded<ddddfdd Zd dd dd d d ZZS) classpropertyaAA decorator that behaves like @property except that operates on classes rather than instances. The decorator is currently special when using the declarative module, but note that the :class:`~.sqlalchemy.ext.declarative.declared_attr` decorator should be used for this purpose with declarative. zCallable[[Any], Any]r\r)r\rr2cs&tj|g|Ri||j|_dSr-)superrrW)rJr\rr2rvr1r2rszclassproperty.__init__NzOptional[type]rdcCs ||Sr-rsrbr1r1r2rcszclassproperty.__get__)N)rTrUrVrWr3rrc __classcell__r1r1rr2rs  rc@s<eZdZddddZdddddd Zd d d d dZdS)hybridpropertyrrcCs||_||_dSr-)rclslevelrJrr1r1r2rszhybridproperty.__init__rr rhownerr,cCs$|dur||}|S||SdSr-rrrJrhrZclsvalr1r1r2rcs zhybridproperty.__get__rrzhybridproperty[_T]rcCs ||_|Sr-rrr1r1r2 classlevel szhybridproperty.classlevelN)rTrUrVrrcrr1r1r1r2rsrc@s^eZdZddddZdddddd Zddd d d d ZdddddZdddddZdS)rw_hybridpropertyrrcCs||_||_d|_dSr-)rrsetfnrr1r1r2rszrw_hybridproperty.__init__rr rcCs$|dur||}|S||SdSr-rrr1r1r2rcs zrw_hybridproperty.__get__rErgcCs|jdusJ|||dSr-rrir1r1r2rjszrw_hybridproperty.__set__rrzrw_hybridproperty[_T]rcCs ||_|Sr-rrr1r1r2setter szrw_hybridproperty.settercCs ||_|Sr-rrr1r1r2r$szrw_hybridproperty.classlevelN)rTrUrVrrcrjrrr1r1r1r2rs rc@s@eZdZdZddddZdddddd Zd d d d dZdS) hybridmethodz/Decorate a function as cls- or instance- level.rrcCs||_|_||_dSr-)rrrrr1r1r2r,s zhybridmethod.__init__rrcCs*|dur|j||jS|j||SdSr-)rrcrvr)rJrhrr1r1r2rc0szhybridmethod.__get__rrzhybridmethod[_T]rcCs ||_|Sr-rrr1r1r2r6szhybridmethod.classlevelN)rTrUrVrWrrcrr1r1r1r2r)src@s\eZdZUdZded<iZded<eZdddddd d d Z d d Z ddZ ddZ dS)symbolaIA constant symbol. >>> symbol("foo") is symbol("foo") True >>> symbol("foo") A slight refinement of the MAGICCOOKIE=object() pattern. The primary advantage of symbol() is its repr(). They are also singletons. Repeated calls of symbol('name') will all return the same instance. r;rpzDict[str, symbol]symbolsNrer)rpr^ canonicalr,cCs|j|j|}|durbt|ts*J|dur:t|}tt|}||_ |rV||_ ||j|<n |r||krt d|d||WdS1s0YdS)Nz#Can't replace canonical symbol for z with new int value ) _lockrr7r4r;hashr__new__rrprWr)rYrpr^rrr1r1r2rOs$    zsymbol.__new__cCst|jdt|ffS)Nr<)rrprrIr1r1r2 __reduce__mszsymbol.__reduce__cCst|Sr-r!rIr1r1r2__str__pszsymbol.__str__cCsd|jdS)Nzsymbol()rprIr1r1r2__repr__sszsymbol.__repr__)NN) rTrUrVrWr3rrrrrrrrr1r1r1r2r;s  rc@s0eZdZddddddddZd d d d Zd S) _IntFlagMetar;zTuple[Type[Any], ...]rrrE) classnamerdict_r2r,c Ksg|_}|D]Z\}}td|r(qt|tr@t||d}n|dstdnqt |||| |qt dd|D|_ dS)Nz^__.*__$)rr4z#Expected integer values for IntFlagcSsi|] }|j|qSr1r)rirr1r1r2 rlz)_IntFlagMeta.__init__..)Z_itemsr(rnmatchr4rrrCrrJrr immutabledict __members__) rYrrrr2r(rvrr1r1r2rxs        z_IntFlagMeta.__init__zIterator[symbol]rFcCs tddS)Nziter not implemented to ensure compatibility with Python 3.11 IntFlag. Please use __members__. See https://github.com/python/cpython/issues/99304rerIr1r1r2__iter__sz_IntFlagMeta.__iter__N)rTrUrVrrr1r1r1r2rwsrc@seZdZdZdS) _FastIntFlagzAn 'IntFlag' copycat that isn't slow when performing bitwise operations. the ``FastIntFlag`` class will return ``enum.IntFlag`` under TYPE_CHECKING and ``_FastIntFlag`` otherwise. NrOr1r1r1r2rsr) metaclass)IntFlag_EzDict[_E, List[Any]]z Optional[_E])rchoicesrpresolve_symbol_namesr,cCsn|D]>\}}||ur |S|r6||jkr6|S||vr|Sq|durTdStd|d|dS)aOGiven a user parameter, parse the parameter into a chosen value from a list of choice objects, typically Enum values. The user argument can be a string name that matches the name of a symbol, or the symbol object itself, or any number of alternate choices such as True/False/ None etc. :param arg: the user argument. :param choices: dictionary of enum values to lists of possible entries for each. :param name: name of the argument. Used in an :class:`.ArgumentError` that is raised if the parameter doesn't match any available argument. NzInvalid value for 'z': )r(rprr)rrrprZ enum_valuechoicer1r1r2parse_user_argument_for_enums rrkcCst|_td7adS)zAssign a '_creation_order' sequence to the given instance. This allows multiple instances to be sorted in order of creation (typically within a single thread; the counter is not particularly threadsafe). rN)_creation_order)rhr1r1r2set_creation_orders r)rrrr,cOs@z||i|WSty:tdtddYn0dS)zXexecutes the given function, catches all exceptions and converts to a warning. z%s('%s') ignoredrrN)rcwarnrGrH)rrrr1r1r2warn_exceptions rcCsDz(t||kr d|d|WS|WSWnty>|YS0dS)Nz%s...r)r r)rMZlen_r1r1r2ellipses_strings    rcsTeZdZUdZded<dddddfdd Zdd d d Zd d dddZZS)_hash_limit_stringa/A string subclass that can only be hashed on a maximum amount of unique values. This is used for warnings so that we can send out parameterized warnings without the __warningregistry__ of the module, or the non-overridable "once" registry within warnings.py, overloading memory, r_hashr; Sequence[Any])rMnumrr,cs<||d|}t||}td|t||f|_|S)Nz6 (this warning may be suppressed after %d occurrences)z%s_%d)rrrr)rYrMrrZ interpolatedrJrr1r2rs z_hash_limit_string.__new__rFcCs|jSr-)rrIr1r1r2__hash__ sz_hash_limit_string.__hash__rrs)otherr,cCst|t|kSr-)r)rJrr1r1r2__eq__sz_hash_limit_string.__eq__) rTrUrVrWr3rrrrr1r1rr2rs   r)msgrr,cCs(|rttj||dn t|tjdS)zdIssue a warning. If msg is a string, :class:`.exc.SAWarning` is used as the category. )rN)_warnings_warnr SAWarning)rrr1r1r2rsrr)rrr,cCs |rt|d|}t|tjdS)z\Issue a warning with a parameterized string, limiting the number of registrations. N)rrrr)rrr1r1r2 warn_limited s rz)Dict[CodeType, Tuple[str, Type[Warning]]] _warning_tagsz Type[Warning]zCallable[[_F], _F])messagecategoryr,csfdd}|S)Ncsft|j<|Sr-)rrr|rrr1r2go0sz#tag_method_for_warnings..gor1)rrrr1rr2tag_method_for_warnings-srz&^(?:sqlalchemy\.(?!testing)|alembic\.)zUnion[str, Warning]zOptional[Type[Warning]])rr stacklevelr,cCszt|}Wn$ty$d}Ynd}Yn0d}}|dur|sbtt|jddsbd}|jt vrd}t |j\}}|p|}|d|d}|j }|s|d7}q<|r<|r.gor1)rr rr1rr2 only_oncemsrz%sqlalchemy/([a-z_]+/){0,2}[a-z_]+\.pyzunit(?:2|test2?/)zre.Pattern[str])tbexclude_prefixexclude_suffixr,cCs`d}t|d}||kr0|||r0|d7}q||krP|||rP|d8}q0|||dS)atChop extraneous lines off beginning and end of a traceback. :param tb: a list of traceback lines as returned by ``traceback.format_stack()`` :param exclude_prefix: a regular expression object matching lines to skip at beginning of ``tb`` :param exclude_suffix: a regular expression object matching lines to skip at end of ``tb`` rr)r search)rrrr|endr1r1r2chop_tracebacks   rcCs$d|}t}t|||dS)Nz&def set(obj, value): obj.%s = valuerZ)rIcopyr)attrnamerrr1r1r2 attrsetters  rz^__.+__$cs*eZdZdZdZddfdd ZZS) TypingOnlyzA mixin class that marks a class as 'typing only', meaning it has absolutely no methods, attributes, or runtime functionality whatsoever. r1rErFcsBt|jvr4dd|jD}|r4td|d|dtdS)NcSsh|]}t|s|qSr1)_dundersrrirpr1r1r2 sz/TypingOnly.__init_subclass__..zClass z< directly inherits TypingOnly but has additional attributes r)rrr6AssertionErrorr__init_subclass__)rY remainingrr1r2r!s zTypingOnly.__init_subclass__)rTrUrVrWrXr!rr1r1rr2rsrcsDeZdZUdZded<ddfdd Zeddd d d ZZS) EnsureKWArga6Apply translation of functions to accept \**kw arguments if they don't already. Used to ensure cross-compatibility with third party legacy code, for things like compiler visit methods that need to accept ``**kw`` arguments, but may have been copied from old code that didn't accept them. r; ensure_kwargrErFcsf|j}|j}|rX|D]B}t||}|r||}t|}|js||}t|||qt dSr-) r$r6rnrrrr _wrap_w_kwrJrr!)rYZfn_regZclsdictr=rArrwrappedrr1r2r!s   zEnsureKWArg.__init_subclass__rrrcs ddddfdd }t|S)Nrrcs|Sr-r1)rr2r|r1r2wrapsz$EnsureKWArg._wrap_w_kw..wrapr)rYrr'r1r|r2r%szEnsureKWArg._wrap_w_kw) rTrUrVrWr3r!rqr%rr1r1rr2r#s   r#cCsjt|drt||S|}|jj|_t|dr4|j|_t|jdrT|jjrT|jj|_n|jrb|j|_|SdS)zAugment functools.update_wrapper() to work with objects with a ``__call__()`` method. :param fn: object with __call__ method rTrUrWN)rrrvrTrUrrW)wrapperr_fr1r1r2 wrap_callables     r*cCsd|vr|dSd}gg}d}t|}||kr||}|dkr|dkr|||dkr|||ddkr||dd|d7}q|dN}n*|dkr|dkr|gn|d||d7}q(dd|DS)aParse a dotted identifier with accommodation for quoted names. Includes support for SQL-style double quotes as a literal character. E.g.:: >>> quoted_token_parser("name") ["name"] >>> quoted_token_parser("schema.name") ["schema", "name"] >>> quoted_token_parser('"Schema"."Name"') ['Schema', 'Name'] >>> quoted_token_parser('"Schema"."Name""Foo"') ['Schema', 'Name""Foo'] "rrrrcSsg|]}d|qS)r)rm)rirr1r1r2r1rlz'quoted_token_parser..)rr r)rMr/rvidxlvcharr1r1r2quoted_token_parsers$ $    r/)paramsrr,cstfdd}|S)Ncs:|jdur|jpd}|r0t|fddD}||_|S)Nrcsi|] }|qSr1r1)riparamrr1r2r:rlz8add_parameter_text..decorate..)rWinject_param_text)rr^r0rr1r2r7s z$add_parameter_text..decorate)rr$)r0rrr1r3r2add_parameter_text4s r4cCsN|dd}t|dkr|S|\}}|ds@|dt|St|SdS)N rrg)rr rCtextwrapdedent)rZ split_text firstliner"r1r1r2_dedent_docstringAs   r9) given_doctext injecttextposr,cCst|pd}|d}t|dkr,|dt|d}|drP|ddddt|D}|dd|t|t|d}|d||||d}d |S)Nrr5rrcSsg|]\}}|s|qSr1)r)rirliner1r1r2rXrlz)inject_docstring_text..) r9rr rr6r7rr&minrm)r:r;r<doctextlinesZ injectlinesZblanksZ inject_posr1r1r2inject_docstring_textMs      rAz(\s+):param (.+?):zDict[str, str])r? inject_paramsr,c Cs t|}g}d}|r|}t|}|dur|r|dd}||vrdt|dd}|rt d|d} | rdt| d}|||}nV|r| d|dgd}n<| s| ||dgd}n| dr| ||gq| |qd|S) Nr*rgrz(\s+)\Srr5z::) collectionsdeque splitlinespopleft _param_regrrlstripr rnr]rstriprDrrm) r?rBZdoclinesr@Z to_injectr=rAr1indentZm2r1r1r2r2ds6   r2)rr,cCst|dkrdSt|dk}|r,|ddn|dd|dd}dd|D}|r`d|Sd d|dd|dfSdS) zTrims a list of strings from the middle and return a string of up to four elements. Strings greater than 11 characters will be truncatedrNrrrcSs,g|]$}t|dkr$d|ddn|qS) z%s..N)r rr1r1r2rrlz$repr_tuple_names..r#z %s, ..., %s)r rm)rflagresr1r1r2repr_tuple_namess  ( rOcCstrdS|rtdndSdS)NTzDcython extensions were expected to be installed, but are not presentF)r ImportError)Zraise_r1r1r2has_compiled_extsrQc@seZdZeZdS)_MissingN)rTrUrVenumautoMissingr1r1r1r2rRsrR)N)FF)T)T)r1r1r1r1)r1Nr1)NNr?N)NNN)TN)N)F)r)N)Nr)F)rW __future__rrDrS functoolsrr.rrQrnrGr6rrrtypingrrrr r r r r rrrrrrrrrrrr rrr_has_cyrrrr r!r#r%r&r'r(py310r/rBrCrardrqrxrrrrrrrrrrrrrrrr rrrr*r+r:r>rMrNrYrZr[rrrtrnon_memoized_propertypropertyro_memoized_propertyro_non_memoized_propertyr~r!HasMemoized_ro_memoized_attributerrrrrrrrrrrrUrrrrrrr5rrr FastIntFlagEnumrrrrrrr;rrrrr3rcompilerrrZ_SQLA_REZ _UNITTEST_RErNoneTyperrrr#r*r/r4r9rArHr2rOrQrRrUZ MissingOrr1r1r1r2 sl                                ;  G(5 9u %N& C V +M.   #<"  "      3     )  ,   +