U
|
¸ý°dM ã @ st U d Z ddlmZ ddlZddlZddlmZ ddlZddlZddl Z ddl
|
Z
|
ddl Z ddl Z ddl Z ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
|
lmZ dd lmZ dd lmZ dd lmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# ddlm$Z$ ddl%Z%ddl&m'Z' ddl&m(Z( dd l)m*Z* dd lm+Z+ d d l&m,Z, e#d Z-e#d!d"d#Z.e#d$ed%ef d&Z/e#d'd(d&Z0e#d)d*d&Z1e#d+d,d&Z2e#d-d.d&Z3e(j4r d/d0d1d2d3Z5nd/d0d1d4d3Z5d/d5d6d7d8Z6G d9d: d:Z7d;d<d=d>d?Z8d/d5d@dAdBZ9dCd5d=dDdEZ:dFdGdHdIdJdKZ;dLdMdNdOdPZ<dQd5dRdSdTdUZ=dVdWdXdYdZd[Z>e#d\dGd&Z?dGd]d^d_d`Z@dadb ZAdcddd5dGdedfdgZBe#dhZCe#diZDG djdk dkZEdldm ZFe dd%dndodpdqdrdsdtduZGe ddvdndodpdHdpdsdwduZGddvdndodpdHdpdsdxduZGdGdydzd{d|ZHd2dGdHdHd}d~ddZId3ddHdddd
ZJd4ddZKd5dCd5d5dQdQdQddddZLdd ZMdd ZNd6d/dddQd5dddZOG dd dZPdd ZQdd ZRd7ddZSdd ZTd8d¡d¢ZUe#d£d¤d&ZVG d¥d¦ d¦ee. ZWG d§d¨ d¨eWe. ZXG d©dª dªeWe. ZYe"rªeWZZeWZ[e\Z]e\Z^neY ZZZ]eX Z[Z^d$d$d«d¬dZ_G d®d¯ d¯Z`e"räe\Zane`jbZaG d°d± d±Zcd/dHd1d²d³Zdd5d´dµd¶d·Zed/d¸d¹dºd»Zfd9ddd5dCdHd¼d½d¾d¿dÀZgd/dCdMdÁdÂdÃZhd d;d/d/d dÄdÅdÆZidÇdÈdÉdÊZjd:d/dËdËdÌdÍdÎZkd/dÏd5d/dÐdÑdÒZldÓdÔ ZmG dÕdÖ dÖe\ZnG d×dØ dØee- ZoG dÙdÚ dÚee- ZpG dÛdÜ dÜee- ZqG dÝdÞ dÞerZsG dßdà dàetZuG dádâ dâeudãZve"rBddälmwZw ewZxnevZxe#dåejyd&Zzd;d/dæd5dHdçdèdédêZ{da|d/d½dëdìdíZ}dGd/d/d/dîdïdðZ~d<dòdóZG dôdõ dõeZd=d5död½d÷dødùZd5dúd½dûdüdýZi Zdþe
dÿ< d5d ddddZe d¡Zd>dddWd½dd d
|
Zd dHd d ddZe d¡Ze d¡ZeefdydddydddZetdZdd ZG dd dZG dd dZd d Zd d Zd/d5dd d!d"Zd5d5dµd#d$Zdöd5dWd5d%d&d'Ze d(¡Zd5d)d5d*d+d,Zdydöd-d.d/Zd?d0d1ZdS (@ z
Routines to help with the creation, loading and introspection of
|
modules, classes, hierarchies, attributes, functions, and methods.
|
|
é )Ú annotationsN©Úupdate_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]r úMapping[str, Any]©ÚobjÚreturnc C s
|
t | ¡S ©N)ÚinspectÚget_annotations©r+ © r1 úRd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/util/langhelpers.pyr/ B s r/ c C sB t | tr| j dd ¡}n t| dd }|d kr4tjS td|S d S )NÚ__annotations__r) )Ú
|
isinstanceÚtypeÚ__dict__ÚgetÚgetattrr Ú
|
EMPTY_DICTr )r+ Úannr1 r1 r2 r/ G s
|
Ústr)Úxr, c C s$ | d¡} t ¡ }| | ¡ | ¡ S )Nzutf-8)ÚencodeÚhashlibÚmd5ÚupdateÚ hexdigest)r< Úmr1 r1 r2 Úmd5_hexX s
|
|
rC c @ s@ e Zd ZU dZdZded< ddddZd d
|
d d d ddZdS )Ú safe_reraisea Reraise 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)]]rE ÚNone©r, c C s t ¡ | _d S r- )ÚsysÚexc_inforE ©Úselfr1 r1 r2 Ú __enter__ s zsafe_reraise.__enter__z Optional[Type[BaseException]]zOptional[BaseException]z Optional[types.TracebackType]r )Útype_ÚvalueÚ tracebackr, c C s` | j d k st|d kr@| j \}}}|d k s.td | _ | |¡n d | _ |d k sRt| |¡d S r- )rE ÚAssertionErrorÚwith_traceback)rK rM rN rO Úexc_typeÚ exc_valueÚexc_tbr1 r1 r2 Ú__exit__ s zsafe_reraise.__exit__N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú __slots__r3 rL rU r1 r1 r1 r2 rD _ s
|
|
|
rD zType[_T]zIterator[Type[_T]])Úclsr, c c sH t }| g}|rD| ¡ } | |kr$q n
|
| | ¡ | | ¡ ¡ | V q d S r- )ÚsetÚpopÚaddÚextendÚ__subclasses__)r[ ÚseenÚstackr1 r1 r2 Úwalk_subclasses s
|
rc )Úelementr, c C s: t | tr| S z
|
t| W S tk
|
r4 d| Y S X d S )Nzunprintable element %r)r4 r; Ú Exception)rd r1 r1 r2 Ústring_or_unprintable¨ s
|
|
rf z Type[Any]c C s d dd t d| j¡D ¡S )Nú c s s | ]}| ¡ V qd S r- )Úlower)Ú.0Únr1 r1 r2 Ú <genexpr>³ s z(clsname_as_plain_name.<locals>.<genexpr>z([A-Z][a-z]+|SQL))ÚjoinÚreÚfindallrV ©r[ r1 r1 r2 Úclsname_as_plain_name² s
|
ÿrp zUnion[Type[Any], object]úCallable[..., Any]Úbool)Úinstance_or_clsÚagainst_methodr, c C s. t | ts| j}n| }|j}t||}||kS )z1Return True if the two class methods don't match.)r4 r5 Ú __class__rV r8 )rs rt Z current_clsÚ method_nameZcurrent_methodr1 r1 r2 Úmethod_is_overridden¸ s
|
|
rw ÚslicezTuple[Any, ...])Úslcr, c C s> 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__)ÚstartÚstopÚstepÚhasattrrz ÚappendÚtuple)ry Úretr< r1 r1 r2 Ú decode_sliceÊ s
|
r z Sequence[str]z Iterator[str])ÚusedÚbasesr, c ' sh t | }|D ]V t ft fddtd¡}|D ] }||kr4| |¡ |V q q4td q d S )Nc s t | S r- ©r; )Úi©Úbaser1 r2 Ú<lambda>Ý ó z!_unique_symbols.<locals>.<lambda>iè z&exhausted namespace for symbol base %s)r\ Ú itertoolsÚchainÚmapÚranger^ Ú NameError)r r Zused_setÚpoolÚsymr1 r r2 Ú_unique_symbolsØ s þ
|
r zCallable[[int], Any]Úintz Iterator[Any])Úfnrj r, c c s* |r&|| d @ }| |V ||N }q dS )z6Call the given function given each nonzero bit from n.r Nr1 )r rj Úbr1 r1 r2 Úmap_bitsè s
|
r Ú_FnzCallable[[_Fn], _Fn])Útargetr, c s ddd fdd }t | S )z'A signature-matching decorator factory.r ©r r, c
|
s( t | ¡s t | ¡s tdt | ¡}i }t||}ttd|d td|dd
| j f }t
|
|dd\}}t ||d}| t |d d
|
¡ | j |d < d t|d kr²d | }nd| }tj| j }| t|¡ | | || d| ji¡ ttjt||| j } t| d| j| _| | _ttt| | S )Nznot a decoratable functionzTuple[str, ...]r r é r r )r r F©ÚgroupedÚnameÚ__zKdef %(name)s%(grouped_args)s:
|
return %(target)s(%(fn)s, %(apply_pos)s)
|
zJdef %(name)s%(grouped_args)s:
|
return %(target)s(%(fn)s, %(apply_kw)s)
|
rV Ú__func__)r. Ú
|
isfunctionÚismethodre r Úinspect_getfullargspecÚ!_update_argspec_defaults_into_envr r rV r Údictr@ Úformat_argspec_plusÚreprrH ÚmodulesrW ÚvarsÚtypesÚ FunctionTypeÚ_exec_code_in_envr8 Ú __defaults__Ú __wrapped__r r )
|
r ÚspecÚenvÚnamesZ targ_nameÚfn_nameÚmetadataÚcodeÚmodZ decorated©r r1 r2 Údecorateù sD
|
|
ÿþÿ
|
|
üÿ üÿ þzdecorator.<locals>.decorater )r r¶ r1 rµ r2 Ú decoratorö s :r· c C s| | j rtg }d}| j D ]@}t|jdkrJd| }|||< | |¡ |d7 }q| |¡ qt| }t||d< tj| S | S dS )zCgiven a FullArgSpec, convert defaults to be symbol names in an env.r )ÚbuiltinsÚ __builtin__zx%dr r N)Údefaultsr5 rW r Úlistr r Ú FullArgSpec)r® r¯ Z new_defaultsr Úargr Úelemr1 r1 r2 r£ 6 s
|
|
|
|
r£ zUnion[str, types.CodeType]úDict[str, Any])r³ r¯ r± r, c C s t | | || S r- )Úexec)r³ r¯ r± r1 r1 r2 r« K s
|
r« Ú_PFÚ_TEc @ sJ e Zd ZddddddZdd Zdd d
|
d d Zdddd dddZdS )Ú PluginLoaderNr; z Optional[Callable[..., Any]])ÚgroupÚauto_fnc C s || _ i | _|| _d S r- )rÄ ÚimplsrÅ )rK rÄ rÅ r1 r1 r2 Ú__init__W s zPluginLoader.__init__c C s | j ¡ d S r- )rÆ ÚclearrJ r1 r1 r2 rÈ ^ s zPluginLoader.clearr )r r, c C s || j kr| j | S | jr:| |¡}|r:|| j |< | S t | j¡D ]&}|j|krF|j| j |< | ¡ S qFt d| j|f ¡d S )NzCan't load plugin: %s:%s) rÆ rÅ r Zimportlib_metadata_getrÄ r Úloadr ZNoSuchModuleError)rK r ÚloaderÚimplr1 r1 r2 rÉ a s
|
|
|
|
ÿzPluginLoader.loadrF )r Ú
|
modulepathÚobjnamer, c s fdd}|| j |< d S )Nc s4 t } d¡dd
D ]}t| |} qt| S )NÚ.r )Ú
|
__import__Úsplitr8 )r´ Útoken©rÌ rÍ r1 r2 rÉ u s z#PluginLoader.register.<locals>.load)rÆ )rK r rÌ rÍ rÉ r1 rÒ r2 Úregistert s zPluginLoader.register)N)rV rW rX rÇ rÈ rÉ rÓ r1 r1 r1 r2 rà V s
|
ÿrà c C sn z
|
t j}W n2 tk
|
r< t | ¡}|d t|d f Y S X | j}|j}t|j d |
t|j
|
|@ fS d S )Nr r ) r. ÚCO_VARKEYWORDSÚAttributeErrorr r¢ rr Ú__code__Ú co_argcountr» Ú co_varnamesÚco_flags)r Zco_varkeywordsr® ÚcoÚnargsr1 r1 r2 Ú_inspect_func_args~ s
|
|
þrÜ )Ú_setÚraiseerrr5 zOptional[Set[str]]z Literal[True]zSet[str])r[ rÝ rÞ r, c C s d S r- r1 ©r[ rÝ rÞ r1 r1 r2 Úget_cls_kwargs s rà Fc C s d S r- r1 rß r1 r1 r2 rà s c C s |dk}|rt }|dk s t| j dd¡}|oHt|tjoHt|jtj}|rt |\}}|
|
|¡ |s|s|rt d| dqdS nd}|r|r´| j D ]}t ||ddkr q´q| d¡ |S )ae Return 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 !
|
|
NrÇ Fz
|
given cls z doesn't have an __init__ method)rÝ rK )r\ rP r6 r7 r4 r© rª rÖ r rÜ r@ Ú TypeErrorÚ __bases__rà Údiscard) r[ rÝ rÞ ÚtoplevelZctrZhas_initr° Zhas_kwÚcr1 r1 r2 rà £ s4
|
ÿ ý
|
|
ÿ
|
|
z List[str]©Úfuncr, c C s t | ¡d S )zReturn the set of legal kwargs for the given `func`.
|
|
Uses getargspec so is safe to call for methods, functions,
|
etc.
|
|
r )r r¢ ©rç r1 r1 r2 Úget_func_kwargsØ s ré zcompat.FullArgSpec)r Úno_selfÚ_is_initr, c C sD t | ¡rtd| n&t | ¡rn|rb|rbt | ¡}t |jdd
|j|j |j
|
|j |j |j ¡S t | ¡S nÒt | ¡rÌ|r¾|s| jr¾t | j¡}t |jdd
|j|j |j
|
|j |j |j ¡S t | j¡S ntt | ¡ræt| j|ddS t| d rþt | j¡S t| dr4t | j¡r&t| j|dS td | n td | dS )
|
zþReturn 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: %sr NT)rê rë r Ú__call__)rê zCan't inspect callable: %s)r. Ú isbuiltinrá r r r¢ r¼ ÚargsÚvarargsÚvarkwrº Ú
|
kwonlyargsÚkwonlydefaultsr r¡ Ú__self__r ÚisclassÚget_callable_argspecrÇ r~ rì )r rê rë r® r1 r1 r2 rõ ã sX
|
|
|
ù
|
|
ù
|
|
ÿ ÿrõ z-Union[Callable[..., Any], compat.FullArgSpec]zDict[str, Optional[str]])r r r, c C sº t | rt | ¡}n| }tj| }t |d |d |d d|d ¡}|d r|d d }t |d dd
|d |d d|d ¡}n"|d rd|d }|}nd}|}d}|d rÌ|tttt |d 7 }|d rä|t|d 7 }|d |d }|r |d| d
} nd} tj||d |d | d d
|
d }
|
|d rdtj|dd
|d |d | d d
|
d } n|
|
} |rt||||
|
|| d S t|||dd
|
|
dd
|dd
| dd
d S dS )a Returns 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)'}
|
|
r r r Né z%s[0]r r1 c S s dt | S ©Nú=r
©r< r1 r1 r2 r p r z%format_argspec_plus.<locals>.<lambda>)Ú formatvaluec S s dt | S r÷ r
rù r1 r1 r2 r y r )Ú grouped_argsÚself_argÚ apply_posÚapply_kwÚapply_pos_proxiedÚapply_kw_proxiedéÿÿÿÿ) Úcallabler r¢ Úinspect_formatargspecÚlenr r r r¤ ) r r r® rî rý rü rÿ Ú num_defaultsZ name_argsZdefaulted_valsrþ r r1 r1 r2 r¥ s $
|
ÿ ÿ û
|
|
ûú
|
|
|
|
úr¥ c C s| | t jkr(d}|rdnd}|r"dnd}n@zt| |dW S tk
|
rf d}|rR|nd}|r^dnd }Y nX td|||||d
|
S ) a format_argspec_plus with considerations for typical __init__ methods
|
|
Wraps format_argspec_plus with error handling strategies for typical
|
__init__ cases::
|
|
object.__init__ -> (self)
|
other unreflectable (usually C) -> (self, *args, **kwargs)
|
|
z(self)rK z()Ú r z(self, *args, **kwargs)zself, *args, **kwargsz(*args, **kwargs)z*args, **kwargs)rü rû rý rþ rÿ r )ÚobjectrÇ r¥ rá r¤ )Úmethodr rû rî Zproxiedr1 r1 r2 Úformat_argspec_init s$
|
|
úr r1 zCallable[[_T], _T])Ú
|
target_clsÚtarget_cls_sphinx_nameÚproxy_cls_sphinx_nameÚ classmethodsÚmethodsÚ
|
attributesr, c C s dd }|S )aS A 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.
|
|
c S s | S r- r1 ro r1 r1 r2 r¶ Ã s z&create_proxy_methods.<locals>.decorater1 )r
|
r r r r r r¶ r1 r1 r2 Úcreate_proxy_methods± s r c C sT z t | ¡W S tk
|
rN | tjkr8dgdddf Y S dgdddf Y S Y nX dS )zúinspect.getargspec with considerations for typical __init__ methods
|
|
Wraps inspect.getargspec with error handling for typical __init__ cases::
|
|
object.__init__ -> (self)
|
other unreflectable (usually C) -> (self, *args, **kwargs)
|
|
rK Nrî Úkwargs)r r¢ rá r rÇ )r r1 r1 r2 Úgetargspec_initÉ s
|
r c C s t | tjr| js| jS | S dS )zSAdjust the incoming callable such that a 'self' argument is not
|
required.
|
|
N)r4 r© Ú
|
MethodTyperó r )Z func_or_clsr1 r1 r2 Úunbound_method_to_callableÛ s r zSequence[Tuple[str, Any]]z%Optional[Union[object, List[object]]])r+ Ú additional_kwÚ
|
to_inspectÚ
|
omit_kwargr, c sV |dkrg}n
|
t |¡}t g }t ¡ }d}t|D ]æ\}}zt |j¡} W n tk
|
rh Y q8Y q8X | j rzt
|
| j nd}
|
|dkrÄ| j r| j }|
|
r®| | j d|
|
¡ qè| | j dd
¡ n$| fdd| j d|
|
D ¡ |
|
r8| j söt| dd t| j |
|
d
| j D ¡ q8g } | fdd|D ¡ |dk rlt|rl| d d t|D ¡ | ¡ D ]f\} } | |krqtz6t| }| k r¾|| kr¾| d
|
| |f ¡ W n tk
|
rÖ Y nX qt|r@|D ]X\} } z6t| }| k r"|| kr"| d
|
| |f ¡ W n tk
|
r: Y nX qæd jjd | ¡f S ) z}Produce a __repr__() based on direct association of the __init__()
|
specification vs. same-named attributes present.
|
|
Nr r c s g | ] }| fqS r1 r1 ©ri r½ )Úmissingr1 r2 Ú
|
<listcomp> s z generic_repr.<locals>.<listcomp>c S s g | ]\}}||fqS r1 r1 )ri r½ Údefaultr1 r1 r2 r s ÿc 3 s | ]}t t |d V qd S r- )r¦ r8 r r0 r1 r2 rk s z generic_repr.<locals>.<genexpr>c S s g | ] }t |qS r1 ©r¦ )ri Úvalr1 r1 r2 r s z%s=%rz%s(%s)ú, )r Úto_listr Ú OrderedDictÚ enumerater r¢ rÇ rá rº r rï r_ rî r@ rP Úzipr~ r8 Úitemsr re ru rV rl )r+ r r r Zpos_argsZkw_argsZvargsr Zinspr® Z default_lenÚoutputr½ Zdefvalr r1 )r r+ r2 Ú generic_reprç sl
|
|
|
ÿ
|
ÿþÿ
|
|
|
r% c @ s6 e Zd ZdZdZdd Zdd Zd dd Zd
|
d Zd S )Úportable_instancemethodz_Turn an instancemethod into a (parent, name) pair
|
to produce a serializable callable.
|
|
)r r r Ú __weakref__c C s | j | j| jdS )N©r r r r( rJ r1 r1 r2 Ú __getstate__= s ýz$portable_instancemethod.__getstate__c C s& |d | _ |d | _| dd¡| _d S )Nr r r r1 )r r r7 r )rK Ústater1 r1 r2 Ú __setstate__D s
|
|
z$portable_instancemethod.__setstate__r1 c C s |j | _|j| _|| _d S r- )ró r rV r r )rK Úmethr r1 r1 r2 rÇ I s z portable_instancemethod.__init__c O s | | j¡ t| j| j||S r- )r@ r r8 r r )rK r½ Úkwr1 r1 r2 rì N s z portable_instancemethod.__call__N)r1 ) rV rW rX rY rZ r) r+ rÇ rì r1 r1 r1 r2 r& 5 s
|
r& c s² | h t | j}|rª| ¡ } fdd|jD }|D ]}| |¡ |¡ q4|jdkst|dsdq fddt|t s|
|
¡ n|
|
|¡D D ]}| |¡ |¡ qqt S )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.
|
|
c 3 s | ]}| kr|V qd S r- r1 ©ri Ú_©Zhierr1 r2 rk b s z"class_hierarchy.<locals>.<genexpr>r¸ r` c s g | ]}| kr|qS r1 r1 r. r0 r1 r2 r k s úz#class_hierarchy.<locals>.<listcomp>) r» Ú__mro__r] râ r r^ rW r~ Ú
|
issubclassr5 r` )r[ Úprocessrå r r Úsr1 r0 r2 Úclass_hierarchyS s$
|
|
|
ÿ
|
û
|
|
r5 c c s@ t | }|D ].}| jD ]"}||jkr||j| fV q qq dS )zÍiterate 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)Údirr1 r6 )r[ ÚkeysÚkeyrå r1 r1 r2 Úiterate_attributesy s
|
|
r9 ú
|
self.proxyc s< |r
|
|}n$dkrd fddt |D }|D ]}z4t||}t|dsRW q2t|d|}ttj|} W n tk
|
r Y q2Y nX z2t | ¡}
|
t |
|
d ¡} t |
|
d dd
¡} W n t
|
k
|
rÔ d } d
|
} Y nX d t } |dk rð||ipòi }t | | z| j || _ W n tk
|
r$ Y nX t ||| q2dS ) z9Automates delegation of __specials__ for a proxying type.N)rZ Ú__del__Ú__getattribute__Ú __metaclass__r) r+ c s6 g | ].}| d ¡r| d ¡rt |s|kr|qS )r )Ú
|
startswithÚendswithr~ ©ri rB ©Úinto_clsÚskipr1 r2 r s
|
|
|
úz0monkeypatch_proxied_specials.<locals>.<listcomp>rì r r r z(self, *args, **kw)z (*args, **kw)z?def %(method)s%(fn_args)s: return %(name)s.%(method)s%(d_args)s)r6 r8 r~ r r© rª rÕ r r¢ r rá ÚlocalsrÀ r¬ Úsetattr)rB Zfrom_clsrC Úonlyr Z from_instanceZdundersr Zmaybe_fnr r® Zfn_argsZd_argsÚpyr¯ r1 rA r2 Ú monkeypatch_proxied_specials sF
|
þ
|
|
|
|
|
|
ÿÿÿ
|
rH c C s t | d| t |d|kS )z;Return True if the two methods are the same implementation.r )r8 )Zmeth1Zmeth2r1 r1 r2 Úmethods_equivalentÌ s
|
ÿrI c C sp |s|st dt|tr(t| |r(| S t|p>dd t|D }tt| }tj}t|trd|}n|svt }tj}nt|}|| |¡|r| S t| t sÆ|tjkrªdp¬d}t d| |d
|
|¡f G dd d }|räd
|
|j |_ t } t | D ]R\}
|
} |
|
|krt d |
|
t | s*t d |
|
| f t||
|
t| | |
|
¡ qò|| |rV|S t d d
|
|| ¡ dS )a Ensure 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 requiredc S s g | ]}| d ¡s|qS )r/ )r> r@ r1 r1 r2 r û s
|
z as_interface.<locals>.<listcomp>zany ofzall ofz %r does not implement %s: %sr c @ s e Zd ZdZdS )z(as_interface.<locals>.AnonymousInterfacezA callable-holding shell.N©rV rW rX rY r1 r1 r1 r2 ÚAnonymousInterface s rK Z Anonymousz %r: unknown in this interfacez%r=%r is not callablez,dictionary does not contain required keys %sN)rá r4 r5 r\ r6 ÚoperatorÚgeÚgtÚ intersectionr¤ rl rV Údictlike_iteritemsr rE Ú staticmethodr^ ) r+ r[ r ÚrequiredZ interfaceZ implementedZcompliesZ qualifierrK Úfoundr rË r1 r1 r2 Ú as_interfaceÔ sP !
|
|
ÿÿ
|
|
ÿÿrT Ú_GFDzgeneric_fn_descriptor[Any]c @ sÊ e Zd ZU dZded< ded< ded< d$ddd d
|
d Zed d dd dddZeddddddZd ddddddZer ddd dddZ dd dd d Z
|
dd d d d Z e ddd d!d"d#Z dS )%Úgeneric_fn_descriptorag Descriptor 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]Úfgetú Optional[str]rY r; rV N©rW Údocc C s || _ |p|j| _|j| _d S r- ©rW rY rV ©rK rW rZ r1 r1 r2 rÇ < s z generic_fn_descriptor.__init__rU rF r ©rK r+ r[ r, c C s d S r- r1 ©rK r+ r[ r1 r1 r2 Ú__get__A s z generic_fn_descriptor.__get__r r! ©r+ r[ r, c C s d S r- r1 r^ r1 r1 r2 r_ E s zUnion[_GFD, _T_co]c C s
|
t d S r- ©ÚNotImplementedErrorr^ r1 r1 r2 r_ I s ©ÚinstancerN r, c C s d S r- r1 ©rK rd rN r1 r1 r2 Ú__set__N s z generic_fn_descriptor.__set__©rd r, c C s d S r- r1 )rK rd r1 r1 r2 Ú
|
__delete__Q s z generic_fn_descriptor.__delete__r* c C s
|
t d S r- ra ©rK r+ r1 r1 r2 Ú_resetT s z generic_fn_descriptor._reset)r+ r r, c C s
|
t d S r- ra ©r[ r+ r r1 r1 r2 ÚresetW s zgeneric_fn_descriptor.reset)N)rV rW rX rY r3 rÇ r r_ r rf rh rj Ú classmethodrl r1 r1 r1 r2 rV - s
|
|
rV c @ s e Zd ZdZesdd ZdS )Ú_non_memoized_propertyzÉa 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.
|
|
c C s |d kr | S | |¡S r- ©rW r^ r1 r1 r2 r_ g s z _non_memoized_property.__get__N)rV rW rX rY r r_ r1 r1 r1 r2 rn \ s rn c @ s0 e Zd ZdZesdd Zdd Zedd ZdS ) Ú_memoized_propertyz2A read-only @property that is only evaluated once.c C s& |d kr | S | |¡ |j| j< }|S r- )rW r6 rV ©rK r+ r[ Úresultr1 r1 r2 r_ r s z_memoized_property.__get__c C s t || j¡ d S r- )rp rl rV ri r1 r1 r2 rj x s z_memoized_property._resetc C s |j |d ¡ d S r- )r6 r] rk r1 r1 r2 rl { s z_memoized_property.resetN) rV rW rX rY r r_ rj rm rl r1 r1 r1 r2 rp m s rp r c s fdd}t | S )zàDecorate 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.
|
|
c s< | f|| fdd}j |_ j|_|| jj < S )Nc s S r- r1 ©Úar- ©rr r1 r2 Úmemo© s z6memoized_instancemethod.<locals>.oneshot.<locals>.memo)rV rY r6 ©rK rî r- rv ©r ru r2 Úoneshot¦ s z(memoized_instancemethod.<locals>.oneshotr )r ry r1 rx r2 Úmemoized_instancemethod s rz c @ s~ e Zd ZU dZesdZe Zded< ddddZ ddd d
|
Z
|
d d dd ddZ G dd de e ZedddddZdS )Ú HasMemoizedzA mixin class that maintains the names of memoized elements in a
|
collection for easy cache clearing, generative, etc.
|
|
r1 zFrozenSet[str]Ú_memoized_keysrF rG c C s | j D ]}| j |d ¡ qd S r- )r| r6 r] ©rK r¾ r1 r1 r2 Ú_reset_memoizationsÁ s
|
z HasMemoized._reset_memoizationsc C s | j D ]}|| jkstqd S r- )r| r6 rP r} r1 r1 r2 Ú_assert_no_memoizationsÅ s
|
z#HasMemoized._assert_no_memoizationsr; r )r8 rN r, c C s || j |< | j|hO _d S r- )r6 r| )rK r8 rN r1 r1 r2 Ú_set_memoized_attributeÉ s
|
z#HasMemoized._set_memoized_attributec @ sr e Zd ZU dZded< ded< ded< dddd d
|
d Zed d dd dddZeddddddZdd ZdS )z HasMemoized.memoized_attributezTA read-only @property that is only evaluated once.
|
|
:meta private:
|
|
úCallable[..., _T]rW rX rY r; rV NrY c C s || _ |p|j| _|j| _d S r- r[ r\ r1 r1 r2 rÇ Ø s z'HasMemoized.memoized_attribute.__init__r& rF r r] c C s d S r- r1 r^ r1 r1 r2 r_ Þ s z&HasMemoized.memoized_attribute.__get__r r` c C s d S r- r1 r^ r1 r1 r2 r_ â s c C s8 |d kr | S | |¡ |j| j< }| j| jhO _|S r- )rW r6 rV r| rq r1 r1 r2 r_ æ s
|
)N)rV rW rX rY r3 rÇ r r_ r1 r1 r1 r2 Úmemoized_attributeÍ s
|
r r# r c s" ddddd fdd }t | S )zMDecorate a method memoize its return value.
|
|
:meta private:
|
|
r )rK rî r- r, c sN | f|| fdd}j |_ j|_|| jj < | jj hO _ S )Nc s S r- r1 rs ru r1 r2 rv ø s zBHasMemoized.memoized_instancemethod.<locals>.oneshot.<locals>.memo)rV rY r6 r| rw rx ru r2 ry õ s z4HasMemoized.memoized_instancemethod.<locals>.oneshotr )r[ r ry r1 rx r2 rz í s z#HasMemoized.memoized_instancemethodN)rV rW rX rY r rZ Ú frozensetr| r3 r~ r r Úmemoized_propertyr r rm rz r1 r1 r1 r2 r{ ´ s
|
r{ c @ s, e Zd ZdZdZdd Zddddd Zd
|
S ) Ú MemoizedSlotszÇApply 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__.
|
|
r1 c C s t |d S r- )rÕ )rK r8 r1 r1 r2 Ú_fallback_getattr s z MemoizedSlots._fallback_getattrr; r )r8 r, c s d¡s d¡r tn|tjd rRtd }t| |S tjd rtd fdd} j|_|S ¡S d S )NZ_memoized_attr_Z_memoized_method_c s6 | | fdd}j |_ j|_t| S )Nc s S r- r1 rs ru r1 r2 rv ) s z8MemoizedSlots.__getattr__.<locals>.oneshot.<locals>.memo)rV rY rE )rî r- rv ©r r8 rK ru r2 ry & s
|
z*MemoizedSlots.__getattr__.<locals>.oneshot)r> rÕ r~ ru r8 rE rY r )rK r8 rN ry r1 r r2 Ú __getattr__ s ÿ
|
zMemoizedSlots.__getattr__N)rV rW rX rY rZ r r r1 r1 r1 r2 r
|
s r
c C sB t | tr:| ¡ ¡ } | dkr"dS | dkr.dS td| t| S )N)ÚtrueÚyesÚonÚyÚtÚ1T)ÚfalseÚnoÚoffrj ÚfÚ0Fz String is not true/false: %r)r4 r; Ústriprh Ú
|
ValueErrorrr r0 r1 r1 r2 Úasbool8 s
|
r z!Callable[[str], Union[str, bool]])Útextr, c s ddd fdd }|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* c s | kr | S t | S d S r- )r r0 ©r r1 r2 Ú bool_or_valueJ s z"bool_or_str.<locals>.bool_or_valuer1 )r r r1 r r2 Ú bool_or_strD s r ú Optional[int])rN r, c C s | dkr | S t | S )zCoerce to integer.N)r )rN r1 r1 r2 ÚasintS s r zOptional[Dict[str, Any]]rF )r- r8 rM Ú
|
flexi_boolÚdestr, c C sj |dkr | }|| krft |tr,t | | |sf| | dk rf|tkrV|rVt| | ||< n|| | ||< dS )zµIf '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)r4 r5 rr r )r- r8 rM r r r1 r1 r2 Úcoerce_kw_type[ s ÿþ þ
|
ý r r` c s$ t |}|ft fdd|D S )zbProduce a tuple structure that is cacheable using the __dict__ of
|
obj to retrieve values
|
|
c 3 s& | ] }| j kr| j | fV qd S r- ©r6 ©ri Úkr0 r1 r2 rk { s
|
z"constructor_key.<locals>.<genexpr>)rà r )r+ r[ r° r1 r0 r2 Úconstructor_keyu s ÿr£ )r+ r[ rî r- r, c s0 t |}| fdd| |¡D ¡ |||S )zInstantiate cls using the __dict__ of obj as constructor arguments.
|
|
Uses inspect to match the named arguments of ``cls``.
|
|
c 3 s& | ] }| j kr| j | fV qd S r- r r¡ r0 r1 r2 rk s
|
z#constructor_copy.<locals>.<genexpr>)rà r@ Ú
|
difference)r+ r[ rî r- r° r1 r0 r2 Úconstructor_copy s
|
ÿr¥ zCallable[[], int]rG c s$ t ¡ t d¡ fdd} | S )z%Return a threadsafe counter function.r c
|
s$ t W 5 Q R £ S Q R X d S r- )Únextr1 ©ÚcounterÚlockr1 r2 Ú_next s zcounter.<locals>._next)Ú threadingÚLockr Úcount)rª r1 r§ r2 r¨ s
|
r¨ zOptional[Type[Any]])Úspecimenr r, c C s t | dr*| jdk r$t| jtr$tS | jS t| tr8tnt}|| trJtS || trXtS || trftS t | drttS t | drtS t | drtS |S dS )zÄGiven 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__Nr r^ r\ )r~ r¯ r2 r\ r4 r5 r» r¤ )r® r Zisar1 r1 r2 Úduck_type_collection s*
|
ÿ
|
|
|
|
|
|
r° z'Union[Tuple[Type[Any], ...], Type[Any]])r½ Úargtyper r, c C s^ t | |r| S t |trBt d|d dd |D ¡t| f ¡nt d||t| f ¡d S )Nz8Argument '%s' is expected to be one of type %s, got '%s'z or c s s | ]}d | V qdS )z'%s'Nr1 )ri rt r1 r1 r2 rk È s z"assert_arg_type.<locals>.<genexpr>z6Argument '%s' is expected to be of type '%s', got '%s')r4 r r Ú ArgumentErrorrl r5 )r½ r± r r1 r1 r2 Úassert_arg_type¿ s
|
|
ÿÿ ÿÿr³ c s t drt ¡ S t dt dddkr>td t dr\ fdd}| S t d rtfd
|
d ¡ D S td dS ) z?Return a (key, value) iterator for almost any dict-like object.r# Ú __getitem__r7 Nz Object '%r' is not dict-likeÚiterkeysc 3 s, ¡ D ] } d k st| | fV qd S r- )rµ rP )r8 ©ÚdictlikeÚgetterr1 r2 ÚiteratorÝ s z$dictlike_iteritems.<locals>.iteratorr7 c 3 s | ]}| |fV qd S r- r1 )ri r8 )r¸ r1 r2 rk ä s z%dictlike_iteritems.<locals>.<genexpr>)r~ r» r# r8 rá Úiterr7 )r· r¹ r1 r¶ r2 rP Ñ s
|
|
|
rP c sH e Zd ZU dZded< dddd fdd Zd dd dd
|
d d Z ZS )Ú classpropertyaA A 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]rW r )rW r½ r- c s t j|f|| |j| _d S r- )ÚsuperrÇ rY )rK rW r½ r- ©ru r1 r2 rÇ ö s zclassproperty.__init__NzOptional[type]r` c C s
|
| |¡S r- ro r^ r1 r1 r2 r_ ú s zclassproperty.__get__)N)rV rW rX rY r3 rÇ r_ Ú __classcell__r1 r1 r½ r2 r» é s
|
|
r» c @ s< e Zd ZddddZdddddd Zd
|
d d d dZdS )Úhybridpropertyr rè c C s || _ || _d S r- )rç Úclslevel©rK rç r1 r1 r2 rÇ ÿ s zhybridproperty.__init__r r ©rd Úownerr, c C s$ |d kr| |¡}|S | |¡S d S r- ©rÀ rç ©rK rd rà Zclsvalr1 r1 r2 r_ s
|
zhybridproperty.__get__rq zhybridproperty[_T]ræ c C s
|
|| _ | S r- ©rÀ rÁ r1 r1 r2 Ú
|
classlevel
|
s zhybridproperty.classlevelN)rV rW rX rÇ r_ rÇ r1 r1 r1 r2 r¿ þ s r¿ c @ s^ e Zd ZddddZdddddd Zddd
|
d d d ZdddddZdddddZdS )Úrw_hybridpropertyr rè c C s || _ || _d | _d S r- )rç rÀ ÚsetfnrÁ r1 r1 r2 rÇ s zrw_hybridproperty.__init__r r r c C s$ |d kr| |¡}|S | |¡S d S r- rÄ rÅ r1 r1 r2 r_ s
|
zrw_hybridproperty.__get__rF rc c C s | j d k st| ||¡ d S r- )rÉ rP re r1 r1 r2 rf s zrw_hybridproperty.__set__rq zrw_hybridproperty[_T]ræ c C s
|
|| _ | S r- )rÉ rÁ r1 r1 r2 Úsetter s zrw_hybridproperty.setterc C s
|
|| _ | S r- rÆ rÁ r1 r1 r2 rÇ $ s z rw_hybridproperty.classlevelN)rV rW rX rÇ r_ rf rÊ rÇ r1 r1 r1 r2 rÈ s
|
rÈ c @ s@ e Zd ZdZddddZdddddd Zd
|
d d d dZdS )Ú hybridmethodz/Decorate a function as cls- or instance- level.r rè c C s | | _ | _|| _d S r- )rç r rÀ rÁ r1 r1 r2 rÇ , s zhybridmethod.__init__r r c C s* |d kr| j ||j¡S | j ||¡S d S r- )rÀ r_ ru rç )rK rd rà r1 r1 r2 r_ 0 s zhybridmethod.__get__rq zhybridmethod[_T]ræ c C s
|
|| _ | S r- rÆ rÁ r1 r1 r2 rÇ 6 s zhybridmethod.classlevelN)rV rW rX rY rÇ r_ rÇ r1 r1 r1 r2 rË ) s rË c @ s\ e Zd ZU dZded< i Zded< e ¡ Zddddd d d
|
d Z d d Z
|
dd Z dd Z dS )ÚsymbolaI A constant symbol.
|
|
>>> symbol('foo') is symbol('foo')
|
True
|
>>> symbol('foo')
|
<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; r zDict[str, symbol]ÚsymbolsNrX r )r rZ Ú canonicalr, c
|
C s | j | j |¡}|d krbt|ts*t|d kr:t|}t t |¡}||_
|
|rV||_ || j|< n |r||krt d| d| |W 5 Q R £ S Q R X d S )Nz#Can't replace canonical symbol for z with new int value ) Ú_lockrÍ r7 r4 r; rP Úhashr Ú__new__rÌ r rY rá )r[ r rZ rÎ r r1 r1 r2 rÑ O s ÿzsymbol.__new__c C s t | jdt| ffS )Nr< )rÌ r r rJ r1 r1 r2 Ú
|
__reduce__m s zsymbol.__reduce__c C s t | S r- r rJ r1 r1 r2 Ú__str__p s zsymbol.__str__c C s d| j dS )Nzsymbol(ú)©r rJ r1 r1 r2 Ú__repr__s s zsymbol.__repr__)NN) rV rW rX rY r3 rÍ r« r¬ rÏ rÑ rÒ rÓ rÖ r1 r1 r1 r2 rÌ ; s
|
ü rÌ c @ s0 e Zd ZddddddddZd d
|
d d Zd S )Ú _IntFlagMetar; zTuple[Type[Any], ...]r¿ r rF )Ú classnamer Údict_r- r, c K sz g | _ }| ¡ D ]L\}}t|tr2t||d}n| d¡stdnqt| || | |¡ qt
|
dd |D ¡| _ d S )N)rÎ r/ z#Expected integer values for IntFlagc S s i | ] }|j |qS r1 rÕ )ri r r1 r1 r2 Ú
|
<dictcomp> s z)_IntFlagMeta.__init__.<locals>.<dictcomp>) Z_itemsr# r4 r rÌ r> rá rE r r Z immutabledictÚ __members__) r[ rØ r rÙ r- r# r¢ Úvr r1 r1 r2 rÇ x s
|
|
|
|
ÿz_IntFlagMeta.__init__zIterator[symbol]rG c C s t dd S )Nziter not implemented to ensure compatibility with Python 3.11 IntFlag. Please use __members__. See https://github.com/python/cpython/issues/99304ra rJ r1 r1 r2 Ú__iter__ s ÿz_IntFlagMeta.__iter__N)rV rW rX rÇ rÝ r1 r1 r1 r2 r× w s r× c @ s e Zd ZdZdS )Ú _FastIntFlagzÆAn 'IntFlag' copycat that isn't slow when performing bitwise
|
operations.
|
|
the ``FastIntFlag`` class will return ``enum.IntFlag`` under TYPE_CHECKING
|
and ``_FastIntFlag`` otherwise.
|
|
NrJ r1 r1 r1 r2 rÞ s rÞ )Ú metaclass)ÚIntFlagÚ_EzDict[_E, List[Any]]z Optional[_E])r½ Úchoicesr Úresolve_symbol_namesr, c C sn | ¡ D ]>\}}| |kr | S |r6| |jkr6| S | |kr| S q| dkrTdS t d| d| ¡dS )aO Given 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# r r r² )r½ râ r rã Z
|
enum_valueÚchoicer1 r1 r2 Ú parse_user_argument_for_enum¬ s
|
rå rg c C s t | _ t d7 a dS )zÞAssign 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).
|
|
r N)Ú_creation_order)rd r1 r1 r2 Úset_creation_orderÑ s rç )rç rî r r, c O s> z | ||W S t k
|
r8 tdt ¡ dd
Y nX dS )zXexecutes the given function, catches all exceptions and converts to
|
a warning.
|
|
z%s('%s') ignoredr r N)re ÚwarnrH rI )rç rî r r1 r1 r2 Úwarn_exceptionÞ s ré é c C sF z(t | |kr d| d|
W S | W S W n tk
|
r@ | Y S X d S )Nz%s...r )r rá )rN Zlen_r1 r1 r2 Úellipses_stringé s
|
rë c sT e Zd ZU dZded< dddd d fdd Zdd d
|
d Zd d dddZ ZS )Ú_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])rN Únumrî r, c s< || d| }t | |¡}td|t|| f |_|S )Nz6 (this warning may be suppressed after %d occurrences)z%s_%d)r¼ rÑ rÐ rí )r[ rN rï rî Z interpolatedrK r½ r1 r2 rÑ s ÿz_hash_limit_string.__new__rG c C s | j S r- )rí rJ r1 r1 r2 Ú__hash__
|
s z_hash_limit_string.__hash__r rr )Úotherr, c C s t | t |kS r- )rÐ )rK rñ r1 r1 r2 Ú__eq__ s z_hash_limit_string.__eq__) rV rW rX rY r3 rÑ rð rò r¾ r1 r1 r½ r2 rì ó s
|
|
|
|
rì rX )Úmsgr³ r, c C s( |rt tj| |d n t | tj dS )zdIssue a warning.
|
|
If msg is a string, :class:`.exc.SAWarning` is used as
|
the category.
|
|
)r³ N)Ú_warnings_warnr Ú SAWarning)ró r³ r1 r1 r2 rè s rè rî )ró rî r, c C s |rt | d|} t| tj dS )z\Issue a warning with a parameterized string, limiting the number
|
of registrations.
|
|
é
|
N)rì rô r rõ )ró rî r1 r1 r2 Ú warn_limited s r÷ z)Dict[CodeType, Tuple[str, Type[Warning]]]Ú _warning_tagsz Type[Warning]zCallable[[_F], _F])ÚmessageÚcategoryr, c s fdd}|S )Nc s ft | j< | S r- )rø rÖ rx ©rú rù r1 r2 Úgo. s z#tag_method_for_warnings.<locals>.gor1 )rù rú rü r1 rû r2 Útag_method_for_warnings+ s rý z&^(?:sqlalchemy\.(?!testing)|alembic\.)zUnion[str, Warning]zOptional[Type[Warning]])rù rú Ú
|
stacklevelr, c C sì zt |¡}W n& tk
|
r& d}Y n d}Y nX d }}|d k r¸|sdt t|j dd¡¡sdd}|jt krd}t |j \}}|p|}| d| d} |j
|
}|s¬|d7 }q>|r>|r>q¸q>|d k rÖt j | ||d d nt j | |d d d S )
|
Nr FrV r Tz (rÔ r )rþ ) rH Ú _getframer rm ÚmatchÚ_not_sa_patternÚ f_globalsr7 Úf_coderø Úf_backÚwarningsrè )rù rú rþ ÚframeZstacklevel_foundZwarning_tag_foundÚ_suffixZ _categoryr1 r1 r2 rô 8 s4
|
ÿ
|
|
rô r zCallable[..., Optional[_T]])r Úretry_on_exceptionr, c s$ gdddd fdd }|S )zNDecorate the given function to be a no-op after it is called exactly
|
once.r z Optional[_T]©r½ r- r, c s@ }r< ¡ }z || |W S r4 d|¡ Y nX d S )Nr )r] Úinsert)r½ r- Z strong_fnZonce_fn©r Úoncer r1 r2 rü t s zonly_once.<locals>.gor1 )r r rü r1 r r2 Ú only_oncel s r z%sqlalchemy/([a-z_]+/){0,2}[a-z_]+\.pyzunit(?:2|test2?/)zre.Pattern[str])ÚtbÚexclude_prefixÚexclude_suffixr, c C s` d}t | d }||kr0| | | ¡r0|d7 }q||krP| | | ¡rP|d8 }q0| ||d
S )at Chop 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``
|
r r )r Úsearch)r r r r{ Úendr1 r1 r2 Úchop_traceback s
|
|
r c C s$ d| }t ¡ }t|| |d S )Nz&def set(obj, value): obj.%s = valuer\ )rD ÚcopyrÀ )Úattrnamer³ r¯ r1 r1 r2 Ú
|
attrsetter§ s
|
|
r c s* e Zd ZdZdZdd fdd Z ZS )Ú
|
TypingOnlyzA mixin class that marks a class as 'typing only', meaning it has
|
absolutely no methods, attributes, or runtime functionality whatsoever.
|
|
r1 rF rG c sL t | jkr>t| j dddddh¡}|r>td| d| dt ¡ d S ) NrW rY rZ Ú__orig_bases__r3 zClass z< directly inherits TypingOnly but has additional attributes rÎ )r râ r\ r6 r¤ rP r¼ Ú__init_subclass__)r[ Ú remainingr½ r1 r2 r ¶ s
|
|
ûÿ ÿz TypingOnly.__init_subclass__)rV rW rX rY rZ r r¾ r1 r1 r½ r2 r ® s r c sD e Zd ZU dZded< dd fdd Zeddd d
|
d Z ZS ) Ú EnsureKWArga6 Apply 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_kwargrF rG c sf | j }| j}|rX|D ]B}t ||¡}|r|| }t |¡}|js| |¡}t| || qt
|
¡ d S r- ) r r6 rm r r r¢ rð Ú
|
_wrap_w_kwrE r¼ r )r[ Zfn_regZclsdictr8 rB r r® Úwrappedr½ r1 r2 r Ü s
|
|
z EnsureKWArg.__init_subclass__rq r c s dddd fdd }t | S )Nr r c s | S r- r1 )r½ r- rx r1 r2 Úwrapì s z$EnsureKWArg._wrap_w_kw.<locals>.wrapr )r[ r r r1 rx r2 r ê s zEnsureKWArg._wrap_w_kw) rV rW rX rY r3 r rm r r¾ r1 r1 r½ r2 r É s
|
|
r c C sj t |drt| |S | }|jj|_t |dr4|j|_t |jdrT|jjrT|jj|_n|jrb|j|_|S dS )zAugment functools.update_wrapper() to work with objects with
|
a ``__call__()`` method.
|
|
:param fn:
|
object with __call__ method
|
|
rV rW rY N)r~ r ru rV rW rì rY )Úwrapperr Z_fr1 r1 r2 Ú wrap_callableò s
|
|
|
|
r! c C sÈ d| kr| d¡S d}g g}d}t| }||k rº| | }|dkr|dkr|||d k r|| |d dkr||d d¡ |d7 }q°|dN }n*|dkr¢|dkr¢| g ¡ n|d |¡ |d7 }q(dd |D S )aÄ Parse 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']
|
|
ú"rÎ r r r c S s g | ]}d |¡qS )r )rl )ri rÑ r1 r1 r2 r 3 s z'quoted_token_parser.<locals>.<listcomp>)rÐ r r )rN r* rr ÚidxÚlvÚcharr1 r1 r2 Úquoted_token_parser
|
s$
|
$
|
|
|
r& )Úparamsr r, c s t ¡ fdd}|S )Nc s: | j d k r| j pd}|r0t|fdd D }|| _ | S )Nr c s i | ]
|
}| qS r1 r1 )ri Úparamr r1 r2 rÚ < s z8add_parameter_text.<locals>.decorate.<locals>.<dictcomp>)rY Úinject_param_text)r rZ ©r' r r1 r2 r¶ 9 s
|
z$add_parameter_text.<locals>.decorate)r r )r' r r¶ r1 r* r2 Úadd_parameter_text6 s
|
r+ c C sN | dd¡}t|dkr | S |\}}| d¡s@|d t |¡ S t | ¡S d S )NÚ
|
r rg )rÐ r r> ÚtextwrapÚdedent)r Z
|
split_textÚ firstliner r1 r1 r2 Ú_dedent_docstringC s
|
r0 )Ú given_doctextÚ
|
injecttextÚposr, c C sª t | pd}| d¡}t|dkr,| d¡ t |¡ d¡}|d rP| dd¡ dd t|D }| dd¡ |t|t|d }|d|
| ||d
}d |¡S )Nr r, r r c S s g | ]\}}| ¡ s|qS r1 )r )ri rï Úliner1 r1 r2 r Z s z)inject_docstring_text.<locals>.<listcomp>)
|
r0 rÐ r r r- r. r
|
r! Úminrl )r1 r2 r3 ÚdoctextÚlinesZ injectlinesZblanksZ
|
inject_posr1 r1 r2 Úinject_docstring_textO s
|
|
r8 z(\s+):param (.+?):zDict[str, str])r6 Ú inject_paramsr, c
|
C s t | ¡ ¡}g }d }|r| ¡ }t |¡}|d kr |rö| d¡ d¡}||krödt| d¡ d }|rt d|d ¡} | rdt| d¡ }||| }nV|rº|
|
d|dg¡ d }n<| ¡ sØ|
|
||dg¡ d }n | d¡rö|
|
|| ¡ g¡ q| |¡ qd |¡S ) Nr Ú*rg r z(\s+)\Sr r, z::)Ú collectionsÚdequeÚ
|
splitlinesÚpopleftÚ
|
_param_regr rÄ Úlstripr rm r_ Úrstripr? r rl )
|
r6 r9 Zdoclinesr7 Z to_injectr4 rB r( ÚindentÚm2r1 r1 r2 r) f s6
|
|
r) )r° r, c C s t | dkrdS t | dk}|r,| dd
n| dd
| dd
} dd | D }|r`d |¡S d d |dd
¡|d f S dS )
|
zTrims a list of strings from the middle and return a string of up to
|
four elements. Strings greater than 11 characters will be truncatedr Nrö r r c S s, g | ]$}t |d kr$d|dd
n|qS )é z%s..N)r )ri r r1 r1 r2 r s z$repr_tuple_names.<locals>.<listcomp>r z %s, ..., %s)r rl )r° ÚflagÚresr1 r1 r2 Úrepr_tuple_names s (
|
rG c C s t rdS | rtdndS d S )NTzDcython extensions were expected to be installed, but are not presentF)r Ú ImportError)Zraise_r1 r1 r2 Úhas_compiled_ext s ÿrI )FF)T)T)r1 r1 r1 )r1 Nr1 )NNr: N)NNN)TN)N)F)rê )N)Nr )F)rY Ú
|
__future__r r; ÚenumÚ functoolsr r> r. r rL rm rH r- r« r© r Útypingr r r r r
|
r r r r r r r r r r r r r r r r r r Z_has_cyr r r r r! r# r% r& r' r( Zpy310r/ rC rD rc rf rp rw r r r r r· r£ r« rÁ r rà rÜ rà ré rõ r¥ r r r r r% r& r5 r9 rH rI rT rU rV rn rp r Znon_memoized_propertyÚpropertyZro_memoized_propertyZro_non_memoized_propertyrz r{ Z!HasMemoized_ro_memoized_attributer r
r r r r r£ r¥ r¨ r° r³ rP r» r¿ rÈ rË r rÌ r5 r× rÞ rà Z FastIntFlagÚEnumrá rå ræ rç ré rë r; rì rè r÷ rø r3 rý Úcompiler rô r Z_SQLA_REZ _UNITTEST_REr ZNoneTyper r r r! r& r+ r0 r8 r? r) rG rI r1 r1 r1 r2 Ú<module> sh ;
|
@(ü ÿ ÿ5 ÿ;ÿu # ú üN & ú
|
C V / P. û ÿ#<
|
ü"
|
|
|
ý 4 ý ) , +
|
