o 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'j3rdPd3d4Z4ndPd5d4Z4dQd8d9Z5Gd:d;d;Z6dRd?d@Z7dSdBdCZ8 dTdUdGdHZ9dVdNdOZ:dWdSdTZ;dXdYdZZ<dYd`daZ=e"dbdLd&Z>dZdedfZ?dgdhZ@d[dndoZAe"dpZBe"dqZCGdrdsdsZDdtduZEedd%dvd\d}d~ZFedddvd]dd~ZFdddvd]dd~ZFd^ddZG d_d`ddZH "dadbddZIdaddZJ dcddddZKddZLddZM  dedfddZNGdddZOddZPddZQ   dgddZRddZSdhddZTe"ddd&ZUGdddee-ZVGdddeVe-ZWGdddeVe-ZXe!r#eVZYeVZZe[Z\e[Z]neXZYZ\eWZZZ]diddZ^GdddZ_e!r>e[Z`ne_jaZ`Gdd„dƒZbdjddĄZcdkddȄZddldd̄Ze " dmdnddՄZfdoddׄZgdpddڄZhdqdd݄Zi dTdrddZjdsddZkddZlGddde[ZmGdddee,ZnGdddee,ZoGdddee,ZpGdddeqZrGdddesZtGdddetdZue!rddlmvZvevZwneuZwe"dejxd&Zy dtduddZzda{dvddZ|dwddZ}dxd d Z~Gd d d eZdTdyddZdzddZiZded<d{ddZe dZ  d|d}dd Zd~d$d%Ze d&Ze d'Zeefdd,d-ZesdZd.d/Ze d0ZGd1d2d2ZGd3d4d4Zd5d6Zd7d8Zdd:d;Zdd<d=ZddAdBZe dCZddGdHZddJdKZdtdLdMZGdNdOdOejxZejZe#e,e*ejfZdS(zRoutines 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]objrreturnMapping[str, Any]cCs t|SN)inspectget_annotationsr)r0]/var/www/html/ecg_monitoring/venv/lib/python3.10/site-packages/sqlalchemy/util/langhelpers.pyr.A r.cCs>t|tr |jdd}nt|dd}|durtjStd|S)N__annotations__r+) isinstancetype__dict__getgetattrr EMPTY_DICTr)r)annr0r0r1r.Fs   xstrcCs*|d}t}||tt|S)Nzutf-8)encodermd5_not_for_securityupdaterr< hexdigest)r;mr0r0r1md5_hexWs  rBc@s2eZdZUdZdZded<dddZdddZdS) 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]]rDr*NonecCst|_dSr,)sysexc_inforDselfr0r0r1 __enter__zsafe_reraise.__enter__type_Optional[Type[BaseException]]valueOptional[BaseException] tracebackOptional[types.TracebackType]rcCsZ|jdusJ|dur|j\}}}|dusJd|_||d|_|dus(J||r,)rDwith_traceback)rIrLrNrPexc_type exc_valueexc_tbr0r0r1__exit__s     zsafe_reraise.__exit__Nr*rE)rLrMrNrOrPrQr*r)__name__ __module__ __qualname____doc__ __slots__r3rJrVr0r0r0r1rC^s  rCclsType[_T]Iterator[Type[_T]]ccsNt}|g}|r%|}||vrq|||||V|s dSdSr,)setpopaddextend__subclasses__)r]seenstackr0r0r1walk_subclassess  rgelementcCs4t|tr|Szt|WStyd|YSw)Nzunprintable element %r)r4r< Exception)rhr0r0r1string_or_unprintables    rj Type[Any]use_name Optional[str]cCs&|p|j}dddtd|DS)N css|]}|VqdSr,)lower).0nr0r0r1 z(clsname_as_plain_name..z([A-Z][a-z]+|SQL))rXjoinrefindall)r]rlnamer0r0r1clsname_as_plain_names rxinstance_or_clsUnion[Type[Any], object]against_methodCallable[..., Any]boolcCs.t|ts |j}n|}|j}t||}||kS)z1Return True if the two class methods don't match.)r4r5 __class__rXr8)ryr{ current_cls method_namecurrent_methodr0r0r1method_is_overriddens  rslcsliceTuple[Any, ...]cCs>g}|j|j|jfD]}t|dr|}||q t|S)zrdecode a slice object as sent to __getitem__. takes into account the 2.5 __index__() method, basically. __index__)startstopstephasattrrappendtuple)rretr;r0r0r1 decode_slices   rused Sequence[str]bases Iterator[str]c'sjt|}|D]+tftfddtd}|D]}||vr+|||VnqtdqdS)Ncs t|Sr,r<)ibaser0r1 z!_unique_symbols..iz&exhausted namespace for symbol base %s)r` itertoolschainmaprangerb NameError)rrused_setpoolsymr0rr1_unique_symbolss   rfnCallable[[int], Any]rqint Iterator[Any]ccs2|r||d@}||V||N}|sdSdS)z6Call the given function given each nonzero bit from n.rNr0)rrqbr0r0r1map_bitss   r_FntargetCallable[[_Fn], _Fn]csdfdd }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|rZd |d <d|d<nd|d <d|d<dt|dvrod|}nd|}tj|j}| t|| |||d|jittjt|||j } t|d|j| _|| _t| |S)Nznot a decoratable functionzTuple[str, ...]rrrr)rrFgroupedrwzasync prefixzawait 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) rX__func__)r- isfunctionismethodririnspect_getfullargspec!_update_argspec_defaults_into_envrrrXrdictr?format_argspec_plusiscoroutinefunctionreprrFmodulesrYvarstypes FunctionType_exec_code_in_envr8 __defaults__ __wrapped__r) rspecenvnames targ_namefn_namemetadatacodemod decoratedrr0r1decoratesN           zdecorator..decorateN)rrr*rr)rrr0rr1 decorators ArcCsx|jr:g}d}|jD] }t|jdvr%d|}|||<|||d7}q ||q t|}t||d<tj|S|S)zCgiven a FullArgSpec, convert defaults to be symbol names in an env.r)builtins __builtin__zx%drr)defaultsr5rYrlistrr FullArgSpec)rr new_defaultsrargrwelemr0r0r1r=s      rrUnion[str, types.CodeType]rDict[str, Any]rcCst||||Sr,)exec)rrrr0r0r1rRs r_PF_TEc@s6eZdZ ddddZdd Zdd dZdddZdS) PluginLoaderNgroupr<auto_fnOptional[Callable[..., Any]]cCs||_i|_||_dSr,)rimplsr)rIrrr0r0r1__init__^s zPluginLoader.__init__cCs|jdSr,)rclearrHr0r0r1rerKzPluginLoader.clearrwr*rcCs||jvr |j|S|jr||}|r||j|<|St|jD]}|j|kr6|j|j|<|Sq#td|j|f)NzCan't load plugin: %s:%s) rrrimportlib_metadata_getrrwloadrNoSuchModuleError)rIrwloaderimplr0r0r1rhs        zPluginLoader.load modulepathobjnamerEcsfdd}||j|<dS)Ncs4t}dddD]}t||}q t|S)N.r) __import__splitr8)rtokenrrr0r1r|s  z#PluginLoader.register..load)r)rIrwrrrr0rr1register{szPluginLoader.registerr,)rr<rr)rwr<r*r)rwr<rr<rr<r*rE)rXrYrZrrrrr0r0r0r1r]s   rcCshztj}Wntyt|}|dt|dfYSw|j}|j}t|j d|t|j |@fS)Nrr) r-CO_VARKEYWORDSAttributeErrorrrr}__code__ co_argcountr co_varnamesco_flags)rco_varkeywordsrconargsr0r0r1_inspect_func_argss     r)_setraiseerrr5rOptional[Set[str]]r Literal[True]Set[str]cCdSr,r0r]rrr0r0r1get_cls_kwargssrFcCrr,r0rr0r0r1rsc Cs|du}|r t}|dusJ|jdd}|o$t|tjo$t|jtj}|rCt|\}}| ||sB|sB|r@t d|ddSnd}|rI|rY|j D] }t ||ddurXnqL| 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)rrI)r`r6r7r4rrrrrr? TypeError __bases__rdiscard) r]rrtoplevelctrhas_initrhas_kwcr0r0r1rs8        func List[str]cCst|dS)zReturn the set of legal kwargs for the given `func`. Uses getargspec so is safe to call for methods, functions, etc. r)rr)r r0r0r1get_func_kwargssr no_self_is_initcompat.FullArgSpecc Cs0t|r td|t|r4|r/|r/t|}t|jdd|j|j |j |j |j |j St|St|rb|r\|s@|jr\t|j}t|jdd|j|j |j |j |j |j St|jSt|rot|j|ddSt|drzt|jSt|drt|jrt|j|dStd |td |) 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)r r r__call__)r zCan't inspect callable: %s)r- isbuiltinrrrrrargsvarargsvarkwr kwonlyargskwonlydefaultsrr__self__risclassget_callable_argspecrrr)rr r rr0r0r1rsN              r-Union[Callable[..., Any], compat.FullArgSpec]rDict[str, Optional[str]]c Cst|r t|}n|}tj|}t|d|d|dd|d}|drB|dd}t|ddd|d|dd|d}n|drOd|d}|}nd}|}d}|drf|tttt|d7}|drr|t|d7}|d|d}|r|d|d} nd} tj||d|d| d d d } |drtj|dd|d|d| d d d } n| } |rt|||| || d St|||dd| dd|dd| ddd S)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]rr0cS dt|SN=rr;r0r0r1rsrz%format_argspec_plus..) formatvaluecSrrrrr0r0r1r|r) grouped_argsself_arg apply_posapply_kwapply_pos_proxiedapply_kw_proxied) callablerrinspect_formatargspeclenrrrr) rrrrr#r"r% num_defaults name_argsdefaulted_valsr$r&r0r0r1r sv$   "       rcCsz|tjurd}|r dnd}|rdnd}nzt||dWSty2d}|r(|nd}|r.dnd }Ynwtd|||||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)rIz()rrz(self, *args, **kwargs)zself, *args, **kwargsz(*args, **kwargs)z*args, **kwargs)r"r!r#r$r%r&)objectrrrr)methodrr!rproxiedr0r0r1format_argspec_inits&    r1r0 target_clstarget_cls_sphinx_nameproxy_cls_sphinx_name classmethodsmethods attributesuse_intermediate_variableCallable[[_T], _T]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,r0)r]r0r0r1rz&create_proxy_methods..decorater0)r2r3r4r5r6r7r8rr0r0r1create_proxy_methodssr;cCsJzt|WSty$|tjurdgdddfYSdgdddfYSw)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) rINrkwargs)rrrr.r)r/r0r0r1getargspec_inits   r=cCst|tjr |js |jS|S)zSAdjust the incoming callable such that a 'self' argument is not required. )r4r MethodTyperr) func_or_clsr0r0r1unbound_method_to_callablesr@ additional_kwSequence[Tuple[str, Any]] to_inspect%Optional[Union[object, List[object]]] omit_kwargc s6|durg}nt|}tg}t}d}t|D]p\}}zt|j} Wn ty1Yqw| j r:t | j nd} |dkr_| j rF| j }| rT| | j d| n| | j ddn|fdd| j d| D| r| j sxJ|ddt| j | d| j Dqg} | fdd|D|durt|r| d dt|D|D]+\} } | |vrqzt| }|ur|| kr| d | |fWqtyYqw|r|D])\} } zt| }|ur|| kr| d | |fWqtyYqwd jjd | fS) z}Produce a __repr__() based on direct association of the __init__() specification vs. same-named attributes present. Nrrcsg|]}|fqSr0r0rpr)missingr0r1 z generic_repr..cSsg|]\}}||fqSr0r0)rprdefaultr0r0r1rHsc3s |] }tt|dVqdSr,)rr8rFr/r0r1rr"szgeneric_repr..cSsg|]}t|qSr0r)rpvalr0r0r1rH%rIz%s=%rz%s(%s), )rto_listr. OrderedDict enumeraterrrrrr*rrcrr?ziprr8itemsrrir~rXrt)r)rArCrEpos_argskw_argsvargsrinspr default_lenoutputrdefvalrLr0)rGr)r1 generic_reprsv        rZc@s6eZdZdZdZddZddZd dd Zd d Zd S)portable_instancemethodz_Turn an instancemethod into a (parent, name) pair to produce a serializable callable. )rrwr< __weakref__cCs|j|j|jdS)Nrrwr<r]rHr0r0r1 __getstate__Esz$portable_instancemethod.__getstate__cCs&|d|_|d|_|dd|_dS)Nrrwr<r0)rrwr7r<)rIstater0r0r1 __setstate__Ls  z$portable_instancemethod.__setstate__r0cCs|j|_|j|_||_dSr,)rrrXrwr<)rImethr<r0r0r1rQs z portable_instancemethod.__init__cOs$||jt|j|j|i|Sr,)r?r<r8rrw)rIrkwr0r0r1rVs z portable_instancemethod.__call__N)r0) rXrYrZr[r\r^r`rrr0r0r0r1r[=s  r[cs|ht|j}|rV|}fdd|jD}|D] }|||q|jdks1t|ds2qfddt|t s@| n| |DD] }|||qG|s tS)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,r0rp_hierr0r1rrjz"class_hierarchy..rrdcsg|]}|vr|qSr0r0rcrer0r1rHss z#class_hierarchy..) r__mro__rarrrbrYr issubclassr5rd)r]processrrrsr0rer1class_hierarchy[s&      rlccsBt|}|D]}|jD]}||jvr||j|fVnq qdS)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)dirrhr6)r]keyskeyrr0r0r1iterate_attributess  rp self.proxyc s.|r|}ndur dfddt|D}|D]{}zt||}t|ds(Wqt|d|}ttj|} Wn ty>Yqwzt| } t | d} t | ddd} Wn t yed } d } Ynwd t } |durs||ipti}t | |z| j ||_ Wn tyYnwt|||qdS) z9Automates delegation of __specials__ for a proxying type.N)r\__del____getattribute__ __metaclass__r^r`cs6g|]}|dr|drt|s|vr|qS)r) startswithendswithrrprAinto_clsskipr0r1rHsz0monkeypatch_proxied_specials..rrrrz(self, *args, **kw)z (*args, **kw)z?def %(method)s%(fn_args)s: return %(name)s.%(method)s%(d_args)s)rmr8rrrrrrrr)rlocalsrrsetattr)ryfrom_clsrzonlyrw from_instancedundersr/maybe_fnrrfn_argsd_argspyrr0rxr1monkeypatch_proxied_specialssN           rcCst|d|t|d|uS)z;Return True if the two methods are the same implementation.r)r8)meth1meth2r0r0r1methods_equivalents rc Csf|s|stdt|trt||r|St|pddt|D}tt|}tj}t|tr2|}n |s;t}tj}nt|}||||rI|St|t sc|tjurUdpVd}td||d |fGdd d }|rrd |j |_ t} t |D]'\} } | |vrtd | t | std | | ft|| t| | | qy|| |r|Std d || )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)rd)rurwr0r0r1rHsz as_interface..zany ofzall ofz%r does not implement %s: %srMc@eZdZdZdS)z(as_interface..AnonymousInterfacezA callable-holding shell.NrXrYrZr[r0r0r0r1AnonymousInterfacer Anonymousz%r: unknown in this interfacez%r=%r is not callablez,dictionary does not contain required keys %s)rr4r5r`rmoperatorgegt intersectionrrtrXdictlike_iteritemsr(r| staticmethodrb) r)r]r6required interface implementedcomplies qualifierrfoundr/rr0r0r1 as_interfacesP!        r_GFDzgeneric_fn_descriptor[Any]c@seZdZUdZded<ded<ded<d%d&d d Zed'ddZed(ddZd)ddZer8d*ddZ d+ddZ d,d d!Z e 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. Callable[..., _T_co]fgetrmr[r<rXNdoccC||_|p|j|_|j|_dSr,rr[rXrIrrr0r0r1rD  zgeneric_fn_descriptor.__init__rIrr)rEr]rr*cCrr,r0rIr)r]r0r0r1__get__Ir:zgeneric_fn_descriptor.__get__r.r!cCrr,r0rr0r0r1rLr:Union[_GFD, _T_co]cCtr,NotImplementedErrorrr0r0r1rOinstancerNcCrr,r0rIrrNr0r0r1__set__Tzgeneric_fn_descriptor.__set__cCrr,r0)rIrr0r0r1 __delete__Vrz generic_fn_descriptor.__delete__cCrr,rrIr)r0r0r1_resetXrzgeneric_fn_descriptor._resetrwcCrr,rr]r)rwr0r0r1reset[szgeneric_fn_descriptor.resetr,)rrrrm)rIrr)rEr]rr*r)r)r.r]rr*r!)rIrr)rr]rr*rrrrNrr*rErrr*rE)r)rr*rE)r)rrwr<r*rE)rXrYrZr[r3rrrrrrr classmethodrr0r0r0r1r5s"         rc@s eZdZdZesddZdSdS)_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,rrr0r0r1rks z_non_memoized_property.__get__N)rXrYrZr[rrr0r0r0r1r`s  rc@s0eZdZdZes ddZddZeddZdS) _memoized_propertyz2A read-only @property that is only evaluated once.cCs&|dur|S|||j|j<}|Sr,)rr6rXrIr)r]resultr0r0r1rvsz_memoized_property.__get__cCst||jdSr,)rrrXrr0r0r1r|sz_memoized_property._resetcCs|j|ddSr,)r6rarr0r0r1rsz_memoized_property.resetN) rXrYrZr[rrrrrr0r0r0r1rqsrcsfdd}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)NcSr,r0arbrr0r1memor:z6memoized_instancemethod..oneshot..memo)rXr[r6rIrrbrrrr1oneshots   z(memoized_instancemethod..oneshotr)rrr0rr1memoized_instancemethods rc@sheZdZUdZes dZeZded<dddZ dd d Z dddZ Gddde e ZedddZdS) HasMemoizedzA mixin class that maintains the names of memoized elements in a collection for easy cache clearing, generative, etc. r0zFrozenSet[str]_memoized_keysr*rEcCs|jD] }|j|dqdSr,)rr6rarIrr0r0r1_reset_memoizations zHasMemoized._reset_memoizationscCs|jD] }||jvs JqdSr,)rr6rr0r0r1_assert_no_memoizationsrz#HasMemoized._assert_no_memoizationsror<rNrcCs||j|<|j|hO_dSr,)r6r)rIrorNr0r0r1_set_memoized_attributes z#HasMemoized._set_memoized_attributec@sZeZdZUdZded<ded<ded<ddd d ZedddZedddZddZdS)zHasMemoized.memoized_attributezTA read-only @property that is only evaluated once. :meta private: Callable[..., _T]rrmr[r<rXNrcCrr,rrr0r0r1rrz'HasMemoized.memoized_attribute.__init__rIr&r)rEr]rr*cCrr,r0rr0r0r1rr:z&HasMemoized.memoized_attribute.__get__r cCrr,r0rr0r0r1rr:cCs8|dur|S|||j|j<}|j|jhO_|Sr,)rr6rXrrr0r0r1rs r,)rrrrm)rIr&r)rEr]rr*r&)r)rr]rr*r )rXrYrZr[r3rrrr0r0r0r1memoized_attributes     rrr#csd fdd }t|S) zMDecorate a method memoize its return value. :meta private: rIrrrbr*csT|g|Ri|fdd}j|_j|_||jj<|jjhO_S)Ncrr,r0rrr0r1rr:zBHasMemoized.memoized_instancemethod..oneshot..memo)rXr[r6rrrrr1rs  z4HasMemoized.memoized_instancemethod..oneshotN)rIrrrrbrr*rr)r]rrr0rr1rs z#HasMemoized.memoized_instancemethodNrW)ror<rNrr*rErr#r*r#)rXrYrZr[rr\ frozensetrr3rrrmemoized_propertyr rrrr0r0r0r1rs    rc@s&eZdZdZdZddZd d d 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__. r0cCst|r,)r)rIror0r0r1_fallback_getattrzMemoizedSlots._fallback_getattrror<r*rcsds drttjdr(td}t||StjdrGtdfdd}j|_|SS)N_memoized_attr__memoized_method_cs:|i|fdd}j|_j|_t|S)Ncrr,r0rrr0r1r)r:z8MemoizedSlots.__getattr__..oneshot..memo)rXr[r|)rrbrrrorIrr1r&s   z*MemoizedSlots.__getattr__..oneshot)rurrr~r8r|r[r)rIrorNrr0rr1 __getattr__s   zMemoizedSlots.__getattr__N)ror<r*r)rXrYrZr[r\rrr0r0r0r1r s rcCsBt|tr|}|dvrdS|dvrdStd|t|S)N)trueyesonyt1T)falsenooffrqf0FzString is not true/false: %r)r4r<stripro ValueErrorr}r/r0r0r1asbool8s   rtext!Callable[[str], Union[str, bool]]csdfdd }|S) zqReturn a callable that will evaluate a string as boolean, or one of a set of "alternate" string values. r)r<r*Union[str, bool]cs|vr|St|Sr,)rr/rr0r1 bool_or_valueJsz"bool_or_str..bool_or_valueN)r)r<r*rr0)rrr0rr1 bool_or_strDsrrN Optional[int]cCs|dur|St|S)zCoerce to integer.N)r)rNr0r0r1asintSsrrbrorL flexi_booldestOptional[Dict[str, Any]]rEcCsx|dur|}||vr6t|trt|||s:||dur8|tur,|r,t||||<dS|||||<dSdSdSdS)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)r4r5r}r)rbrorLrrr0r0r1coerce_kw_type[s    rcs$t|}|ftfdd|DS)zbProduce a tuple structure that is cacheable using the __dict__ of obj to retrieve values c3(|]}|jvr|j|fVqdSr,r6rpkr/r0r1rr{z"constructor_key..)rr)r)r]rr0r/r1constructor_keyus rrcs4t|}|fdd||D||i|S)zInstantiate cls using the __dict__ of obj as constructor arguments. Uses inspect to match the named arguments of ``cls``. c3rr,rrr/r0r1rrrz#constructor_copy..)rr? difference)r)r]rrbrr0r/r1constructor_copys rCallable[[], int]cs$ttdfdd}|S)z%Return a threadsafe counter function.rcs0 tWdS1swYdSr,)nextr0counterlockr0r1_nexts$zcounter.._next) threadingLockrcount)rr0rr1rs rspecimenrJOptional[Type[Any]]cCst|dr|jdurt|jtrtS|jSt|trtnt}||tr%tS||tr,tS||tr3tSt|dr:tSt|drAtSt|drHtS|S)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__Nrrbr`)rrrir`r4r5rr)rrJisar0r0r1duck_type_collections(        rrargtype'Union[Tuple[Type[Any], ...], Type[Any]]rwcCsXt||r|St|tr td|ddd|Dt|ftd||t|f)Nz8Argument '%s' is expected to be one of type %s, got '%s'z or css|]}d|VqdS)z'%s'Nr0)rprr0r0r1rrrsz"assert_arg_type..z6Argument '%s' is expected to be of type '%s', got '%s')r4rr ArgumentErrorrtr5)rrrwr0r0r1assert_arg_types   r cstdr tStdtdddurtdtdr.fdd}|Std r@tfd d DStd) z?Return a (key, value) iterator for almost any dict-like object.rR __getitem__r7NzObject '%r' is not dict-likeiterkeysc3s.D]}dus J||fVqdSr,)r )rodictlikegetterr0r1iterators   z$dictlike_iteritems..iteratorrnc3s|] }||fVqdSr,r0)rpro)rr0r1rrrgz%dictlike_iteritems..)rrrRr8riterrn)rrr0rr1rs      rcs8eZdZUdZded<dfdd ZddddZZS) 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. Callable[[Any], Any]rrrrbcs&tj|g|Ri||j|_dSr,)superrr[)rIrrrbr~r0r1rs zclassproperty.__init__Nr)r]Optional[type]r*cCs ||Sr,rrr0r0r1rr2zclassproperty.__get__)rrrrrbrr,)r)rr]rr*r)rXrYrZr[r3rr __classcell__r0r0rr1rs  rc@s*eZdZdddZdd d ZdddZdS)hybridpropertyr rcCs||_||_dSr,)r clslevelrIr r0r0r1rs zhybridproperty.__init__rrownerr*r cC |dur ||}|S||Sr,rr rIrrclsvalr0r0r1r  zhybridproperty.__get__r|hybridproperty[_T]cC ||_|Sr,rrr0r0r1 classlevel zhybridproperty.classlevelNr rrrrrr*r )r r|r*r")rXrYrZrrr%r0r0r0r1rs  rc@s>eZdZdddZdd d ZdddZdddZdddZdS)rw_hybridpropertyr rcCs||_||_d|_dSr,)r rsetfnrr0r0r1rs zrw_hybridproperty.__init__rrrr*r cCrr,rrr0r0r1rr!zrw_hybridproperty.__get__rNrEcCs|jdusJ|||dSr,r*rr0r0r1rszrw_hybridproperty.__set__r|rw_hybridproperty[_T]cCr#r,r+rr0r0r1setter r&zrw_hybridproperty.settercCr#r,r$rr0r0r1r%$r&zrw_hybridproperty.classlevelNr'r(r)r r|r*r,)rXrYrZrrrr-r%r0r0r0r1r)s     r)c@s.eZdZdZdddZdd d ZdddZdS) hybridmethodz/Decorate a function as cls- or instance- level.r rcCs||_|_||_dSr,)r rrrr0r0r1r,s  zhybridmethod.__init__rrrr*cCs&|dur |j||jS|j||Sr,)rrr~r )rIrrr0r0r1r0szhybridmethod.__get__r|hybridmethod[_T]cCr#r,r$rr0r0r1r%6r&zhybridmethod.classlevelNr')rrrrr*r)r r|r*r/)rXrYrZr[rrr%r0r0r0r1r.)s   r.c@sVeZdZUdZded<iZded<eZ  ddd d Z ddZ 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<rwzDict[str, symbol]symbolsNrrm canonicalrr*cCs|jG|j|}|dur1t|tsJ|durt|}tt|}||_ |r+||_ ||j|<n|rA||krAt d|d||WdS1sMwYdS)Nz#Can't replace canonical symbol for z with new int value ) _lockr1r7r4r<hashr__new__r0rwr[r)r]rwrr2rr0r0r1r5Os&    $zsymbol.__new__cCst|jdt|ffS)Nr;)r0rwrrHr0r0r1 __reduce__mszsymbol.__reduce__cCst|Sr,rKrHr0r0r1__str__przsymbol.__str__cCsd|jdS)Nzsymbol()rwrHr0r0r1__repr__srKzsymbol.__repr__)NN)rwr<rrmr2rr*r0) rXrYrZr[r3r1rrr3r5r6r7r:r0r0r0r1r0;s    r0c@s eZdZdd d ZdddZdS) _IntFlagMeta classnamer<rTuple[Type[Any], ...]dict_rrbrr*rEc Ksg|_}|D],\}}td|rq t|tr t||d}n |ds)tdq t |||| |q t dd|D|_ dS)Nz^__.*__$)r2rdz#Expected integer values for IntFlagcSsi|]}|j|qSr0r9)rprr0r0r1 rIz)_IntFlagMeta.__init__..)_itemsrRrumatchr4rr0rurr|rr immutabledict __members__) r]r<rr>rbrRrvrr0r0r1rxs        z_IntFlagMeta.__init__Iterator[symbol]cCstd)Nziter not implemented to ensure compatibility with Python 3.11 IntFlag. Please use __members__. See https://github.com/python/cpython/issues/99304rrHr0r0r1__iter__sz_IntFlagMeta.__iter__N) r<r<rr=r>rrbrr*rE)r*rE)rXrYrZrrFr0r0r0r1r;ws r;c@r) _FastIntFlagzAn 'IntFlag' copycat that isn't slow when performing bitwise operations. the ``FastIntFlag`` class will return ``enum.IntFlag`` under TYPE_CHECKING and ``_FastIntFlag`` otherwise. Nrr0r0r0r1rGrrG) metaclass)IntFlag_EchoicesDict[_E, List[Any]]resolve_symbol_names Optional[_E]cCsj|D]\}}||ur|S|r||jkr|S||vr#|Sq|dur*dStd|d|)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': )rRrwrr )rrKrwrM enum_valuechoicer0r0r1parse_user_argument_for_enumsrQrcCst|_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)rr0r0r1set_creation_orders rSr<cOs>z||i|WStytdtddYdSw)zXexecutes the given function, catches all exceptions and converts to a warning. z%s('%s') ignoredrrN)riwarnrFrG)r rr<r0r0r1warn_exceptions  rUcCs<zt||krd|d|WS|WSty|YSw)Nz%s...r)r*r)rNlen_r0r0r1ellipses_strings  rXcs@eZdZUdZded<dfd d Zdd d ZdddZZS)_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_hashrNr<numr Sequence[Any]r*cs<||d|}t||}td|t||f|_|S)Nz6 (this warning may be suppressed after %d occurrences)z%s_%d)rr5r4rZ)r]rNr[r interpolatedrIrr0r1r5s z_hash_limit_string.__new__cCs|jSr,)rZrHr0r0r1__hash__ rz_hash_limit_string.__hash__otherrr}cCst|t|kSr,)r4)rIr_r0r0r1__eq__sz_hash_limit_string.__eq__)rNr<r[rrr\r*rY)r*r)r_rr*r}) rXrYrZr[r3r5r^r`rr0r0rr1rYs   rYmsgcCs*|r ttj||ddSt|tjdS)zdIssue a warning. If msg is a string, :class:`.exc.SAWarning` is used as the category. )rN)_warnings_warnr SAWarning)rarr0r0r1rTsrTr\cCs |rt|d|}t|tjdS)z\Issue a warning with a parameterized string, limiting the number of registrations. N)rYrbrrc)rarr0r0r1 warn_limited s rez)Dict[CodeType, Tuple[str, Type[Warning]]] _warning_tagsmessagecategory Type[Warning]Callable[[_F], _F]csfdd}|S)Ncsft|j<|Sr,)rfrrrhrgr0r1go0sz#tag_method_for_warnings..gor0)rgrhrlr0rkr1tag_method_for_warnings-srmz&^(?:sqlalchemy\.(?!testing)|alembic\.)Union[str, Warning]Optional[Type[Warning]] stacklevelcCszt|}Wntyd}YnKd}YnDd}}|dur]|s0tt|jdds0d}|jt vrJd}t |j\}}|pA|}|d|d}|j }|sT|d7}n|rY|rYn|dus!|durmt j |||dd dSt j ||dd dS) NrFrXrTz (r8r)rp) rF _getframerrurA_not_sa_pattern f_globalsr7f_coderff_backwarningsrT)rgrhrpframestacklevel_foundwarning_tag_found_suffix _categoryr0r0r1rb:s4   rbrretry_on_exceptionCallable[..., Optional[_T]]csgd fdd }|S) zNDecorate the given function to be a no-op after it is called exactly once.rrrbr* Optional[_T]cs>}r}z||i|WSrd|dS)Nr)rainsert)rrb strong_fnonce_fnroncer|r0r1rlus zonly_once..goN)rrrbrr*r~r0)rr|rlr0rr1 only_oncemsrz%sqlalchemy/([a-z_]+/){0,2}[a-z_]+\.pyzunit(?:2|test2?/)tbexclude_prefixre.Pattern[str]exclude_suffixcCsd}t|d}||kr"|||r"|d7}||kr"|||s||kr<|||r<|d8}||kr<|||s-|||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)rrrrendr0r0r1chop_tracebacks rcCs$d|}t}t|||dS)Nz&def set(obj, value): obj.%s = valuer`)r{copyr)attrnamerrr0r0r1 attrsetters  rz^__.+__$cs&eZdZdZdZdfdd ZZS) TypingOnlyzA mixin class that marks a class as 'typing only', meaning it has absolutely no methods, attributes, or runtime functionality whatsoever. r0r*rEcsBt|jvrdd|jD}|rtd|d|dtdS)NcSsh|] }t|s|qSr0)_dundersrArprwr0r0r1 s  z/TypingOnly.__init_subclass__..zClass z< directly inherits TypingOnly but has additional attributes r)rrr6AssertionErrorr__init_subclass__)r] remainingrr0r1rs zTypingOnly.__init_subclass__rW)rXrYrZr[r\rrr0r0rr1rsrcs<eZdZUdZded< d fdd Zed 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_kwargr*rEcsf|j}|j}|r,|D]!}t||}|r+||}t|}|js+||}t|||q t dSr,) rr6rurArrr _wrap_w_kwr|rr)r]fn_regclsdictrorArrwrappedrr0r1rs    zEnsureKWArg.__init_subclass__rr|csdfdd }t|S)Nrrrbr*cs|Sr,r0)rrbrr0r1wraprz$EnsureKWArg._wrap_w_kw..wrap)rrrbrr*rr)r]rrr0rr1rs zEnsureKWArg._wrap_w_kwrW)rr|r*r|) rXrYrZr[r3rrrrr0r0rr1rs  rcCsht|dr t||S|}|jj|_t|dr|j|_t|jdr+|jjr+|jj|_|S|jr2|j|_|S)zAugment functools.update_wrapper() to work with objects with a ``__call__()`` method. :param fn: object with __call__ method rXrYr[)rrr~rXrYrr[)wrapperr_fr0r0r1 wrap_callables     rcCsd|vr |dSd}gg}d}t|}||kr`||}|dkrC|dkr>||dkr>||ddkr>|dd|d7}n|dN}n|dkrQ|dkrQ|gn|d||d7}||ksdd|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'] "rrrr'cSsg|]}d|qS)r)rt)rprr0r0r1rH1sz'quoted_token_parser..)rr*r)rNr_ridxlvcharr0r0r1quoted_token_parsers& $   rparamscstfdd}|S)Ncs:|jdur|jp d}|rt|fddD}||_|S)Nrcsi|]}|qSr0r0)rpparamrr0r1r?:sz8add_parameter_text..decorate..)r[inject_param_text)rrrrr0r1r7s z$add_parameter_text..decorate)rrN)rrrr0rr1add_parameter_text4s rcCsJ|dd}t|dkr|S|\}}|ds |dt|St|S)N rrn)rr*rutextwrapdedent)r split_text firstlinerr0r0r1_dedent_docstringAs    r given_doctext injecttextposcCst|pd}|d}t|dkr|dt|d}|dr(|ddddt|D}|dd|t|t|d}|d||||d}d |S)NrrrrcSsg|] \}}|s|qSr0)r)rpr[liner0r0r1rHXsz)inject_docstring_text..) rrr*rrrrrPminrt)rrrdoctextlines injectlinesblanks inject_posr0r0r1inject_docstring_textMs       rz(\s+):param (.+?):r inject_paramsDict[str, str]c Cs t|}g}d}|r|}t|}|durO|rN|dd}||vrNdt|dd}|rHt d|d} | rHdt| d}|||}n+|r\| d|dgd}n| sk| ||dgd}n| drz| ||gq | ||s d|S) Nr*rnrz(\s+)\Srrz::) collectionsdeque splitlinespopleft _param_regrArlstripr*rurcrstriprvrrt) rrdoclinesr to_injectrrArindentm2r0r0r1rds:     !rrcCs~t|dkrdSt|dk}|r|ddn |dd|dd}dd|D}|r0d|Sd d|dd|dfS) zTrims a list of strings from the middle and return a string of up to four elements. Strings greater than 11 characters will be truncatedrNrrr'cSs,g|]}t|dkrd|ddn|qS) z%s..N)r*rr0r0r1rHs,z$repr_tuple_names..rMz %s, ..., %s)r*rt)rflagresr0r0r1repr_tuple_namess  ( rcCstrdS|r tddS)NTzDcython extensions were expected to be installed, but are not presentF)r ImportError)raise_r0r0r1has_compiled_extsrc@seZdZeZdS)_MissingN)rXrYrZenumautoMissingr0r0r0r1rs r)r)rr*r+)r;rr*r<)r]r^r*r_)rhrr*r<r,)r]rkrlrmr*r<)ryrzr{r|r*r})rrr*r)rrrr<r*r)rrrqrr*r)rr|r*r)rrrrrr<r*r|)r]r5rrrrr*r)r]r5rrrr}r*r)r r|r*r )FF)rr|r r}r r}r*r)T)rrrr}r*r)r0r0r0r0)r2rkr3r<r4r<r5rr6rr7rr8rr*r9)r0Nr0) r)rrArBrCrDrErr*r<)NNrqN)NNNr)r)rr*r})rr<r*r)rNrr*r)TN) rbrror<rLrkrr}rrr*rE)r)rr]rkr*r) r)r r]r^rrrbrr*r )r*r)rrrJrr*r)rrrr rwr<r*r)F) rrrKrLrwr<rMr}r*rNr)r r|rrr<rr*r)rV)rar<rrmr*rE)rar<rr\r*rE)rgr<rhrir*rj)Nr)rgrnrhrorprr*rE)rrr|r}r*r})rr rrrrr*r )rrrr<r*rj)rr<r*r<)rrmrr<rrr*r<)rr<rrr*r<)rr r*rm)r[ __future__rrr functoolsrr-rrrurFrrrrtypingrrrr r r r r rrrrrrrrrrrrvrrr_has_cyrrrr r!r#r%r&r'r(py310r.rBrCrgrjrxrrrrrrrrrrrrrr rrr1r;r=r@rZr[rlrprrrrrrrrnon_memoized_propertypropertyro_memoized_propertyro_non_memoized_propertyrr!HasMemoized_ro_memoized_attributerrrrrrrrrrr rrrr)r.rr0r5r;rGrI FastIntFlagEnumrJrQrRrSrUrXr<rYrTrerfr3rmcompilerrrbr_SQLA_RE _UNITTEST_RErNoneTyperrrrrrrrrrrrrrr MissingOrr0r0r0r1sn                                   ;       G ( 5 9 u%N& C  V+ M .     #<" "      3     ) ,  +