o  j\@sdZddlZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd lm Z dd lm Z dd l mZmZmZdd lmZmZmZddlmZddZddZddZddZddZddZddZddZdS)aThe ``spyne.decorator`` module contains the the @srpc decorator and its helper methods. The @srpc decorator is responsible for tagging methods as remote procedure calls extracting method's input and output types. It's possible to create custom decorators that wrap the @srpc decorator in order to have a more elegant way of passing frequently-used parameter values. The @rpc decorator is a simple example of this. N)copy)isclass)MethodDescriptor) LogicError)BODY_STYLE_EMPTY)BODY_STYLE_WRAPPED)BODY_STYLE_BARE)BODY_STYLE_OUT_BARE)BODY_STYLE_EMPTY_OUT_BARE) ModelBase ComplexModelComplexModelBase)TypeInforecust_selfref SelfReference)add_request_suffixc  CsHd} |dur | d7} |dur| d7} |durVz|jj} |jj| | }Wn ty/tdw|dur?|g|}d|}t|t|krUtd|jt|t|fnt |}t|t|krptd|jt|t|ft } ddl m } t ||D]0\}}zt|| }Wn tyd}Ynw|r|durtd t||}|||}|| |<q~t jjj}|d r|ddd \}}}d}|d krt| dkrtd t| dkrtj||| d}n4| \}|j||d}t|tr|jstd|jtjur |||d|n tj||| d}||_ | r"|j| d}|S)NrFzIt's not possible to instrospect builtins. You must pass a sequence of argument names as the '_args' argument to the rpc decorator to manually denote the arguments that this function accepts.)selfz8%r function has %d argument(s) but its decorator has %d.z=%r function has %d argument(s) but the _args argument has %d.r#SelfReference can't be used in @rpc{}barez;body_style='bare' can handle at most one function argument. type_name namespacememberssub_namesub_nsz5body_style='bare' does not allow empty model as paramz%s_arg0wsdl_part_name)!__code__ co_argcount co_varnamesAttributeError TypeErrornovalidate_freqlenr__name__rrspynerzip issubclassrgetconstxml DEFAULT_NS startswith partitionr producevalues customizer _type_info __type_name__r Empty_fill_empty_type_name __namespace__)fparamsin_message_namein_variable_namesno_ctxno_selfargnamesbody_style_str self_ref_clsin_wsdl_part_name arg_startargcount in_paramsrkv is_self_refns_messagerNO/var/www/html/LicenciasMiG/venv/lib/python3.10/site-packages/spyne/decorator.py_produce_input_message3s             rPcCs~|dd}|dd}d}|durd}n"||vr td|f|dkr'd}n|dkr.d}n |dur3ntd |dvs=J|S) N _body_style_soap_body_style)wrappedrout_barerSzbody_style must be one of %rdocumentrpcrz2soap_body_style must be one of ('rpc', 'document'))pop ValueError)kparamsrQrRallowed_body_stylesrNrNrO_validate_body_styles$   r[cs|dd}zt|t}Wn tyd}Ynw|r(|dur#tdt||}d|v}|ddtjjf}|durJ|dksB|rJd| |f}|d d} t } |r|dkrt |t t frfd d tt|D} |d | } t|t| ks}Jt| |} t | } n|d dtjjf}|| |<tjjj}|dr|ddd}|d}|d}|dr|dur|j||d}|jtjur||_ntj||| d}d|j_||_| r|j| d}|S)zxGenerate an output message for "rpc"-style API methods. This message is a wrapper to the declared return type. _returnsNFr_out_message_namez%s%srS%s.%s_wsdl_part_namecsg|] }dtjj|fqS)z%s%s%d)r*r. RESULT_SUFFIX).0i func_namerNrO sz+_produce_output_message.._out_variable_names_out_variable_namerrrrrrrTr ) rWr,rr&rrr*r.RESPONSE_SUFFIX get_type_namer isinstancelisttupleranger(r+r`r/r0r1r2endswithr5r7r r8r r3 Attributes_wrapperr:)rdrBrCr@rYr\rJ_is_out_message_name_overriddenr]_out_wsdl_part_name out_params default_namesrfvar_pairrgrK_out_message_name_partsrMrNrcrO_produce_output_messagesl                rxcCsddlm}t|D]\}}t|r%t||r%|rtdt||||<q |||<q |D]\}}t|rIt||rI|rAtdt||||<q.|||<q.dS)Nrrr) spyne.modelr enumeraterr,rritems)r<rYself_ref_replacement_no_selfrrbrIrHrNrNrO_substitute_self_references   r~cCs|dd}|dd}|dur|durtd|dur|g}|dd}|dd}|dur7|dur7td|dur>|g}|durJ|durJtd|durP|}|durV|SgS)N_evmgr_evmgrsz*Pass one of _evmgr or _evmgrs but not both_event_manager_event_managersz:Pass one of _event_manager or _event_managers but not bothzKYou must pass at most one of _evmgr* arguments or _event_manager* arguments)rWr)rYrrrrrNrNrO_get_event_managerss"    rcstfdd}|S)aMethod decorator to tag a method as a remote procedure call in a :class:`spyne.service.Service` subclass. You should use the :class:`spyne.server.null.NullServer` transport if you want to call the methods directly. You can also use the 'function' attribute of the returned object to call the function itself. ``_operation_name`` vs ``_in_message_name``: Soap clients(SoapUI, Savon, suds) will use the operation name as the function name. The name of the input message(_in_message_name) is irrelevant when interfacing in this manner; this is because the clients mostly wrap around it. However, the soap xml request only uses the input message when posting with the soap server; the other protocols only use the input message as well. ``_operation_name`` cannot be used with ``_in_message_name``. :param _returns: Denotes The return type of the function. It can be a type or a sequence of types for functions that have multiple return values. :param _in_header: A type or an iterable of types that that this method accepts as incoming header. :param _out_header: A type or an iterable of types that that this method sends as outgoing header. :param _operation_name: The function's soap operation name. The operation and SoapAction names will be equal to the value of ``_operation_name``. Default is the function name. :param _in_message_name: The public name of the function's input message. Default is: ``_operation_name + REQUEST_SUFFIX``. :param _out_message_name: The public name of the function's output message. Default is: ``_operation_name + RESPONSE_SUFFIX``. :param _in_arg_names: The public names of the function arguments. It's a dict that maps argument names in the code to public ones. :param _in_variable_names: **DEPRECATED** Same as _in_arg_names, kept for backwards compatibility. :param _out_variable_name: The public name of the function response object. It's a string. Ignored when ``_body_style != 'wrapped'`` or ``_returns`` is a sequence. :param _out_variable_names: The public name of the function response object. It's a sequence of strings. Ignored when ``_body_style != 'wrapped'`` or or ``_returns`` is not a sequence. Must be the same length as ``_returns``. :param _body_style: One of ``('bare', 'wrapped')``. Default: ``'wrapped'``. In wrapped mode, wraps response objects in an additional class. :param _soap_body_style: One of ('rpc', 'document'). Default ``'document'``. ``_soap_body_style='document'`` is an alias for ``_body_style='wrapped'``. ``_soap_body_style='rpc'`` is an alias for ``_body_style='bare'``. :param _port_type: Soap port type string. :param _no_ctx: Don't pass implicit ctx object to the user method. :param _no_self: This method does not get an implicit 'self' argument (before any other argument, including ctx). :param _udd: Short for User Defined Data, you can use this to mark the method with arbitrary metadata. :param _udp: **DEPRECATED** synonym of ``_udd``. :param _aux: The auxiliary backend to run this method. ``None`` if primary. :param _throws: A sequence of exceptions that this function can throw. This has no real functionality besides publishing this information in interface documents. :param _args: the name of the arguments to expose. :param _event_managers: An iterable of :class:`spyne.EventManager` instances. This is useful for adding additional event handlers to individual functions. :param _event_manager: An instance of :class:`spyne.EventManager` class. :param _logged: May be the string '...' to denote that the rpc arguments will not be logged. :param _evmgrs: Same as ``_event_managers``. :param _evmgr: Same as ``_event_manager``. :param _service_class: A :class:`Service` subclass. It's generally not a good idea to override it for ``@rpc`` methods. It could be necessary to override it for ``@mrpc`` methods to add events and other goodies. :param _service: Same as ``_service``. :param _wsdl_part_name: Overrides the part name attribute within wsdl input/output messages eg "parameters" cs"fdd}j|_d|_|S)Nc) s|d}|dd}d}dd}dd}dd}dd}dd}d d} d d} d d} d d} d g} dd}dd}dd}dd}dd}dd}dd}dvr~dvr~tddvrd}dvrd}dd}t}|dd}dd}t||d}dvrdvrtddvrňd}n dvrΈd}dv}d|}|dur|rd ||f}d!|}||kr||krtd"||krt|}d#vrd$vrtd%d#vrd#}n d$vr%d$}ni}d&vr5d'vr5td(d&vr@d&}n d'vrKd'}ni}d)d}t}t } | d*ri| d+krgt }nt }t ||| ||| || }!t|| ||}"|dkr||!j_||"j_td,}#| dur| gkrtd-| dur| g} | d*rd.d/lm}$|!}%|"}&t|%|$rt|%jd.krt|&|$rt|&jd.krt}nt}|dust|tsJt|!|"|#fid0|d1|d2|d3|d4|d5|d6|d7| d8| d9|d:|d;| d<| d=|d>|d?|d@|dA|dB|dC|dD|dE|dF|dG|dH|dI|}'| durN|rN| D]}(|(|'qEtd.krZtdJ|'S)KN_default_function_name_service_class _is_callbackF _is_async_mtom _in_header _out_header _port_type_no_ctx_aux_pattern _patterns_args _translations_when _static_when_href_loggedT_internal_key_suffix_servicez7Please pass only one of '_service' and '_service_class'r}_self_ref_replacement_default_on_null_faults_throwszOonly one of '_throws ' or '_faults' argumentsmust be given -- they're synonyms._in_message_namer^_operation_namezNonly one of '_operation_name' and '_in_message_name' arguments should be given _in_arg_names_in_variable_namesz=Use either '_in_arg_names' or '_in_variable_names', not both._udd_udpz&Use either '_udd' or '_udp', not both.r_rrT__doc__z@only one of '_pattern' and '_patterns' arguments should be givenr)r is_callbackis_asyncmtom in_header out_headerfaults parent_class port_typer?udd class_keyauxpatterns body_styleargsoperation_namer@ translationswhen static_when service_classhrefinternal_key_suffixdefault_on_nullevent_managersloggedzUnknown kwarg(s) %r passed.)rWrrr~rXrjrr-rr[ror rrPrxrprgetattrryr r,r(r6r rrkrmrhello))kwargs function_namerrrrrrrrrrrrrrrrrrrr}rrr_is_in_message_name_overriddenrrrrr_rrB in_message out_messagedocr titoretvalp)r;rYr<rNrOexplain_method{sD                                                       z,rpc..explain..explain_methodT)r_is_rpc)r;rrYr<)r;rOexplainzs *zrpc..explain)rl)r<rYrrNrrOrV-sK0rVcOd|d<t|i|S)aMethod decorator to tag a method as a remote procedure call. See :func:`spyne.decorator.rpc` for detailed information. The initial "s" stands for "static". In Spyne terms, that means no implicit first argument is passed to the user callable, which really means the method is "stateless" rather than static. It's meant to be used for existing functions that can't be changed. TrrVr<rYrNrNrOsrpc,s rcOr)NFr}rrrNrNrOmrpc:sr)rspyne.const.xmlr*rinspectrrrrrrr r ryr r r spyne.model.complexrrr spyne.constrrPr[rxr~rrVrrrNrNrNrOs0          `L