U [h  @s UdZddlmZddlZddlZddlmZddlZddlZddl 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'j3rZdd/l4m5Z5dd0l4m6Z6d1d2Z7e8j9d3j:Z;d4d5ZZ>n*e'j?rtd6d8d<d?d>Z>nd6d8d<d@d>Z>d6dAdBdCdDZ@GdEdFdFZAdGdHdIdJdKZBd6dAdLdMdNZCd@dOdPdAdQdRdSZDdTdUdVdWdXdYZEdZd[d\d]d^ZFd_dAd`dadbdcZGdddedfdgdhdiZHe"djdUd&ZIdUdkdldmdnZJdodpdAdUdqdrdsZKe"dtZLe"duZMGdvdwdwZNdxdyZOedd%dzd{d|d}d~dddZPedddzd{d|dVd|dddZPdddzd{d|dVd|dddZPdUddddZQdAdUdVdVddddZRdBddVddddZSdCddZTdDdOdAdAd_d_d_d_ddddZUddZVddZWdEd6ddd_dAdddZXGdddZYddZZddZ[dFddZ\ddZ]dGddZ^e"ddd&Z_Gdddee-Z`Gddde`e-ZaGddde`e-Zbe!re`Zce`ZdeeZfeeZgnebZcZfeaZdZgd$d$dddZhGdddZie!rd?d?ejZejZe#e,e*ejfZdS(OzRoutines 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)Z covariant_F.)Zbound_MPzmemoized_property[Any]_MAz#HasMemoized.memoized_attribute[Any]_HPzhybridproperty[Any]_HMzhybridmethod[Any])call_annotate_function)FormatcCsBt|dd}|dk r>t|||d}t|ts:t|d|SdS)N __annotate__)ownerz!.__annotate__ returned a non-dict)getattrr' isinstancedict ValueError)objformatZannotateannr2A./venv/lib/python3.8/site-packages/sqlalchemy/util/langhelpers.py_get_and_call_annotateFs  r4__annotations__cCsjt|tr2z t|}WqJtk r.iYSXnt|dd}|dkrJiSt|tsbt|dt|S)Nr5z+.__annotations__ is neither a dict nor None)r,type_BASE_GET_ANNOTATIONSAttributeErrorr+r-r.r/r1r2r2r3_get_dunder_annotationsRs     r:rr(Mapping[str, Any])r/r0returncCsz t|}Wntk r YnX|dk r2t|St||}|dkrLt|}|dkrxt|tsft|rjiSt|d|siSt|S)z:A sparse implementation of annotationlib.get_annotations()Nz does not have annotations)r: Exceptionr-r4r,r6callable TypeError)r/r0r1r2r2r3_vendored_get_annotationsds   r@r/r<cCst|tjdS)N)r0)r@r(Z FORWARDREFr/r2r2r3get_annotationssrCcCs t|SN)inspectrCrBr2r2r3rCscCsBt|tr|jdd}n t|dd}|dkr4tjStd|SdS)Nr5r;)r,r6__dict__getr+rZ EMPTY_DICTrr9r2r2r3rCs   str)xr<cCs*|d}t}||tt|S)Nzutf-8)encoderZmd5_not_for_securityupdaterrHZ hexdigest)rImr2r2r3md5_hexs  rMc@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_infozfUnion[None, Tuple[Type[BaseException], BaseException, types.TracebackType], Tuple[(None, None, None)]]rONoner<cCst|_dSrD)sysexc_inforOselfr2r2r3 __enter__szsafe_reraise.__enter__zOptional[Type[BaseException]]zOptional[BaseException]zOptional[types.TracebackType]r)type_value tracebackr<cCs`|jdk st|dkr@|j\}}}|dk s.td|_||nd|_|dk sRt||dSrD)rOAssertionErrorwith_traceback)rUrWrXrYexc_type exc_valueexc_tbr2r2r3__exit__s    zsafe_reraise.__exit__N)__name__ __module__ __qualname____doc__ __slots__r5rVr_r2r2r2r3rNs  rNzType[_T]zIterator[Type[_T]])clsr<ccsHt}|g}|rD|}||kr$q n |||||Vq dSrD)setpopaddextend__subclasses__)reseenstackr2r2r3walk_subclassess rm)elementr<cCs:t|tr|Sz t|WStk r4d|YSXdS)Nzunprintable element %r)r,rHr=)rnr2r2r3string_or_unprintables   roz Type[Any] Optional[str])reuse_namer<cCs&|p|j}dddtd|DS)N css|]}|VqdSrD)lower).0nr2r2r3 sz(clsname_as_plain_name..z([A-Z][a-z]+|SQL))r`joinrefindall)rerqnamer2r2r3clsname_as_plain_names r{zUnion[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.)r,r6 __class__r`r+)r~rZ current_clsZ method_nameZcurrent_methodr2r2r3method_is_overriddens   rslicezTuple[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__)startstopstephasattrrappendtuple)rretrIr2r2r3 decode_slices   rz Sequence[str]z Iterator[str])usedbasesr<c'sht|}|D]Vtftfddtd}|D] }||kr4|||Vq q4tdq dS)Ncs t|SrDrH)ibaser2r3+z!_unique_symbols..iz&exhausted namespace for symbol base %s)rf itertoolschainmaprangerh NameError)rrZused_setZpoolsymr2rr3_unique_symbols&s rzCallable[[int], Any]intz Iterator[Any])fnrur<ccs*|r&||d@}||V||N}qdS)z6Call the given function given each nonzero bit from n.rNr2)rrubr2r2r3map_bits6s r_FnzCallable[[_Fn], _Fn])targetr<csdddfdd }t|S)z'A signature-matching decorator factory.rrr<c st|st|stdt|dd}|dk rPd|_zt|}W5||_Xn t|}dt|j pfd}t |j pxd}|j i||d}ttd|dtd|dd |jf}t|d d \}}t ||d }|t|d d|j|d<t|rd|d<d|d<nd|d<d|d<dt|dkr:d|} nd|} |||d|ji} ttjt| | |j} |j| _|j| _t| |S)Nznot a decoratable functionr)rDr2)rdefaultskwonlydefaultszTuple[str, ...]rrrr)rrFgroupedrzzasync 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) r`)rE isfunctionismethodr=r+r)rinspect_getfullargspeclenrr-fromkeysr_replacerrr`rrKformat_argspec_plusZiscoroutinefunctionreprratypes FunctionType_exec_code_in_env __defaults____kwdefaults__r) rZannofuncspecZempty_defaultsZempty_kwdefaultsnamesZ targ_namefn_nameZmetadatacodeenvZ decoratedrr2r3decorateGsl           zdecorator..decorater)rrr2rr3 decoratorDsVrzUnion[str, types.CodeType]Dict[str, Any])rrrr<cCst||||SrD)exec)rrrr2r2r3rs r_PF_TEc@sZeZdZddddddZddZdd d d d Zdddd dddZdd d ddZdS) PluginLoaderNrHzOptional[Callable[..., Any]])groupauto_fncCs||_i|_||_dSrD)rimplsr)rUrrr2r2r3__init__szPluginLoader.__init__cCs|jdSrD)rclearrTr2r2r3rszPluginLoader.clearr)rzr<cCs||jkr|j|S|jr:||}|r:||j|<|St|jD]&}|j|krF|j|j|<|SqFtd|j|fdS)NzCan't load plugin: %s:%s) rrrZimportlib_metadata_getrrzloadrZNoSuchModuleError)rUrzloaderimplr2r2r3rs       zPluginLoader.loadrP)rz modulepathobjnamer<csfdd}||j|<dS)Ncs4t}dddD]}t||}qt|S)N.r) __import__splitr+)modtokenrrr2r3rs z#PluginLoader.register..loadr)rUrzrrrr2rr3registerszPluginLoader.registercCs |j|=dSrDr)rUrzr2r2r3 deregisterszPluginLoader.deregister)N)r`rarbrrrrrr2r2r2r3rs  rcCsnz tj}Wn2tk r<t|}|dt|dfYSX|j}|j}t|j d|t|j |@fSdS)Nrr) rEZCO_VARKEYWORDSr8rrr}__code__ co_argcountlist co_varnamesco_flags)rZco_varkeywordsrconargsr2r2r3_inspect_func_argss   r)_setraiseerrr6zOptional[Set[str]]z Literal[True]zSet[str])rerrr<cCsdSrDr2rerrr2r2r3get_cls_kwargssrFcCsdSrDr2rr2r2r3rsc Cs|dk}|rt}|dk st|jdd}|oHt|tjoHt|jtj}|rt |\}}| ||s|s|rt d|dqdSnd}|r|r|j D]}t ||ddkrqq|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)rrU)rfrZrFrGr,rrrrrrKr? __bases__rdiscard) rerrZtoplevelZctrZhas_initrZhas_kwcr2r2r3rs4        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)rrrr2r2r3get_func_kwargs.srzcompat.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)rr__func____call__)rzCan't inspect callable: %s)rEZ isbuiltinr?rrrZ FullArgSpecargsvarargsvarkwrZ kwonlyargsrrr__self__rZisclassget_callable_argspecrrr)rrrrr2r2r3r9sR             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]rr2cSs dt|SN=rrIr2r2r3rrz%format_argspec_plus..)Z formatvaluecSs dt|Srrrr2r2r3rr) grouped_argsself_arg apply_posapply_kwapply_pos_proxiedapply_kw_proxied) r>rrinspect_formatargspecrrrrr-) rrrrrrrZ num_defaultsZ name_argsZdefaulted_valsrrr2r2r3rqs$           rcCs||tjkr(d}|rdnd}|r"dnd}n@zt||dWStk rfd}|rR|nd}|r^dnd }YnXtd|||||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)rUz()rrz(self, *args, **kwargs)zself, *args, **kwargsz(*args, **kwargs)z*args, **kwargs)rrrrrr)objectrrr?r-)methodrrrZproxiedr2r2r3format_argspec_inits$   rr2zCallable[[_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|SrDr2)rer2r2r3rsz&create_proxy_methods..decorater2)rrrrrrr rr2r2r3create_proxy_methodssr cCsTz t|WStk rN|tjkr8dgdddfYSdgdddfYSYnXdS)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) rUNrkwargs)rrr?rr)rr2r2r3getargspec_init s   r cCs t|tjr|js|jS|SdS)zSAdjust the incoming callable such that a 'self' argument is not required. N)r,r MethodTyperr)Z func_or_clsr2r2r3unbound_method_to_callable4srzSequence[Tuple[str, Any]]z%Optional[Union[object, List[object]]])r/ additional_kw to_inspect omit_kwargr<c sV|dkrg}n t|}tg}t}d}t|D]\}}zt|j} Wntk rhYq8Yq8X| j rzt | j nd} |dkr| j r| j }| r| | j d| q| | j ddn$|fdd| j d| D| r8| j st|ddt| j | d| j Dq8g} | fdd|D|dk rlt|rl| d dt|D|D]f\} } | |krqtz6t| }|k r|| kr| d | |fWntk rYnXqt|r@|D]X\} } z6t| }|k r"|| kr"| d | |fWntk r:YnXqd jjd | fS) z}Produce a __repr__() based on direct association of the __init__() specification vs. same-named attributes present. Nrrcsg|] }|fqSr2r2rtarg)missingr2r3 dsz generic_repr..cSsg|]\}}||fqSr2r2)rtrdefaultr2r2r3rjsc3s|]}tt|dVqdSrD)rr+rrBr2r3rvsszgeneric_repr..cSsg|] }t|qSr2r)rtvalr2r2r3rvsz%s=%rz%s(%s), )rto_listr OrderedDict enumeraterrrr?rrrrirrKrZziprr+itemsrr=rr`rw)r/rrrZpos_argsZkw_argsZvargsrZinsprZ default_lenoutputrZdefvalrr2)rr/r3 generic_repr@sl          r c@s6eZdZdZdZddZddZd dd Zd d Zd S)portable_instancemethodz_Turn an instancemethod into a (parent, name) pair to produce a serializable callable. )rrzr  __weakref__cCs|j|j|jdS)Nrrzr r#rTr2r2r3 __getstate__sz$portable_instancemethod.__getstate__cCs&|d|_|d|_|dd|_dS)Nrrzr r2)rrzrGr )rUstater2r2r3 __setstate__s  z$portable_instancemethod.__setstate__r2cCs|j|_|j|_||_dSrD)rrr`rzr )rUmethr r2r2r3rsz portable_instancemethod.__init__cOs ||jt|j|j||SrD)rKr r+rrz)rUrkwr2r2r3rs z portable_instancemethod.__call__N)r2) r`rarbrcrdr$r&rrr2r2r2r3r!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|]}|kr|VqdSrDr2rt_Zhierr2r3rvsz"class_hierarchy..builtinsrjcsg|]}|kr|qSr2r2r)r+r2r3rsz#class_hierarchy..) r__mro__rgrrrhrar issubclassr6rj)reZprocessrrrsr2r+r3class_hierarchys$       r0ccs@t|}|D].}|jD]"}||jkr||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)dirr-rF)rekeyskeyrr2r2r3iterate_attributess   r4 self.proxyc s<|r |}n$dkrdfddt|D}|D]}z4t||}t|dsRWq2t|d|}ttj|} Wntk rYq2YnXz2t| } t | d} t | ddd} Wnt k rd } d } YnXd t } |dk r||ipi}t | |z| j ||_ Wntk r$YnXt|||q2dS) z9Automates delegation of __specials__ for a proxying type.N)rd__del____getattribute__Z __metaclass__r$r&cs6g|].}|dr|drt|s|kr|qS)r) startswithendswithrrtrLinto_clsskipr2r3rs    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)r1r+rrrrr8rrrr?localsrrsetattr)r<Zfrom_clsr=ZonlyrzZ from_instanceZdundersrZmaybe_fnrrZfn_argsZd_argspyrr2r;r3monkeypatch_proxied_specialssF          rAcCst|d|t|d|kS)z;Return True if the two methods are the same implementation.r)r+)Zmeth1Zmeth2r2r2r3methods_equivalent%s  rBc Csp|s|stdt|tr(t||r(|St|p>ddt|D}tt|}tj}t|trd|}n|svt}tj}nt|}||||r|St|t s|tjkrdpd}td||d |fGdd d }|rd |j |_ t} t |D]R\} } | |krtd | 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)r*)r8r:r2r2r3rTs z as_interface..zany ofzall ofz%r does not implement %s: %src@seZdZdZdS)z(as_interface..AnonymousInterfacezA callable-holding shell.Nr`rarbrcr2r2r2r3AnonymousInterfaceksrDZ Anonymousz%r: unknown in this interfacez%r=%r is not callablez,dictionary does not contain required keys %sN)r?r,r6rfr1operatorgegt intersectionr-rwr`dictlike_iteritemsr>r? staticmethodrh) r/rerrequiredZ interfaceZ implementedZcompliesZ qualifierrDfoundrrr2r2r3 as_interface-sP!          rM_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]fgetrprcrHr`NrPdoccCs||_|p|j|_|j|_dSrDrPrcr`rUrPrRr2r2r3rs zgeneric_fn_descriptor.__init__rNrPrrUr/rer<cCsdSrDr2rUr/rer2r2r3__get__szgeneric_fn_descriptor.__get__rr!r/rer<cCsdSrDr2rVr2r2r3rWszUnion[_GFD, _T_co]cCs tdSrDNotImplementedErrorrVr2r2r3rWsinstancerXr<cCsdSrDr2rUr\rXr2r2r3__set__rzgeneric_fn_descriptor.__set__r\r<cCsdSrDr2)rUr\r2r2r3 __delete__rz generic_fn_descriptor.__delete__rAcCs tdSrDrYrUr/r2r2r3_resetszgeneric_fn_descriptor._reset)r/rzr<cCs tdSrDrYrer/rzr2r2r3resetszgeneric_fn_descriptor.reset)N)r`rarbrcr5rrrWrr^r`rb classmethodrdr2r2r2r3rOs  rOc@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|dkr |S||SrDrPrVr2r2r3rWsz_non_memoized_property.__get__N)r`rarbrcrrWr2r2r2r3rfsrfc@s0eZdZdZesddZddZeddZdS) _memoized_propertyz2A read-only @property that is only evaluated once.cCs&|dkr |S|||j|j<}|SrD)rPrFr`rUr/reresultr2r2r3rWsz_memoized_property.__get__cCst||jdSrD)rhrdr`rar2r2r3rbsz_memoized_property._resetcCs|j|ddSrD)rFrgrcr2r2r3rdsz_memoized_property.resetN) r`rarbrcrrWrbrerdr2r2r2r3rhs rhrcsfdd}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. cs<|f||fdd}j|_j|_||jj<S)NcsSrDr2ar(rjr2r3memosz6memoized_instancemethod..oneshot..memo)r`rcrFrUrr(rnrrmr3oneshots   z(memoized_instancemethod..oneshotr)rrqr2rpr3memoized_instancemethods rrc@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. r2zFrozenSet[str]_memoized_keysrPrQcCs|jD]}|j|dqdSrD)rtrFrgrUelemr2r2r3_reset_memoizationss zHasMemoized._reset_memoizationscCs|jD]}||jkstqdSrD)rtrFrZrur2r2r3_assert_no_memoizationss z#HasMemoized._assert_no_memoizationsrHr)r3rXr<cCs||j|<|j|hO_dSrD)rFrt)rUr3rXr2r2r3_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]rPrprcrHr`NrQcCs||_|p|j|_|j|_dSrDrSrTr2r2r3r,s z'HasMemoized.memoized_attribute.__init__r$rPrrUcCsdSrDr2rVr2r2r3rW1sz&HasMemoized.memoized_attribute.__get__r rXcCsdSrDr2rVr2r2r3rW4scCs8|dkr |S|||j|j<}|j|jhO_|SrD)rPrFr`rtrir2r2r3rW7s )N)r`rarbrcr5rrrWr2r2r2r3memoized_attribute!s r{r"rcs"dddddfdd }t|S)zMDecorate a method memoize its return value. :meta private: r)rUrr(r<csN|f||fdd}j|_j|_||jj<|jjhO_S)NcsSrDr2rkrmr2r3rnIszBHasMemoized.memoized_instancemethod..oneshot..memo)r`rcrFrtrorprmr3rqFs  z4HasMemoized.memoized_instancemethod..oneshotr)rerrqr2rpr3rr>s z#HasMemoized.memoized_instancemethodN)r`rarbrcrrd frozensetrtr5rwrxrymemoized_propertyr r{rerrr2r2r2r3rss rsc@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__. r2cCs t|dSrD)r8)rUr3r2r2r3_fallback_getattreszMemoizedSlots._fallback_getattrrHr)r3r<csdsdrtn|tjdrRtd}t||Stjdrtdfdd}j|_|SSdS)NZ_memoized_attr_Z_memoized_method_cs6||fdd}j|_j|_t|S)NcsSrDr2rkrmr2r3rnzsz8MemoizedSlots.__getattr__..oneshot..memo)r`rcr?)rr(rnrr3rUrmr3rqws    z*MemoizedSlots.__getattr__..oneshot)r8r8rrr+r?rcr)rUr3rXrqr2rr3 __getattr__hs   zMemoizedSlots.__getattr__N)r`rarbrcrdrrr2r2r2r3r~[sr~cCsBt|tr:|}|dkr"dS|dkr.dStd|t|S)N)trueZyesZonyt1T)ZfalsenoZoffruf0FzString is not true/false: %r)r,rHstriprsr.r}rBr2r2r3asbools   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. rHzUnion[str, bool]rAcs|kr |St|SdSrD)rrBrr2r3 bool_or_valuesz"bool_or_str..bool_or_valuer2)rrr2rr3 bool_or_strsr Optional[int])rXr<cCs|dkr |St|S)zCoerce to integer.N)r)rXr2r2r3asintsrzOptional[Dict[str, Any]]rP)r(r3rW flexi_booldestr<cCsj|dkr |}||krft|tr,t|||sf||dk rf|tkrV|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)r,r6r}r)r(r3rWrrr2r2r3coerce_kw_types    rrXcs$t|}|ftfdd|DS)zbProduce a tuple structure that is cacheable using the __dict__ of obj to retrieve values c3s&|]}|jkr|j|fVqdSrDrFrtkrBr2r3rvs z"constructor_key..)rr)r/rerr2rBr3constructor_keysr)r/rerr(r<cs0t|}|fdd||D|||S)zInstantiate cls using the __dict__ of obj as constructor arguments. Uses inspect to match the named arguments of ``cls``. c3s&|]}|jkr|j|fVqdSrDrrrBr2r3rvs z#constructor_copy..)rrK difference)r/rerr(rr2rBr3constructor_copys rzCallable[[], int]rQcs$ttdfdd}|S)z%Return a threadsafe counter function.rc s$tW5QRSQRXdSrD)nextr2counterlockr2r3_nextszcounter.._next) threadingLockrcount)rr2rr3rs rzOptional[Type[Any]])specimenrr<cCst|dr*|jdk r$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__Nrrhrf)rrr.rfr,r6rr-)rrZisar2r2r3duck_type_collections*        rz'Union[Tuple[Type[Any], ...], Type[Any]])rargtyperzr<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'Nr2)rtrlr2r2r3rvsz"assert_arg_type..z6Argument '%s' is expected to be of type '%s', got '%s')r,rr ArgumentErrorrwr6)rrrzr2r2r3assert_arg_types   rcstdrtStdtdddkr>tdtdr\fdd}|Std rtfd d DStddS) z?Return a (key, value) iterator for almost any dict-like object.r __getitem__rGNzObject '%r' is not dict-likeiterkeysc3s,D]}dk st||fVqdSrD)rrZ)r3dictlikegetterr2r3iterator.s  z$dictlike_iteritems..iteratorr2c3s|]}||fVqdSrDr2)rtr3)rr2r3rv5sz%dictlike_iteritems..)rrrr+r?iterr2)rrr2rr3rI"s     rIcsHeZdZUdZded<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]rPr)rPrr(cs tj|f|||j|_dSrD)superrrc)rUrPrr(rr2r3rGszclassproperty.__init__NzOptional[type]rXcCs ||SrDrgrVr2r2r3rWKszclassproperty.__get__)N)r`rarbrcr5rrW __classcell__r2r2rr3r:s  rc@s<eZdZddddZdddddd Zd d d d dZdS)hybridpropertyrzrcCs||_||_dSrD)rclslevelrUrr2r2r3rPszhybridproperty.__init__rr r\r*r<cCs$|dkr||}|S||SdSrDrrrUr\r*Zclsvalr2r2r3rWTs zhybridproperty.__get__r|zhybridproperty[_T]rcCs ||_|SrDrrr2r2r3 classlevel[szhybridproperty.classlevelN)r`rarbrrWrr2r2r2r3rOsrc@s^eZdZddddZdddddd Zddd d d d ZdddddZdddddZdS)rw_hybridpropertyrzrcCs||_||_d|_dSrD)rrsetfnrr2r2r3raszrw_hybridproperty.__init__rr rcCs$|dkr||}|S||SdSrDrrr2r2r3rWfs zrw_hybridproperty.__get__rPr[cCs|jdk st|||dSrD)rrZr]r2r2r3r^mszrw_hybridproperty.__set__r|zrw_hybridproperty[_T]rcCs ||_|SrD)rrr2r2r3setterqszrw_hybridproperty.settercCs ||_|SrDrrr2r2r3ruszrw_hybridproperty.classlevelN)r`rarbrrWr^rrr2r2r2r3r`s rc@s@eZdZdZddddZdddddd Zd d d d dZdS) hybridmethodz/Decorate a function as cls- or instance- level.rzrcCs||_|_||_dSrD)rrrrr2r2r3r}s zhybridmethod.__init__rrcCs*|dkr|j||jS|j||SdSrD)rrWrr)rUr\r*r2r2r3rWszhybridmethod.__get__r|zhybridmethod[_T]rcCs ||_|SrDrrr2r2r3rszhybridmethod.classlevelN)r`rarbrcrrWrr2r2r2r3rzsrc@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. rHrzzDict[str, symbol]symbolsNrpr)rzrR canonicalr<c Cs|j|j|}|dkrbt|ts*t|dkr:t|}tt |}||_ |rV||_ ||j|<n |r||krt d|d||W5QRSQRXdS)Nz#Can't replace canonical symbol for z with new int value ) _lockrrGr,rHrZhashr__new__rrzrcr?)rerzrRrrr2r2r3rs     zsymbol.__new__cCst|jdt|ffS)NrI)rrzrrTr2r2r3 __reduce__szsymbol.__reduce__cCst|SrDrrTr2r2r3__str__szsymbol.__str__cCsd|jdS)Nzsymbol()rzrTr2r2r3__repr__szsymbol.__repr__)NN) r`rarbrcr5rrrrrrrrr2r2r2r3rs  rc@s0eZdZddddddddZd d d d Zd S) _IntFlagMetarHzTuple[Type[Any], ...]rrrP) classnamerdict_r(r<c Ksg|_}|D]Z\}}td|r(qt|tr@t||d}n|dstdnqt |||| |qt dd|D|_ dS)Nz^__.*__$)rr*z#Expected integer values for IntFlagcSsi|] }|j|qSr2r)rtrr2r2r3 sz)_IntFlagMeta.__init__..)Z_itemsrrxmatchr,rrr8r?r?rrZ immutabledict __members__) rerrrr(rrvrr2r2r3rs        z_IntFlagMeta.__init__zIterator[symbol]rQcCs tddS)Nziter not implemented to ensure compatibility with Python 3.11 IntFlag. Please use __members__. See https://github.com/python/cpython/issues/99304rYrTr2r2r3__iter__sz_IntFlagMeta.__iter__N)r`rarbrrr2r2r2r3rsrc@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. NrCr2r2r2r3rsr) metaclass)IntFlag_EzDict[_E, List[Any]]z Optional[_E])rchoicesrzresolve_symbol_namesr<cCsn|D]>\}}||kr |S|r6||jkr6|S||kr|Sq|dkrTdStd|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': )rrzrr)rrrzrZ enum_valuechoicer2r2r3parse_user_argument_for_enums rr_cCst|_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)r\r2r2r3set_creation_order$s r)rrr r<cOs>z |||WStk r8tdtddYnXdS)zXexecutes the given function, catches all exceptions and converts to a warning. z%s('%s') ignoredrrN)r=warnrRrS)rrr r2r2r3warn_exception1s rcCsFz(t||kr d|d|WS|WSWntk r@|YSXdS)Nz%s...r)rr?)rXZlen_r2r2r3ellipses_string<s   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_hashrH Sequence[Any])rXnumrr<cs<||d|}t||}td|t||f|_|S)Nz6 (this warning may be suppressed after %d occurrences)z%s_%d)rrrr)rerXrrZ interpolatedrUrr2r3rSs z_hash_limit_string.__new__rQcCs|jSrD)rrTr2r2r3__hash__]sz_hash_limit_string.__hash__rr})otherr<cCst|t|kSrD)r)rUrr2r2r3__eq__`sz_hash_limit_string.__eq__) r`rarbrcr5rrrrr2r2rr3rFs   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)rrr2r2r3rdsrr)rrr<cCs |rt|d|}t|tjdS)z\Issue a warning with a parameterized string, limiting the number of registrations. N)rrrr)rrr2r2r3 warn_limitedqs rz)Dict[CodeType, Tuple[str, Type[Warning]]] _warning_tagsz Type[Warning]zCallable[[_F], _F])messagecategoryr<csfdd}|S)Ncsft|j<|SrD)rrrprrr2r3gosz#tag_method_for_warnings..gor2)rrrr2rr3tag_method_for_warnings~srz&^(?:sqlalchemy\.(?!testing)|alembic\.)zUnion[str, Warning]zOptional[Type[Warning]])rr stacklevelr<cCszt|}Wn&tk r&d}Ynd}YnXd}}|dk r|sdtt|jddsdd}|jt krd}t |j\}}|p|}|d|d}|j }|s|d7}q>|r>|r>qq>|dk rt j |||dd nt j ||dd dS) NrFr`rTz (rr)r) rR _getframer.rxr_not_sa_pattern f_globalsrGf_coderf_backwarningsr)rrrframeZstacklevel_foundZwarning_tag_foundZ_suffixZ _categoryr2r2r3rs4    rrzzCallable[..., Optional[_T]])rretry_on_exceptionr<cs$gddddfdd }|S)zNDecorate the given function to be a no-op after it is called exactly once.rz Optional[_T]rr(r<cs@}r<}z |||WSr4d|YnXdS)Nr)rginsert)rr(Z strong_fnZonce_fnroncerr2r3rs  zonly_once..gor2)rrrr2rr3 only_oncesrz%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)rsearch)rrrrendr2r2r3chop_tracebacks   rcCs$d|}t}t|||dS)Nz&def set(obj, value): obj.%s = valuerf)r>copyr)attrnamerrr2r2r3 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. r2rPrQcsBt|jkr4dd|jD}|r4td|d|dtdS)NcSsh|]}t|s|qSr2)_dundersrrtrzr2r2r3 s z/TypingOnly.__init_subclass__..zClass z< directly inherits TypingOnly but has additional attributes r)r rrFrZr__init_subclass__)re remainingrr2r3r  s zTypingOnly.__init_subclass__)r`rarbrcrdr rr2r2rr3r sr csDeZdZUdZded<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. rH ensure_kwargrPrQcsf|j}|j}|rX|D]B}t||}|r||}t|}|js||}t|||qt dSrD) rrFrxrrrr _wrap_w_kwr?rr )reZfn_regZclsdictr3rLrrwrappedrr2r3r +s   zEnsureKWArg.__init_subclass__r|rcs ddddfdd }t|S)Nrrcs|SrDr2)rr(rpr2r3wrap;sz$EnsureKWArg._wrap_w_kw..wrapr)rerrr2rpr3r9szEnsureKWArg._wrap_w_kw) r`rarbrcr5r rerrr2r2rr3rs   rcCsjt|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 r`rarcN)rrrr`rarrc)wrapperrZ_fr2r2r3 wrap_callableAs     rcCsd|kr|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)rw)rtrr2r2r3rsz'quoted_token_parser..)rrr)rXr%rjidxlvcharr2r2r3quoted_token_parserYs$ $    r)paramsrr<cstfdd}|S)Ncs:|jdk r|jpd}|r0t|fddD}||_|S)Nrcsi|] }|qSr2r2)rtparamrr2r3rsz8add_parameter_text..decorate..)rcinject_param_text)rrRrrr2r3rs z$add_parameter_text..decorate)rr)rrrr2rr3add_parameter_texts rcCsN|dd}t|dkr|S|\}}|ds@|dt|St|SdS)N rrr)rrr8textwrapdedent)rZ split_text firstlinerr2r2r3_dedent_docstrings   r$) given_doctext injecttextposr<cCst|pd}|d}t|dkr,|dt|d}|drP|ddddt|D}|dd|t|t|d}|d||||d}d |S)Nrr rrcSsg|]\}}|s|qSr2)r)rtrliner2r2r3rsz)inject_docstring_text..) r$rrrr!r"rrminrw)r%r&r'doctextlinesZ injectlinesZblanksZ inject_posr2r2r3inject_docstring_texts      r,z(\s+):param (.+?):zDict[str, str])r* inject_paramsr<c Cs t|}g}d}|r|}t|}|dkr|r|dd}||krdt|dd}|rt d|d} | rdt| d}|||}nV|r| d|dgd}n<| s| ||dgd}n| dr| ||gq| |qd|S) Nr*rrrz(\s+)\Srr z::) collectionsdeque splitlinespopleft _param_regrrlstriprrxrirstripr9rrw) r*r-Zdoclinesr+Z to_injectr(rLrindentZm2r2r2r3rs6   r)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)rr r2r2r3rsz$repr_tuple_names..rz %s, ..., %s)rrw)rflagresr2r2r3repr_tuple_namess  ( r:cCstrdS|rtdndSdS)NTzDcython extensions were expected to be installed, but are not presentF)r ImportError)Zraise_r2r2r3has_compiled_extsr<c@seZdZeZdS)_MissingN)r`rarbenumautoMissingr2r2r2r3r=sr=)N)FF)T)T)r2r2r2r2)r2Nr2)NNr5N)NNN)TN)N)F)r)N)Nr)F)rcZ __future__rr/r> functoolsrrErrErxrRr!rrrtypingrrrr r r r r rrrrrrrrrrrrrrrZ_has_cyrrrr r!r"r#r$r%r&Zpy314Z annotationlibr'r(r4r6rFrWr7r:r@rCZpy310rMrNrmror{rrrrrrrrrrrrrrrrr r rr r!r0r4rArBrMrNrOrfrhr}Znon_memoized_propertypropertyZro_memoized_propertyZro_non_memoized_propertyrrrsZ!HasMemoized_ro_memoized_attributer{r~rrrrrrrrrrIrrrrrrrrrZ FastIntFlagEnumrrrrrrrHrrrrr5rcompilerrrZ_SQLA_REZ _UNITTEST_RErZNoneTyperr r rrrrr$r,r3rr:r<r=r@Z MissingOrr2r2r2r3 s                                   !;  \+5 9u %N& C V +M.   #<"  "      3     )  ,   +