o حh @sddlmZddlZddlZddlZddlZddlmZddlmZddl m Z ddl m Z ddl mZddlmZejd krCejZnd d Zz dd l mZmZmZWneyfdd lmZmZmZYnwzdd l mZWn ey|ddZYnwzddl mZWn eyddZYnwzddl mZWn eyddZYnwzddlmZmZm Z m!Z!m"Z"m#Z#m$Z$Wn eyYnwejdkZ%e%sefZ&ne'fZ&e(dZ)            daddZ*ddZ+        dbdd Z,d!d"Z-d#d$Z.d%d&Z/Gd'd(d(Z0d)d*Z1d+d,Z2e3ee4e5fZ6d-d.Z7d/d0Z8d1d2Z9d3d4Z:d5d6Z;d7d8ZZ?dcd;d<Z@ ddd>d?ZAded@dAZB            dfdBdCZCdDdEZD        dbdFdGZEdHdIZF = = = JdgdKdLZGdMdNZHdOdPZIe%rGdQdRdRZJeJZKndZKdSdTZLdUdVZMGdWdXdXeNZOGdYdZdZePZQGd[d\d\eRZS  =dhd]d^ZT  = did_d`ZUdS)j)print_functionN) OrderedDict)copy) getsource) iskeyword)dedent) FunctionType)rcCs4t|dks |drdStdd|dDS)z Replacement for `str.isidentifier` when it is not available (e.g. on Python 2). :param string: :return: rFcSs g|] }t|dkp |qSr)lenisalnum).0srQ/var/www/html/stock_analysis/be/venv/lib/python3.10/site-packages/makefun/main.py s z!is_identifier.._)r isdigitallsplit)stringrrr is_identifiersr) signature Signature Parameter)iscoroutinefunctioncCdSNFrfrrrr)r)isgeneratorfunctioncCrrrrrrrr!0r r!)isasyncgenfunctioncCrrrrrrrr"7r r")CallableAnyUnionIterableDictTupleMapping)r z(?s)^\s*(?P[_\w][_\w\d]*)?\s*\(\s*(?P.*?)\s*\)\s*(((?P->\s*[^:]+)?(?P:)?\s*)|:\s*#\s*(?P.+))*$FTcKs.t|f|||||||| | | | | d ||S)z Creates a signature-preserving wrapper function. `create_wrapper(wrapped, wrapper, **kwargs)` is equivalent to `wraps(wrapped, **kwargs)(wrapper)`. See `@makefun.wraps` ) new_sig prepend_args append_args remove_args func_nameinject_as_first_arg add_sourceadd_impldocqualname module_nameco_name)wraps)wrappedwrapperr*r+r,r-r.r/r0r1r2r3r5r4attrsrrrcreate_wrapperOs r:cGsRt||g|R}t|tjr'|dus|dkr't|dkr't|j|g|RS|S)z> Same as getattr but recurses in obj.func if obj is a partial N__dict__r)getattr isinstance functoolspartialr getattr_partial_awarefunc)objatt_name att_defaultvalrrrr@ks  r@c  Ksz | dtdd} Wn tyt} Ynwt| \} } d}|dur-t|dd}d}|du}|s=|dur:d}n|}nt|sKt|sKtd |d}|durYt|d d}d}|durct|d d}| durmt|d d} t |t rt || \}}}|dur|s|}|s|}|s|}t| }|r|rt |nd }||dd}n*|dur||}n!t |t rt| }|rt|| }nt||| }ntdt|t|}t|}t|\}}}dd|D}d|}|rd||f}t|rtjdkrd||f}n2d dlm}|||f}n$t|rd||f}n|r1|r,d||f}n d|}nd||f}t|rDd|dd}t | |||| d<|rYt!d||| }nt!|||| }|rg|| d <|rn|| d!<t"|||||t#||| | d" |S)#a Creates a function with signature `func_signature` that will call `func_impl` when called. All arguments received by the generated function will be propagated as keyword-arguments to `func_impl` when it is possible (so all the time, except for var-positional or positional-only arguments that get passed as *args. Note that positional-only does not yet exist in python but this case is already covered because it is supported by `Signature` objects). `func_signature` can be provided in different formats: - as a string containing the name and signature without 'def' keyword, such as `'foo(a, b: int, *args, **kwargs)'`. In which case the name in the string will be used for the `__name__` and `__qualname__` of the created function by default - as a `Signature` object, for example created using `signature(f)` or handcrafted. Since a `Signature` object does not contain any name, in this case the `__name__` and `__qualname__` of the created function will be copied from `func_impl` by default. All the other metadata of the created function are defined as follows: - default `__name__` attribute (see above) can be overridden by providing a non-None `func_name` - default `__qualname__` attribute (see above) can be overridden by providing a non-None `qualname` - `__annotations__` attribute is created to match the annotations in the signature. - `__doc__` attribute is copied from `func_impl.__doc__` except if overridden using `doc` - `__module__` attribute is copied from `func_impl.__module__` except if overridden using `module_name` - `__code__.co_name` (see above) defaults to the same value as the above `__name__` attribute, except when that value is not a valid Python identifier, in which case it will be ``. It can be overridden by providing a `co_name` that is either a valid Python identifier or ``. Finally two new attributes are optionally created - `__source__` attribute: set if `add_source` is `True` (default), this attribute contains the source code of the generated function - `__func_impl__` attribute: set if `add_impl` is `True` (default), this attribute contains a pointer to `func_impl` A lambda function will be created in the following cases: - when `func_signature` is a `Signature` object and `func_impl` is itself a lambda function, - when the function name, either derived from a `func_signature` string, or given explicitly with `func_name`, is not a valid Python identifier, or - when the provided `co_name` is ``. :param func_signature: either a string without 'def' such as "foo(a, b: int, *args, **kwargs)" or "(a, b: int)", or a `Signature` object, for example from the output of `inspect.signature` or from the `funcsigs.signature` backport. Note that these objects can be created manually too. If the signature is provided as a string and contains a non-empty name, this name will be used instead of the one of the decorated function. :param func_impl: the function that will be called when the generated function is executed. Its signature should be compliant with (=more generic than) `func_signature` :param inject_as_first_arg: if `True`, the created function will be injected as the first positional argument of `func_impl`. This can be handy in case the implementation is shared between several facades and needs to know from which context it was called. Default=`False` :param func_name: provide a non-`None` value to override the created function `__name__` and `__qualname__`. If this is `None` (default), the `__name__` will default to the one of `func_impl` if `func_signature` is a `Signature`, or to the name defined in `func_signature` if `func_signature` is a `str` and contains a non-empty name. :param add_source: a boolean indicating if a '__source__' annotation should be added to the generated function (default: True) :param add_impl: a boolean indicating if a '__func_impl__' annotation should be added to the generated function (default: True) :param doc: a string representing the docstring that will be used to set the __doc__ attribute on the generated function. If None (default), the doc of func_impl will be used. :param qualname: a string representing the qualified name to be used. If None (default), the `__qualname__` will default to the one of `func_impl` if `func_signature` is a `Signature`, or to the name defined in `func_signature` if `func_signature` is a `str` and contains a non-empty name. :param co_name: a string representing the name to be used in the compiled code of the function. If None (default), the `__code__.co_name` will default to the one of `func_impl` if `func_signature` is a `Signature`, or to the name defined in `func_signature` if `func_signature` is a `str` and contains a non-empty name. :param module_name: the name of the module to be set on the function (under __module__ ). If None (default), `func_impl.__module__` will be used. :param attrs: other keyword attributes that should be set on the function. Note that `func_impl.__dict__` is not automatically copied. :return: _with_sig_offsetTN__name__FzzlInvalid co_name %r for created function. It is not possible to declare a function with the provided co_name. __qualname____doc__ __module__rz%Invalid type for `func_signature`: %scSs$g|]\}}|rd||fn|qS)z%s=%sr)r kis_kwrrrr%s$z#create_function.., z%s, %sr r z&def %s yield from _func_impl_(%s) )%get_legacy_py_generator_body_templatezAasync def %s async for y in _func_impl_(%s): yield y z%lambda_ = lambda %s: _func_impl_(%s) z"lambda_ = lambda: _func_impl_(%s) z"def %s return _func_impl_(%s) zasync zreturn _func_impl_zreturn await _func_impl_ _func_impl_lambda_ __source__ __func_impl__)namer3r2 annotationsdefaultskwonlydefaultsmodulekw)$pop_get_callerframeKeyErrorextract_module_and_evaldictr@_is_valid_func_def_name_is_lambda_func_name ValueErrorr<r=strget_signature_from_stringr rget_lambda_argument_stringget_signature_string TypeErrortypeget_signature_paramslistkeysget_signature_detailsitemsjoin_is_generator_funcsys version_infomakefun._main_legacy_pyrSr"rreplaceprotect_eval_dict_make_update_fieldstuple)func_signature func_implr.r/r0r1r2r3r5r4r9frameevaldictruser_provided_nameuser_provided_co_nameuser_provided_qnamefunc_name_from_strfunc_signature_str create_lambdaname_lenparams_to_kw_assignment_mode params_namesrYrZr[ assignments params_strbodyrSrrrrcreate_functionvsR                         rcCs:dtjkr dkrnt|St|ot| St|S)zX Return True if the func_impl is a generator :param func_impl: :return: r r )rrrsr!r)r{rrrrqUsrqcCs|ddjjkS)z] Return True if func_name is the name of a lambda :param func_name: :return: cSsdSNrrrrrjz&_is_lambda_func_name..)__code__r5r.rrrrcdsrccCst|ot| S)zh Return True if func_name is valid in a function definition. :param func_name: :return: )rrrrrrrbmsrbc@s$eZdZdZdZddZddZdS) _SymbolRefaC A class used to protect signature default values and type hints when the local context would not be able to evaluate them properly when the new function is created. In this case we store them under a known name, we add that name to the locals(), and we use this symbol that has a repr() equal to the name. varnamecCs ||_dSrr)selfrrrr__init__~s z_SymbolRef.__init__cCs|jSrrrrrr__repr__sz_SymbolRef.__repr__N)rJrMrKrL __slots__rrrrrrrvs  rcCstjdk}g}d}|jD]D\}}t|j|}t|j|d||} |r-tj} | |j u} nt|j |} t|j | d||} |sA| rMt|j |j | | d}d}| |q|r^tj} | |j u} nt|j |} t|j | d|} |sp| rwt|| d}n|}d ||fS) z Returns the string to be used as signature. If there is a non-native symbol in the defaults, it is created as a variable in the evaldict :param func_name: :param func_signature: :return: rFz DEFAULT_%szHINT_%s)kinddefault annotationT RETURNHINT parametersreturn_annotationz%s%s:)rrrsrro"_signature_symbol_needs_protectionr_protect_signature_symbolremptyrrXrappendrr)r.rzr}no_type_hints_allowed new_paramsparams_changedp_namepdefault_needs_protection new_defaultnew_annotationannotation_needs_protectionnew_return_annotationreturn_needs_protectionrrrrrhs8        rhcCstd||ddS)z Returns the string to be used as arguments in a lambda function definition. If there is a non-native symbol in the defaults, it is created as a variable in the evaldict :param func_name: :param func_signature: :return: rGrN)rh)rzr}rrrrgsrgcCsL|dur$|tjur$t|tvr$z tt|||kWSty#YdSwdS)a Helper method for signature symbols (defaults, type hints) protection. Returns True if the given symbol needs to be protected - that is, if its repr() can not be correctly evaluated with current evaldict. :param symbol: :return: NTF)rrrjTYPES_WITH_SAFE_REPRevalrepr Exception)symbolr}rrrrs  rcCs|r |||<t|S|S)aJ Helper method for signature symbols (defaults, type hints) protection. Returns either `val`, or a protection symbol. In that case the protection symbol is created with name `varname` and inserted into `evaldict` :param val: :param needs_protection: :param varname: :param evaldict: :return: )r)rEneeds_protectionrr}rrrrs rc Cs|dr |dd}t|}|durtd|tjf|}|d}|dus-|dkr2d}d}n|}|d}|d }|dusFt|d krT|dusPt|d krT|d }|dur\||n|}d |} t|g| |} |t| |fS) z Creates a `Signature` object from the given function signature string. :param func_sig_str: :return: (func_name, func_sig, func_sig_str). func_sig_str is guaranteed to contain the ':' symbol already  rGNzThe provided function template is not valid: "%s" does not match "()[ -> ]". For information the regex used is: "%s"funcnamerdummycoloncomment_return_hintr:zdef %s pass ) startswithFUNC_DEFmatch SyntaxErrorpattern groupdictr rwr) func_sig_strr} def_matchgroupsr. func_name_ colon_endcmt_return_hint func_sig_str_rdummy_frrrrfs2    rfcCst}|jD]P\}}|jtjurd||<q|jtjur"d||<q|jtjur-d||<q|jtjurE| D]}d||<q7d|d|<q|jtj urRd|d|<qt d|j|S)z Utility method to return the parameter names in the provided `Signature` object, by group of kind :param s: :return: FT*z**zUnknown kind: %s) rrrorrPOSITIONAL_ONLY KEYWORD_ONLYPOSITIONAL_OR_KEYWORDVAR_POSITIONALrm VAR_KEYWORDrd)rparams_to_assignment_moderrrOrrrrkJs           rkcCst}g}t}|j|jur|j|d<|jD]'\}}|j|jur'|j||<|j|jur?|jtj ur:| |jq|j||<q|||fS)z Utility method to extract the annotations, defaults and kwdefaults from a `Signature` object :param s: :return: return) dictrrrrorrrrrr)rrYrZr[rrrrrrngs        rncCsRz|jdd}t|j}||jW||fSty(d}t}Y||fSw)z Utility function to extract the module name from the given frame, and to return a dictionary containing globals and locals merged together :param frame: :return: rJ?) f_globalsgetrupdatef_localsAttributeErrorr)r|r4r}rrrras  rac CsHz||=Wn tyYnw|D]}z||=Wqty!Yqw|S)z remove all symbols that could be harmful in evaldict :param evaldict: :param func_name: :param params_names: :return: )r`)r}r.rnrrrrvs    rvcCs|pi}|D]}|dvrtd||fq|dstddttf}z t||d}t||WntyHtdt j dt|t j dw||}|S) z Make a new function from a given template and update the signature :param func_name: :param params_names: :param body: :param evaldict: :param add_source: :return: )_func_rTz%s is overridden in %srzbody should end with a newlinezsinglezError in generated code:)file) NameErrorendswithrdnext_compile_countcompileexec BaseExceptionprintrrstderr)rrrr}rfilenamecoderArrrrws$    rwrc CsZ|durt}||_|dur||_||_||_||_t|dkr"d}||_||_||_ dS)z Update the signature of func with the provided information This method merely exists to remind which field have to be filled. :param func: :param name: :param qualname: :param kw: :return: Nr) rrJrKrLr; __defaults__r __kwdefaults____annotations__rM) rArXr3r2rYrZr[r\r]rrrrxs  rxcCs.z td|}W|Styd}Y|Sw)N)rr _getframer)rIr|rrrr_s r_c  KsLt||||||| | || | \}}} } }} }t|f|||| | | || d|S)a  A decorator to create a signature-preserving wrapper function. It is similar to `functools.wraps`, but - relies on a proper dynamically-generated function. Therefore as opposed to `functools.wraps`, - the wrapper body will not be executed if the arguments provided are not compliant with the signature - instead a `TypeError` will be raised before entering the wrapper body. - the arguments will always be received as keywords by the wrapper, when possible. See [documentation](./index.md#signature-preserving-function-wrappers) for details. - you can modify the signature of the resulting function, by providing a new one with `new_sig` or by providing a list of arguments to remove in `remove_args`, to prepend in `prepend_args`, or to append in `append_args`. See [documentation](./index.md#editing-a-signature) for details. Comparison with `@with_signature`:`@wraps(f)` is equivalent to `@with_signature(signature(f), func_name=f.__name__, doc=f.__doc__, module_name=f.__module__, qualname=f.__qualname__, __wrapped__=f, **f.__dict__, **attrs)` In other words, as opposed to `@with_signature`, the metadata (doc, module name, etc.) is provided by the wrapped `wrapped_fun`, so that the created function seems to be identical (except possibly for the signature). Note that all options in `with_signature` can still be overridden using parameters of `@wraps`. The additional `__wrapped__` attribute is set on the created function, to stay consistent with the `functools.wraps` behaviour. If the signature is modified through `new_sig`, `remove_args`, `append_args` or `prepend_args`, the additional `__signature__` attribute will be set so that `inspect.signature` and related functionality works as expected. See PEP 362 for more detail on `__wrapped__` and `__signature__`. See also [python documentation on @wraps](https://docs.python.org/3/library/functools.html#functools.wraps) :param wrapped_fun: the function that you intend to wrap with the decorated function. As in `functools.wraps`, `wrapped_fun` is used as the default reference for the exposed signature, `__name__`, `__qualname__`, `__doc__` and `__dict__`. :param new_sig: the new signature of the decorated function. By default it is `None` and means "same signature as in `wrapped_fun`" (similar behaviour as in `functools.wraps`). If you wish to modify the exposed signature you can either use `remove/prepend/append_args`, or pass a non-None `new_sig`. It can be either a string without 'def' such as "foo(a, b: int, *args, **kwargs)" of "(a, b: int)", or a `Signature` object, for example from the output of `inspect.signature` or from the `funcsigs.signature` backport. Note that these objects can be created manually too. If the signature is provided as a string and contains a non-empty name, this name will be used instead of the one of `wrapped_fun`. :param prepend_args: a string or list of strings to prepend to the signature of `wrapped_fun`. These extra arguments should not be passed to `wrapped_fun`, as it does not know them. This is typically used to easily create a wrapper with additional arguments, without having to manipulate the signature objects. :param append_args: a string or list of strings to append to the signature of `wrapped_fun`. These extra arguments should not be passed to `wrapped_fun`, as it does not know them. This is typically used to easily create a wrapper with additional arguments, without having to manipulate the signature objects. :param remove_args: a string or list of strings to remove from the signature of `wrapped_fun`. These arguments should be injected in the received `kwargs` before calling `wrapped_fun`, as it requires them. This is typically used to easily create a wrapper with less arguments, without having to manipulate the signature objects. :param func_name: provide a non-`None` value to override the created function `__name__` and `__qualname__`. If this is `None` (default), the `__name__` will default to the ones of `wrapped_fun` if `new_sig` is `None` or is a `Signature`, or to the name defined in `new_sig` if `new_sig` is a `str` and contains a non-empty name. :param inject_as_first_arg: if `True`, the created function will be injected as the first positional argument of the decorated function. This can be handy in case the implementation is shared between several facades and needs to know from which context it was called. Default=`False` :param add_source: a boolean indicating if a '__source__' annotation should be added to the generated function (default: True) :param add_impl: a boolean indicating if a '__func_impl__' annotation should be added to the generated function (default: True) :param doc: a string representing the docstring that will be used to set the __doc__ attribute on the generated function. If None (default), the doc of `wrapped_fun` will be used. If `wrapped_fun` is an instance of `functools.partial`, a special enhanced doc will be generated. :param qualname: a string representing the qualified name to be used. If None (default), the `__qualname__` will default to the one of `wrapped_fun`, or the one in `new_sig` if `new_sig` is provided as a string with a non-empty function name. :param co_name: a string representing the name to be used in the compiled code of the function. If None (default), the `__code__.co_name` will default to the one of `func_impl` if `func_signature` is a `Signature`, or to the name defined in `func_signature` if `func_signature` is a `str` and contains a non-empty name. :param module_name: the name of the module to be set on the function (under __module__ ). If None (default), the `__module__` attribute of `wrapped_fun` will be used. :param attrs: other keyword attributes that should be set on the function. Note that the full `__dict__` of `wrapped_fun` is automatically copied. :return: a decorator )r.r/r0r1r2r3r5r4)_get_args_for_wrappingwith_signature) wrapped_funr*r+r,r-r.r5r/r0r1r2r3r4r9func_sig all_attrsrrrr6s&br6c Csd} |dur|dus|dus|durtd|} d} n?t|} |r3t|tr)|f}t| g|R} d} |r>t|tr=|f}nd}|rKt|trJ|f}nd}|sQ|rZd} t| ||d} |durdt|dd}|durt|dd}t|tj r| s|t d d j krt|j } t t|j ddt|j dd| | |j }|durt|d d}| durt|d d} |durt|d d}|dur|j}tt|d}||d<| rt| tr| |d<ntdd}t|\}}t| |\}}}||d<|| || |||| |fS)a3 Internal method used by @wraps and create_wrapper :param wrapped: :param new_sig: :param remove_args: :param prepend_args: :param append_args: :param func_name: :param doc: :param qualname: :param co_name: :param module_name: :param attrs: :return: FNzJOnly one of `[remove/prepend/append]_args` or `new_sig` should be providedTr)firstlastrJrLcSr)NTrrrrrrrz(_get_args_for_wrapping..rKrMrr; __wrapped__ __signature__rGrH)rdrr= string_typesremove_signature_parametersadd_signature_parametersr@r<r>r?rLrAgen_partial_docargsr5rrr_rarfr)r7r*r-r+r,r.r2r3r5r4r9 has_new_sigrorig_sigrrr|r}r _func_namefunc_sig_as_sigrrrr}sp               rc s^durdursrstd fdd} | S f dd} | S)a A decorator for functions, to change their signature. The new signature should be compliant with the old one. ```python @with_signature() def impl(...): ... ``` is totally equivalent to `impl = create_function(, func_impl=impl)` except for one additional behaviour: - If `func_signature` is set to `None`, there is no `TypeError` as in create_function. Instead, this simply applies the new metadata (name, doc, module_name, attrs) to the decorated function without creating a wrapper. `add_source`, `add_impl` and `inject_as_first_arg` should not be set in this case. :param func_signature: the new signature of the decorated function. Either a string without 'def' such as "foo(a, b: int, *args, **kwargs)" of "(a, b: int)", or a `Signature` object, for example from the output of `inspect.signature` or from the `funcsigs.signature` backport. Note that these objects can be created manually too. If the signature is provided as a string and contains a non-empty name, this name will be used instead of the one of the decorated function. Finally `None` can be provided to indicate that user wants to only change the medatadata (func_name, doc, module_name, attrs) of the decorated function, without generating a new function. :param inject_as_first_arg: if `True`, the created function will be injected as the first positional argument of the decorated function. This can be handy in case the implementation is shared between several facades and needs to know from which context it was called. Default=`False` :param func_name: provide a non-`None` value to override the created function `__name__` and `__qualname__`. If this is `None` (default), the `__name__` will default to the ones of the decorated function if `func_signature` is a `Signature`, or to the name defined in `func_signature` if `func_signature` is a `str` and contains a non-empty name. :param add_source: a boolean indicating if a '__source__' annotation should be added to the generated function (default: True) :param add_impl: a boolean indicating if a '__func_impl__' annotation should be added to the generated function (default: True) :param doc: a string representing the docstring that will be used to set the __doc__ attribute on the generated function. If None (default), the doc of the decorated function will be used. :param qualname: a string representing the qualified name to be used. If None (default), the `__qualname__` will default to the one of `func_impl` if `func_signature` is a `Signature`, or to the name defined in `func_signature` if `func_signature` is a `str` and contains a non-empty name. :param co_name: a string representing the name to be used in the compiled code of the function. If None (default), the `__code__.co_name` will default to the one of `func_impl` if `func_signature` is a `Signature`, or to the name defined in `func_signature` if `func_signature` is a `str` and contains a non-empty name. :param module_name: the name of the module to be set on the function (under __module__ ). If None (default), the `__module__` attribute of the decorated function will be used. :param attrs: other keyword attributes that should be set on the function. Note that the full `__dict__` of the decorated function is not automatically copied. NzIf `func_signature=None` no new signature will be generated so only `func_name`, `module_name`, `doc` and `attrs` should be provided, to modify the metadata.csZdur|_dur|_dur|_dur|_D] \}}t|||q |Sr)rJrLrKrMrosetattr)rrOv)r9r2r.r4r3rr replace_fsz!with_signature..replace_fcs&td| dd S)NT) rzr{r.r/r0r1r2r3r5r4rFr)rr r1r0r9r5r2r.rzr/r4r3rrr%s )rd) rzr.r/r0r1r2r3r5r4r9rrrrrs9 rcGs.t|j}|D]}||=q |j|dS)z Removes the provided parameters from the signature `s` (returns a new `Signature` instance). :param s: :param param_names: a list of parameter names to remove :return: r)rrroruvalues)r param_namesparams param_namerrrr7s rc CsLt|j}t|}zt|D]}|j|vr td|j|||qWnt yC|j|vr;td|j|||Ynwd}zQt|D]J}t |t r|durnt j }z tt|j}Wn tymYnw|t jt jfvryt j}t ||d}n|j}|j|vrtd|j|d|qKWnt y|j|vrtd|j|d|Ynwd} zN|D]I}t |t r| durt j } z tt|j} Wn tyYnw| t jt jfvrt j} t || d}n|j} |j|vrtd|j||qWnt y|j|vrtd|j||Ynw|j|dS)a Adds the provided parameters to the signature `s` (returns a new `Signature` instance). :param s: the original signature to edit :param first: a single element or a list of `Parameter` instances to be added at the beginning of the parameter's list. Strings can also be provided, in which case the parameter kind will be created based on best guess. :param last: a single element or a list of `Parameter` instances to be added at the end of the parameter's list. Strings can also be provided, in which case the parameter kind will be created based on best guess. :param custom: a single element or a list of `Parameter` instances to be added at a custom position in the list. That position is determined with `custom_idx` :param custom_idx: the custom position to insert the `custom` parameters to. :return: a new signature created from the original one by adding the specified parameters. zDParameter with name '%s' is present twice in the signature to createN)rXrrr)rrrorlrreversedrXrdinsertrir=rrrriterr StopIterationrrrrrru) rrrcustom custom_idxr lstparamfirst_param_kindlast_param_kindrrrrFs|                 rcsfdd}|S)z Decorator to 'partialize' a function using `partial` :param preset_pos_args: :param preset_kwargs: :return: cst|gRiSr)r?r preset_kwargspreset_pos_argsrrapply_decoratorsz%with_partial..apply_decoratorr)rrrrrr with_partialsrc st}srt|}nd}trAtjdkr.ddlm}||gRi}n=ddlm}||gRi}n*t r]tjdkr]ddl m }||gRi}nt |dfd d }|durzt |j|j|||_|_|S) aK Equivalent of `functools.partial` but relies on a dynamically-created function. As a result the function looks nicer to users in terms of apparent documentation, name, etc. See [documentation](./index.md#removing-parameters-easily) for details. :param preset_pos_args: :param preset_kwargs: :return: NrRr)make_partial_using_yield_from)make_partial_using_yieldr)%make_partial_using_async_for_in_yield)r*cs |t|i|Sr)r itertoolschain)rkwargsrrrrr partial_fs zpartial..partial_f)rgen_partial_sigrqrrrsmakefun._main_py35_and_higherrrtrr"makefun._main_py36_and_higherrr6rrJrLrA) rrrrr*rr"rrrr!rr?s&     r?c@seZdZddZddZdS)KwOnlycCst|Sr)rrrrr__str__szKwOnly.__str__cCr)Nz KW_ONLY_ARG!rrrrrrr zKwOnly.__repr__N)rJrMrKr'rrrrrr&s r&c Cs~t|}t|jt|krtdt|t|d|t|jfg}d}t|jD]w\}\}}|t|kr7q*z||} Wn5tys|rq|j t j t j fvrqt ra|j } |jt jur^|jnt} nt j } |j} t |j| | |jd}Yn)w|j t jur~tdt s|j t j t j fvrt j } n|j } t |j| | |jd}d}||q*tt||jd} t|dkrtd t|d||f| S) a Returns the signature of partial(f, *preset_pos_args, **preset_kwargs) Raises explicit errors in case of non-matching argument names. By default the behaviour is the same as `functools.partial`: - partialized positional arguments disappear from the signature - partialized keyword arguments remain in the signature in the same order, but all keyword arguments after them in the parameters order become keyword-only (if python 2, they do not become keyword-only as this is not allowed in the compiler, but we pass them a bad default value "KEYWORD_ONLY") :param orig_sig: :param preset_pos_args: :param preset_kwargs: :param f: used in error messages only :return: z?Cannot preset %s positional args, function %s has only %s args.rJF)rXrrrzPredefining a positional-only argument using keyword is not supported as in python 3.8.8, 'signature()' does not support such functions and raises aValueError. Please report this issue if support needs to be added in the future.TrrzICannot preset keyword argument(s), not present in the signature of %s: %s)rr rrdr< enumerateror^r`rrrrPY2rrKW_ONLYrXrrNotImplementedErrorrrryr) rrrrr kwonly_flagirroverridden_p_defaultnew_kindrr*rrrr#sL     r#cCsg}d}t|jD]E\}\}} |t|kr!|t||q |j|} |s7tr/| jtus5| j t j kr7d}trI|rI|t |  dtdq |t | q d|} |dus`t|dkrhd|| f} | Sd || |f} | |} | S) a6 Generate a documentation indicating which positional arguments and keyword arguments are set in this partial implementation, and appending the wrapped function doc. :param wrapped_name: :param wrapped_doc: :param orig_sig: :param new_sig: :param preset_pos_args: :return: FTz=%srrQNrz+ zH )r(rror rrr)rr*rrrrerurp) wrapped_name wrapped_docrr*rall_strskw_onlyr-r_ppnew argstring partial_docnew_linerrrrZs*    rc@eZdZdZdS)UnsupportedForCompilationzQ Exception raised by @compile_fun when decorated target is not supported NrJrMrKrLrrrrr:r:c@r9)UndefinedSymbolErrorz\ Exception raised by @compile_fun when the function requires a name not yet defined Nr;rrrrr=r<r=c@r9)SourceUnavailablezx Exception raised by @compile_fun when the function source is not available (inspect.getsource raises an error) Nr;rrrrr>r<r>cs*tr }t|ddSfdd}|S)a A draft decorator to `compile` any existing function so that users cant debug through it. It can be handy to mask some code from your users for convenience (note that this does not provide any obfuscation, people can still reverse engineer your code easily. Actually the source code even gets copied in the function's `__source__` attribute for convenience): ```python from makefun import compile_fun @compile_fun def foo(a, b): return a + b assert foo(5, -5.0) == 0 print(foo.__source__) ``` yields ``` @compile_fun def foo(a, b): return a + b ``` If the function closure includes functions, they are recursively replaced with compiled versions too (only for this closure, this does not modify them otherwise). **IMPORTANT** this decorator is a "goodie" in early stage and has not been extensively tested. Feel free to contribute ! Note that according to [this post](https://stackoverflow.com/a/471227/7262247) compiling does not make the code run any faster. Known issues: `NameError` will appear if your function code depends on symbols that have not yet been defined. Make sure all symbols exist first ! See https://github.com/smarie/python-makefun/issues/47 :param recurse: a boolean (default `True`) indicating if referenced symbols should be compiled too :param except_names: an optional list of symbols to exclude from compilation when `recurse=True` :return: T) _evaldictcst|ddS)NTrecurse except_namesr?)compile_fun_manually)targetrBrArrapply_compile_funsz&compile_fun..apply_compile_fun)callablerC)rArBrDrFrrEr compile_funs - rHc Cst|ts td|dus|dur$|durtdd}nt}t|\}}zt|}WnttfyD}z dt|vr?t ||d}~wwz|j }|j } Wnt y\|j }|j} Ynw|r|durt| j|D]9\} } | |vrrqi| |vr|td| z| j} Wn tyYqiwz t| |||d|| <Wqitt fyYqiwt|}|} |d rd |dd}d |vrtd |d d kr|d 7}t|jd ||}| |_|S)z& :param target: :return: z0Only functions can be compiled by this decoratorNTrGrHzcould not get source codez|Symbol %s does not seem to be defined yet. Make sure you apply `compile_fun` *after* all required symbols have been defined.r@z @compile_funrzA@compile_fun seems to appear several times in the function sourcer r)r=rr:r_rarOSErrorIOErrorrer> __closure__rr func_closure func_codezip co_freevarsr= cell_contentsrdrCrrrp splitlinesrwrJrV)rDrArBr?r|rlineserLrMrXcellvalue source_linesnew_frrrrCsl              rC) NNNNNFTTNNNN)NFTTNNNNr)NNNrNNNr ) NNNNNNFTTNNN)rrrr )Tr)TrN)V __future__rr>rerrr collectionsrrinspectrkeywordrtextwraprtypesrrsre isidentifierrrrr ImportErrorfuncsigsrr!r"typingr#r$r%r&r'r(r)r)r basestringrrr:r@rrqrcrbrrhrgintbytesboolrrrrfrkrnrarvcountrrwrxr_r6rrrrrr?r&r*r#rrir:rr=rIr>rHrCrrrrs                (      `  6 U & " u\ _ k 3X- ;