a lct@s*dZddlmZmZmZddlZddlZddlZddlZddl m Z dZ gdZ e e jZe ejZeeejfZd#ddZd d Zd d ZGd ddeZGdddeZGdddeZedddZedddZedddZedddZedddZ GdddeZ!Gdd d eZ"Gd!d"d"eZ#dS)$zFunction signature objects for callables Back port of Python 3.3's function signature tools from the inspect module, modified to be compatible with Python 2.6, 2.7 and 3.2+. )absolute_importdivisionprint_functionN) OrderedDictz0.3)BoundArguments Parameter Signature signaturecCs8t|tr0|jdd|fvr |jS|jd|jSt|S)Nbuiltins __builtin__.) isinstancetype __module____name__repr) annotation base_modulerP/var/www/html/django/DPS/env/lib/python3.9/site-packages/backcall/_signatures.pyformatannotation,s  rcGsZz2|turWdSt||}|D]}t|||}qWntyFYdS0t|tsV|SdSN)rgetattrAttributeErrorr _NonUserDefinedCallables)cls method_namenestedmethnamerrr_get_user_defined_method4s   r c Cst|std|t|tjrJt|j}|jt |j dddSz |j }Wnt yfYn0|durt|Sz |j}Wnt yYn 0t|St|tjrt|St|tjrt|j}t|j }|jpd}|jpi}z|j|i|}Wn8ty6}zd|}t|WYd}~n d}~00|jD]R\} } || } | |vrp| j| dd|| <n"| jttfvrB| jsB| | qB|j| dSd}t|t!rt"t!|d } | durt| }n:t"|d } | durt| }nt"|d }|durBt|}n.t|t#sBt"t!|d d } | durBt| }|durP|St|tj$rpd |}t|td|dS)z/Get a signature object for the passed callable.z{0!r} is not a callable objectN) parametersrz,partial object {0!r} has incorrect argumentsT)default_partial_kwarg__call____new____init__Zim_funcz-no signature found for builtin function {0!r}z,callable {0!r} is not supported by signature)%callable TypeErrorformatr types MethodTyper __func__replacetupler"values __signature__r __wrapped__ FunctionTyper from_function functoolspartialfuncritemsargskeywords bind_partial ValueError argumentskind _VAR_KEYWORD_VAR_POSITIONALr$poprr rBuiltinFunctionType)objsigwrapped new_params partial_argspartial_keywordsbaexmsgZarg_name arg_valueparamcallnewinitrrrr Dsx                           r c@seZdZdZdS)_voidz0A private marker - used in Parameter & SignatureN)rr __qualname____doc__rrrrrQsrQc@s eZdZdS)_emptyN)rrrRrrrrrTsrTc@s$eZdZddZddZddZdS)_ParameterKindcOs tj|g|R}|d|_|S)Nr)intr&_name)selfr9kwargsrCrrrr&s z_ParameterKind.__new__cCs|jSrrWrXrrr__str__sz_ParameterKind.__str__cCs d|jS)Nz<_ParameterKind: {0!r}>)r*rWr[rrr__repr__sz_ParameterKind.__repr__N)rrrRr&r\r]rrrrrUsrUPOSITIONAL_ONLYrr!POSITIONAL_OR_KEYWORDVAR_POSITIONAL KEYWORD_ONLY VAR_KEYWORDc@seZdZdZdZeZeZe Z e Z e ZeZeedfddZeddZedd Zed d Zed d ZeeeeefddZddZddZddZddZddZdS)raRepresents a parameter in a function signature. Has the following public attributes: * name : str The name of the parameter as a string. * default : object The default value for the parameter if specified. If the parameter has no default value, this attribute is not set. * annotation The annotation for the parameter if specified. If the parameter has no annotation, this attribute is not set. * kind : str Describes how argument values are bound to the parameter. Possible values: `Parameter.POSITIONAL_ONLY`, `Parameter.POSITIONAL_OR_KEYWORD`, `Parameter.VAR_POSITIONAL`, `Parameter.KEYWORD_ONLY`, `Parameter.VAR_KEYWORD`. )rW_kind_default _annotationr$FcCs|tttttfvrtd||_|turF|ttfvrFd|}t|||_ ||_ |durr|tkrjtd||_ n8t |}|tkrt d|t jsd|}t|||_ ||_dS)Nz,invalid value for 'Parameter.kind' attributez){0} parameters cannot have default valueszr#rr$rKrrrr's*   zParameter.__init__cCs|jSrrZr[rrrr szParameter.namecCs|jSr)rhr[rrrr#szParameter.defaultcCs|jSr)rir[rrrrszParameter.annotationcCs|jSr)rgr[rrrr>szParameter.kindcCs\|tur|j}|tur|j}|tur*|j}|tur8|j}|turF|j}t||||||dS)z+Creates a customized copy of the Parameter.)r#rr$)rQrWrgrirhr$r)rXrr>rr#r$rrrr.szParameter.replacecCs|j}|j}|tkr*|dur d}d|}|jturFd|t|j}|jturbd|t|j}|t krtd|}n|t krd|}|S)Nz<{0}>z{0}:{1}z{0}={1}*z**) r>rWrjr*rirTrrhrr@r?)rXr> formattedrrrr\1s"    zParameter.__str__cCsd|jjt||jS)Nz<{0} at {1:#x} {2!r}>)r* __class__ridrr[rrrr]Is  zParameter.__repr__cCsd|jj}t|dSNzunhashable type: '{0}'r*rtrr)rXrKrrr__hash__MszParameter.__hash__cCs<t|jto:|j|jko:|j|jko:|j|jko:|j|jkSr) issubclassrtrrWrgrhrirXotherrrr__eq__Qs     zParameter.__eq__cCs || Srr}r{rrr__ne__XszParameter.__ne__N)rrrRrS __slots__rjr^rkr`r@rbrlrdr?rfrTemptyr'propertyrr#rr>rQr.r\r]ryr}rrrrrrs6      rc@sTeZdZdZddZeddZeddZedd Zd d Z d d Z ddZ dS)raResult of `Signature.bind` call. Holds the mapping of arguments to the function's parameters. Has the following public attributes: * arguments : OrderedDict An ordered mutable mapping of parameters' names to arguments' values. Does not contain arguments' default values. * signature : Signature The Signature object that created this instance. * args : tuple Tuple of positional arguments values. * kwargs : dict Dict of keyword arguments values. cCs||_||_dSr)r= _signature)rXr r=rrrr'mszBoundArguments.__init__cCs|jSr)rr[rrrr qszBoundArguments.signaturec Csg}|jjD]h\}}|jttfvs,|jr0qzz|j|}WntyVYqzYq0|jt krn| |q| |qt |Sr) rr"r8r>r?rlr$r=KeyErrorr@extendappendr/)rXr9 param_namerMargrrrr9us     zBoundArguments.argsc Csi}d}|jjD]|\}}|sJ|jttfvs4|jr:d}n||jvrJd}q|sPqz|j|}WntypYq0|jtkr| |q|||<q|S)NFT) rr"r8r>r?rlr$r=rupdate)rXrYkwargs_startedrrMrrrrrYs*     zBoundArguments.kwargscCsd|jj}t|dSrvrwrxrrrryszBoundArguments.__hash__cCs$t|jto"|j|jko"|j|jkSr)rzrtrr r=r{rrrr}s    zBoundArguments.__eq__cCs || Srr~r{rrrrszBoundArguments.__ne__N) rrrRrSr'rr r9rYryr}rrrrrr\s   rc@seZdZdZdZeZeZe Z de dfddZ e ddZ ed d Zed d Zeefd dZddZddZddZdddZddZddZddZdS)raA Signature object represents the overall signature of a function. It stores a Parameter object for each parameter accepted by the function, as well as information specific to the function itself. A Signature object has the following public attributes and methods: * parameters : OrderedDict An ordered mapping of parameters' names to the corresponding Parameter objects (keyword-only arguments are in the same order as listed in `code.co_varnames`). * return_annotation : object The annotation for the return type of the function if specified. If the function has no annotation for its return type, this attribute is not set. * bind(*args, **kwargs) -> BoundArguments Creates a mapping from positional and keyword arguments to parameters. * bind_partial(*args, **kwargs) -> BoundArguments Creates a partial mapping from positional and keyword arguments to parameters (simulating 'functools.partial' behavior.) )_return_annotation _parametersNTc Cs|durt}n|rt}t}t|D]z\}}|j}||krXd} | ||j} t| n|}|j} | dur~t|} |j| d}| |vrd| } t| ||| <q&ntdd|D}||_ ||_ dS)zConstructs Signature from the given list of Parameter objects and 'return_annotation'. All arguments are optional. Nz%wrong parameter order: {0} before {1}r_zduplicate parameter name: {0!r}css|]}|j|fVqdSrr_).0rMrrr sz%Signature.__init__..) rrj enumerater>r*r<rrmr.rr) rXr"return_annotation__validate_parameters__paramstop_kindidxrMr>rKrrrrr's2    zSignature.__init__c Cst|tjstd||j}|j}|j}|j}t |d|}t |dd}||||}t |di} |j } t |dd} | rt | } nd} g} || }|d|D]$}| |t}| |||tdqt||dD].\}}| |t}| |||t| |dq|jd @rD|||}| |t}| |||td|D]B}t}| durf| |t}| |t}| |||t|dqH|jd @r||}|jd @r|d 7}||}| |t}| |||td|| | d td dS)z2Constructs Signature for the given python functionz{0!r} is not a Python functionNco_kwonlyargcountr__annotations____kwdefaults__)rr>)rr>r#rer!returnF)rr)r r+r3r)r*_parameter_cls__code__ co_argcount co_varnamesr/r __defaults__lengetrTrrkrco_flagsr@rlr?)rr7r func_code pos_count arg_names positionalkeyword_only_count keyword_only annotationsdefaults kwdefaultspos_default_countr"non_default_countrroffsetr#indexrrrr4sp                         zSignature.from_functioncCs4zt|jWSty.t|jYS0dSr)r+MappingProxyTyperrrr8r[rrrr"Js zSignature.parameterscCs|jSr)rr[rrrrQszSignature.return_annotationcCs0|tur|j}|tur |j}t|||dS)zCreates a customized copy of the Signature. Pass 'parameters' and/or 'return_annotation' arguments to override them in the new copy. )r)rQr"r0rr)rXr"rrrrr.Us zSignature.replacecCsd|jj}t|dSrvrwrxrrrrydszSignature.__hash__c Cstt|tr.|j|jks.t|jt|jkr2dStddt|jD}t|j D]\}\}}|j t krz|j|}Wnt yYdS0||krdSq\z ||}Wnt yYdS0||ks||j|kr\dSq\dS)NFcss|]\}}||fVqdSrr)rrrMrrrrnsz#Signature.__eq__..T) rzrrrrr"dictrkeysr8r>rlr)rXr|Zother_positionsrrrMZ other_paramZ other_idxrrrr}hs4         zSignature.__eq__cCs || Srr~r{rrrrszSignature.__ne__Fc Cst}t|j}d}t|}|rP|jD] \}} | jr.||vr.| j||<q.z t|} Wnty8z t|} WntyYYqYn0| j t krYqn| j |vr| j t krd} | j | j d} t| | f}YqnR| j tks| jtur| f}Yqn.|r| f}Yqnd} | j | j d} t| YqP0z t|} WntybtdYqP0| j ttfvr|td| j t kr| g} | |t| || j <q| j |vrtdj | j d| || j <qPd} t||D]} | j t krtdj | j d| j tkr| } q| j }z||} WnBtyp|sl| j t krl| jturltdj |dYn 0| ||<q|r| dur||| j <ntd|||S) z$Private method. Don't use directly.rzA{arg!r} parameter is positional only, but was passed as a keyword)rz'{arg!r} parameter lacking default valueztoo many positional argumentsz$multiple values for argument {arg!r}Nztoo many keyword arguments)riterr"r0r8r$r#next StopIterationr>r@rrjr*r)r?rTrlrr/ itertoolschainrAr_bound_arguments_cls)rXr9rYr6r=r" parameters_exarg_valsrrMarg_valrKr0 kwargs_paramrrr_binds                  zSignature._bindcOs |||S)zGet a BoundArguments object, that maps the passed `args` and `kwargs` to the function's signature. Raises `TypeError` if the passed arguments can not be bound. rrXr9rYrrrbind szSignature.bindcOs|j||ddS)zGet a BoundArguments object, that partially maps the passed `args` and `kwargs` to the function's signature. Raises `TypeError` if the passed arguments can not be bound. T)r6rrrrrr;szSignature.bind_partialc Csg}d}t|jD]H\}}t|}|j}|tkr:d}n|tkrT|rT|dd}||qdd |}|j t urt |j }|d|7}|S)NTFrrz({0})z, z -> {0}) rr"r0rmr>r@rlrr*joinrrTr) rXresultrender_kw_only_separatorrrMrsr>renderedannorrrr\s      zSignature.__str__)F)rrrRrSrrrrrrTrr' classmethodr4rr"rrQr.ryr}rrrr;r\rrrrrs. & H   r)N)$rS __future__rrrrr5rnr+ collectionsr __version____all__rr%_WrapperDescriptorall_MethodWrapperrBrrr r objectrQrTrVrUrjrkr@rlr?rrrrrrrs:    p      a