|h} VUddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZddlmZej"eZgdZe j*dZe j.e j0e j2e j0e j4ee j.e j8j:e j2e j8j:ffe j<ege j0ffZe j.de j<e j@e j<fZ!e jDe j<Z#e j<de jHfZ%e j*d Z&e j*d e j< Z'e j*d e Z(e j*d e% Z)e j<de jTe jHfZ+dZ,dZ-de.d<ddZ/ddZ0ddZ1d dZ2d!dZ3ddd"dZ4d#dZ5Gdde jleZ7y)$) annotationsN)ValidationErrormissing)MultiDictProxy)rParserr parse_jsonRequest.TC)boundMultiDictProxyT ErrorHandlerT_defaultiintDEFAULT_VALIDATION_STATUSc\|yt|dsd|_|xj|fz c_y)N__webargs_argnames__)hasattrr)fargnames K/var/www/html/test/engine/venv/lib/python3.12/site-packages/webargs/core.py_record_arg_namer;s0 1, -!#wj(ct|SN)callable)xs r _iscallabler Cs A;rc<|rt|st|d|S)ziMakes sure an object is callable if it is not ``None``. If not callable, a ValueError is raised. z is not callable.)r ValueError)objs r_callable_or_raiser$Is& ;s#C7"3455 JrcF|jddjS)N;r)splitstrip) content_types r get_mimetyper*Rs!   c "1 % + + --rcz|syd|vr t|}|dk(ry|jdr|jdryy)zIndicates if this mimetype is JSON or not. By default a request is considered to include JSON data if the mimetype is ``application/json`` or ``application/*+json``. Fr&zapplication/jsonTz application/z+json)r* startswithendswith)mimetypes ris_jsonr/XsH  h)%%>*x/@/@/I rzutf-8)encodingct|tr|}n |j|}t j|S#t$rH}t j d|j t|j|j|d}~wwxYw)NzBytes decoding error : )docpos) isinstancestrdecodeUnicodeDecodeErrorjsonJSONDecodeErrorreasonobjectstartloads)sr0decodedexcs rr r hs!S hhx(G ::g  " &&)#**6 OII   s; B ABB c|rYt|ttfr%tjt t|}|St |r|g}|St|dg}|S)Nz( is not a callable or list of callables.)r4listtupletypingcast CallableListrr")r# validatorss r_ensure_list_of_callablesrHwsg cD%= )\49=J  c]J w&NOP P rc xeZdZUdZdZded<dddejejejejejdZded<ejZ d ed <e Z d ed <d Z ded<ejjejjgZded<dZded<dddddddddZded< dCeddd dDdZed  dEd!ZdFd"Z dGd#Z dGd$Z dHd%Z dHd&ZdId'ZdJd(Zddedf dKd)Z dLd*Z dCdedddd+ dMd,Z dCdedddd+ dMd-Z!dNd.Z" dOd/Z#e$ dPd0Z% dCded1ddddd2 dQd3Z& dCdedddd+ dRd4Z'dSd5Z(dTd6Z)dUd7Z* dVd8Z+ dWd9Z,dXd:Z-dXd;Z.dYd<Z/dXd=Z0dXd>Z1dXd?Z2dXd@Z3dXdAZ4 dZdBZ5y)[raBase parser class that provides high-level implementation for parsing a request. Descendant classes must provide lower-level implementations for reading data from different locations, e.g. ``load_json``, ``load_querystring``, etc. :param str location: Default location to use for data :param str unknown: A default value to pass for ``unknown`` when calling the schema's ``load`` method. Defaults to ``marshmallow.EXCLUDE`` for non-body locations and ``marshmallow.RAISE`` for request bodies. Pass ``None`` to use the schema's setting instead. :param callable error_handler: Custom error handler function. r8r5DEFAULT_LOCATIONN)r8form json_or_form querystringqueryheaderscookiesfileszdict[str, str | None]DEFAULT_UNKNOWN_BY_LOCATIONztype[ma.Schema]DEFAULT_SCHEMA_CLASSrrzInvalid value.DEFAULT_VALIDATION_MESSAGEz list[type]KNOWN_MULTI_FIELDSTboolUSE_ARGS_POSITIONAL load_jsonload_querystring load_form load_headers load_cookies load_filesload_json_or_form)r8rMrNrKrOrPrQrLz dict[str, str | typing.Callable]__location_map__)unknown error_handler schema_classc|xs |j|_t||_|xs |j|_||_yr)rJlocationr$error_callbackrSrbr`)selfrdr`rarbs r__init__zParser.__init__s=!9D$9$9 3Em3T(ED,E,E r)clsc>|||t|jS)zDCreate a multidict proxy object with options from the current parser)known_multi_fields)rCrU)rf multidictschemarhs r _makeproxyzParser._makeproxys9ft?V?V9WXXrct|jj}||vrtd||j|}t |t r t ||S|S)zuGet the loader function for the given location. :raises: ValueError if a given location is invalid. zInvalid location argument: )setr_keysr"r4r5getattr)rfrdvalid_locationsfuncs r _get_loaderzParser._get_loadersf d3388:; ? *:8*EF F$$X. dC 4& & rc6|j|}|||S)zReturn a dictionary-like object for the location on the given request. Needs to have the schema in hand in order to correctly handle loading lists from multidict objects and `many=True` schemas. )rt)rfrlreqrd loader_funcs r_load_location_datazParser._load_location_datas!&&x0 3''rcK|j|}|||}tj|r |d{S|S7wr)rtinspect isawaitable)rfrlrvrdrwdatas r_async_load_location_dataz Parser._async_load_location_datasD &&x0 3'   t $:  s5A>Acx||ji|_|jxs |j}||||||yNerror_status_code error_headers)messagesre handle_error)rferrorrvrlrdrrras r_on_validation_errorzParser._on_validation_errorsA#ENN3&*&9&9&NT=N=N    /'  rcK||ji|_|jxs |j}tj|r0t j t|}||||||d{y||||||y7wr)rrerasyncioiscoroutinefunctionrDrEAsyncErrorHandler) rfrrvrlrdrrraasync_error_handlers r_async_on_validation_errorz!Parser._async_on_validation_errors#ENN3++@t/@/@  & &} 5"(++.?"O %"3+    "3+   sA-B/B0BcX|D]%}||dus|j}t||y)NF)r|)rTr)rfr|rG validatormsgs r_validate_argumentszParser._validate_arguments5s7$ 6I%'55%c55 6rct|tjr|}|St|tr#t |tjr |}|St|t j jr@t|tr|}n t|}|jj|}|St|r ||}|Stdt|)abReturn a `marshmallow.Schema` for the given argmap and request. :param argmap: Either a `marshmallow.Schema`, `dict` of argname -> `marshmallow.fields.Field` pairs, or a callable that returns a `marshmallow.Schema` instance. :param req: The request object being parsed. :rtype: marshmallow.Schema zargmap was of unexpected type ) r4maSchematype issubclass collectionsabcMappingdictrb from_dictr TypeError)rfargmaprvrl argmap_dicts r _get_schemazParser._get_schema=s fbii ( &F  %*VRYY*GXF   7 7 8&$'$ "6l =T&&00=?F f C[F  `marshmallow.fields.Field` pairs, or a callable which accepts a request and returns a `marshmallow.Schema`. :param req: The request object to parse. :param str location: Where on the request to load values. Can be any of the values in :py:attr:`~__location_map__`. By default, that means one of ``('json', 'query', 'querystring', 'form', 'headers', 'cookies', 'files', 'json_or_form')``. :param str unknown: A value to pass for ``unknown`` when calling the schema's ``load`` method. Defaults to ``marshmallow.EXCLUDE`` for non-body locations and ``marshmallow.RAISE`` for request bodies. Pass ``None`` to use the schema's setting instead. :param callable validate: Validation function or list of validation functions that receives the dictionary of parsed arguments. Validator either returns a boolean or raises a :exc:`ValidationError`. :param int error_status_code: Status code passed to error handler functions when a `ValidationError` is raised. :param dict error_headers: Headers passed to error handler functions when a a `ValidationError` is raised. :return: A dictionary of parsed arguments rr4_on_validation_error hook did not raise an exceptionN)rrxrr exceptionsrrr" rfrrvrdr`rrrr|rGrlrrs rparsez Parser.parsesF372I2I C7H3 /c8Z  4435M..vsHgzD }},,   % %"3+ & F  s*A B&#B  Bc PK|j|||||\}}}} } |j| ||d{} |j| | |||| }|S7#tjj $r1} |j | || |||d{7td| d} ~ wwxYww)zCoroutine variant of `webargs.core.Parser.parse`. Receives the same arguments as `webargs.core.Parser.parse`. rNrr)rr}rrrrrr"rs r async_parsezParser.async_parses372I2I C7H3 /c8Z "&"@"@3#A#M..vsHgzD % }},, 11"3+ 2  F  sDB&AAAB&AB#2B B BB##B&cy)ziOptional override. Provides a hook for frameworks that use thread-local request objects. Nr)rfs rrzParser.get_default_requestsrcy)aOptional override. Returns the request object to be parsed, given a view function's args and kwargs. Used by the `use_args` and `use_kwargs` to get a request object from a view's arguments. :param callable view: The view function or method being decorated by `use_args` or `use_kwargs` :param tuple args: Positional arguments passed to ``view``. :param dict kwargs: Keyword arguments passed to ``view``. Nr)rfviewargskwargss rget_request_from_view_argsz!Parser.get_request_from_view_argss"rcZ|r|j|||fS|r |||<||fS||fz }||fS)z=Update args or kwargs with parsed_args depending on as_kwargs)update)rr parsed_args as_kwargsarg_names r_update_args_kwargszParser._update_args_kwargs sR  MM+ &V| #.x V|&V|rF)rdr`rrrrrc d xs j| ttjr;tts t j j  r tdjsjd  f d } | S)aDecorator that injects parsed arguments into a view function or method. Example usage with Flask: :: @app.route("/echo", methods=["get", "post"]) @parser.use_args({"name": fields.Str()}, location="querystring") def greet(querystring_args): return "Hello " + querystring_args["name"] :param argmap: Either a `marshmallow.Schema`, a `dict` of argname -> `marshmallow.fields.Field` pairs, or a callable which accepts a request and returns a `marshmallow.Schema`. :param str location: Where on the request to load values. :param str unknown: A value to pass for ``unknown`` when calling the schema's ``load`` method. :param bool as_kwargs: Whether to insert arguments as keyword arguments. :param str arg_name: Keyword argument name to use for arguments. Mutually exclusive with as_kwargs. :param callable validate: Validation function that receives the dictionary of parsed arguments. If the function returns ``False``, the parser will raise a :exc:`ValidationError`. :param int error_status_code: Status code passed to error handler functions when a `ValidationError` is raised. :param dict error_headers: Headers passed to error handler functions when a a `ValidationError` is raised. z-arg_name and as_kwargs are mutually exclusivec V  "s tdd}|vrtddtjr/t j  d  f d }n(t j d  f d }|_t||S)NrrzAttempted to pass `arg_name='z'` via use_args() but that name was already used. If this came from stacked webargs decorators, try setting `arg_name` to distinguish usages.c  K }|s j ||} j| d{} j|||\}} |i|d{S7,7wN)rvrdr`rrr)rrrrrreq_objrrrrrrrsrdreq_rfr`rs rwrapperz3Parser.use_args..decorator..wrapperes#G""&"A"A$f"U(,(8(8#!) '!)*;&3)9)#K$(#;#;fk9h$LD&"&t!6v!666#7s!3A'A#'A'A%A'%A'c  }|s j ||} j| } j|||\}} |i|Sr)rrrrs rrz3Parser.use_args..decorator..wrapper~sz"G""&"A"A$f"U"&**#!) '!)*;&3#-#K$(#;#;fk9h$LD& 000r)r typing.Anyrrreturnr)rqr"rr functoolswraps __wrapped__r)rsexisting_arg_namesrrrrrrrrd request_objrfr`rs` @r decoratorz"Parser.use_args..decoratorUsD#I%,T3I2%N"11$7zBTT **40&7%71;777'70&11'1(#'G  Wh /Nr)rstyping.Callablerr) rdr4rDrrrbrr"rWget_default_arg_name) rfrrvrdr`rrrrrrrs `` ``````` @ruse_argszParser.use_argssN,t}}  ffnn -fd+f8T&&008:F  ILM M  D$<$<006BH@ @ Drc 4|j||d|||||S)aDecorator that injects parsed arguments into a view function or method as keyword arguments. This is a shortcut to :meth:`use_args` with ``as_kwargs=True``. Example usage with Flask: :: @app.route("/echo", methods=["get", "post"]) @parser.use_kwargs({"name": fields.Str()}) def greet(name): return "Hello " + name Receives the same ``args`` and ``kwargs`` as :meth:`use_args`. T)rvrrdr`rrr)r)rfrrvrdr`rrrs r use_kwargszParser.use_kwargss22}} /'  rc |dS)aThis method provides the rule by which an argument name is derived for :meth:`use_args` if no explicit ``arg_name`` is provided. By default, the format used is ``{location}_args``. Users may override this method to customize the default argument naming scheme. ``schema`` will be the argument map or schema passed to :meth:`use_args` unless a dict was used, in which case it will be the schema derived from that dict. _argsr)rfrdrls rrzParser.get_default_arg_names5!!rcdfd }|S)aDecorator that registers a function for loading a request location. The wrapped function receives a schema and a request. The schema will usually not be relevant, but it's important in some cases -- most notably in order to correctly load multidict values into list fields. Without the schema, there would be no way to know whether to simply `.get()` or `.getall()` from a multidict for a given value. Example: :: from webargs import core parser = core.Parser() @parser.location_loader("name") def load_data(request, schema): return request.data :param str name: The name of the location to register. c&|j<|Sr)r_)rsnamerfs rrz)Parser.location_loader..decorators*.D ! !$ 'Kr)rsr rr r)rfrrs`` rlocation_loaderzParser.location_loaders. rc||_|S)aDecorator that registers a custom error handling function. The function should receive the raised error, request object, `marshmallow.Schema` instance used to parse the request, error status code, and headers to use for the error response. Overrides the parser's ``handle_error`` method. Example: :: from webargs import flaskparser parser = flaskparser.FlaskParser() class CustomError(Exception): pass @parser.error_handler def handle_error(error, req, schema, *, error_status_code, error_headers): raise CustomError(error.messages) :param callable func: The error callback to register. )re)rfrss rrazParser.error_handlers0# rc|S)zA method of the parser which can transform data after location loading is done. By default it does nothing, but users can subclass parsers and override this method. r)rfrrlrvrds rrzParser.pre_loads rc|)aInternal hook for overriding treatment of JSONDecodeErrors. Invoked by default `load_json` implementation. External parsers can just implement their own behavior for load_json , so this is not part of the public parser API. r)rfrrvrrs r_handle_invalid_json_errorz!Parser._handle_invalid_json_errors  rc |j|S#tj$r6}|jdk(r tcYd}~S|j ||cYd}~Sd}~wt $r}|j ||cYd}~Sd}~wwxYw)z^Load JSON from a request object or return `missing` if no value can be found. N)_raw_load_jsonr8r9r2rrr7)rfrvrlr@s rrXzParser.load_jsonsm =&&s+ +## =ww"}223< <! =223< < =s7A?AA?AA? A?#A:4A?:A?c^|j||}|tur|S|j||S)zLoad data from a request, accepting either JSON or form-encoded data. The data will first be loaded as JSON, and, if that fails, it will be loaded as a form post. )rXrrZ)rfrvrlr|s rr^zParser.load_json_or_form1s2~~c6* w K~~c6**rctS)aInternal hook method for implementing load_json() Get a request body for feeding in to `load_json`, and parse it either using core.parse_json() or similar utilities which raise JSONDecodeErrors. Ensure consistent behavior when encountering decoding errors. The default implementation here simply returns `missing`, and the default implementation of `load_json` above will pass that value through. However, by implementing a "mostly concrete" version of load_json with this as a hook for getting data, we consolidate the logic for handling those JSONDecodeErrors. r)rfrvs rrzParser._raw_load_json?s rctS)zhLoad the query string of a request object or return `missing` if no value can be found. rrfrvrls rrYzParser.load_querystringO rctS)zeLoad the form data of a request object or return `missing` if no value can be found. rrs rrZzParser.load_formUrrctS)z>Load the headers or return `missing` if no value can be found.rrs rr[zParser.load_headers[srctS)z`Load the cookies from the request or return `missing` if no value can be found. rrs rr\zParser.load_cookies_rrctS)z[Load files from the request or return `missing` if no values can be found. rrs rr]zParser.load_fileserrc0tj||)zjCalled if an error occurs while parsing args. By default, just logs and raises ``error``. )loggerr)rfrrvrlrrs rrzParser.handle_errorks  U rr) rd str | Noner`rrazErrorHandler | Nonerbztype[ma.Schema] | NonerNone)rkrrl ma.Schemarhz,type[MultiDictProxyT] | type[MultiDictProxy]rz MultiDictProxyT | MultiDictProxy)rdr5rr)rlrrvr rdr5rr)rrrvr rlrrdr5r int | Nonertyping.Mapping[str, str] | Nonertyping.NoReturn)r|rrGrFrr)rArgMaprvr rr) rrrvRequest | Nonerdrr`rr ValidateArgrz2tuple[None, Request, str, CallableList, ma.Schema])rrrlrrvr rdr5r`rrGrFrr)rrrvrrdrr`rrrrrrrrr)rr)rrrrCrztyping.Mapping[str, typing.Any]rr) rrCrdict[str, typing.Any]rrrrVrrrz#tuple[tuple, dict[str, typing.Any]])rrrvrrdrr`rrrVrrrrrrrrr%typing.Callable[..., typing.Callable])rrrvrrdrr`rrrrrrrrr)rdr5rlrrr5)rr5rztyping.Callable[[C], C])rsrrr) rtyping.Mappingrlrrvr rdr5rr) rz)json.JSONDecodeError | UnicodeDecodeErrorrvr rrrrrr)rvr rlrrr)rvr rr) rrrvr rlrrrrrrr)6__name__ __module__ __qualname____doc__rJ__annotations__rEXCLUDErRrrSrrTfieldsListTuplerUrWr_rrgrrmrtrxr}rrrrrrrrrr staticmethodrrrrrrarrrXr^rrYrZr[r\r]rrrrrrs  #c"zz:::: :!6 -/II/5%>s>&66&(iinnbiioo%F F!%$)#!!+ :6  $ 5-1/3    +  -   $=K YYY : Y * Y (" ()0 (z typing.AnyStrr0r5rr)r#rrrF)8 __future__rrcollections.abcrrrzr8loggingrD marshmallowrrmarshmallow.utilsrwebargs.multidictproxyr getLoggerrr__all__TypeVarr UnionrTyperr5rFieldCallablerIterablerrrFNoReturn ErrorHandlerr r rr Awaitablerrrrrr r$r*r/r rHGenericrrrrrs"  '%1   8 $  &.. # II KK  NN3 RYY__fkk"))//6R%RSST OOWIryy()+ ll4&//&//2RRS {{6??+ sFOO34 FNN3FNN3foo. &..!2.IlC OOC)9)9&//)J$JK $!$3$) .  5<  t V^^G $t r