+hoddlmZddlmZmZddlmZmZmZddlm Z ddlm Z ddl mZddlmZddlmZdd lmZmZmZmZmZdd lmZdd lmZmZmZdd l m!Z!dd l"Z"ddl#m$Z$dd l%Z% ddl&m'Z'dZ*dZ+dZ dZ,dZ-de!fgZ.Gdde/Z0GddeZ1ddZ2Gdde/Z3Gdde/Z4y #e($r ddl)m'Z'YPwxYw) )absolute_import)wrapspartial)requesturl_for current_app)abort) make_response) MethodView)got_request_exception)Headers) HTTPExceptionMethodNotAllowedNotFound NotAcceptableInternalServerError)Response)http_status_messageunpack OrderedDict) output_jsonN) MethodType)MappingPROPAGATE_EXCEPTIONS)ApiResourcemarshal marshal_withmarshal_with_fieldr c d t|y#t$r}t|r||_d}~wwxYw)zRaise a HTTPException for the given http_status_code. Attach any keyword arguments to the exception for later processing. N)original_flask_abortrlendata)http_status_codekwargses I/var/www/html/venv/lib/python3.12/site-packages/flask_restful/__init__.pyr r s1 -.  v;AF s  /*/c~|jjtd}||jxs |jS|S)uIHandle Flask's propagate_exceptions. If propagate_exceptions is set to True then the exceptions are re-raised rather than being handled by the app’s error handlers. The default value for Flask's app.config['PROPAGATE_EXCEPTIONS'] is None. In this case return a sensible value: self.testing or self.debug. F)configget_PROPAGATE_EXCEPTIONStestingdebug)apppropagate_exceptionss r'_get_propagate_exceptions_boolr0's9::>>*?G#{{'cii' c~t|}t|ts"|rtj\}}}||ur|yyN)r0 isinstancersysexc_info)r.r&r/exc_type exc_valuetbs r')_handle_flask_propagate_exceptions_configr:6sD9#> a ',@"%,,.)R > G -A 'r1application/jsonceZdZdZ ddZdZdZeddZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZy)ra The main entry point for the application. You need to initialize it with a Flask Application: :: >>> app = Flask(__name__) >>> api = restful.Api(app) Alternatively, you can use :meth:`init_app` to set the Flask application after it has been constructed. :param app: the Flask application object :type app: flask.Flask or flask.Blueprint :param prefix: Prefix all routes with a value, eg v1 or 2010-04-01 :type prefix: str :param default_mediatype: The default media type to return :type default_mediatype: str :param decorators: Decorators to attach to every resource :type decorators: list :param catch_all_404s: Use :meth:`handle_error` to handle 404 errors throughout your app :param serve_challenge_on_401: Whether to serve a challenge response to clients on receiving 401. This usually leads to a username/password popup in web browsers. :param url_part_order: A string that controls the order that the pieces of the url are concatenated when the full url is constructed. 'b' is the blueprint (or blueprint registration) prefix, 'a' is the api prefix, and 'e' is the path component the endpoint is added with :type catch_all_404s: bool :param errors: A dictionary to define a custom response for each exception or error raised during a request :type errors: dict Nc 8tt|_i|_||_||_|r|ng|_||_||_||_ |xsi|_ d|_ t|_ g|_d|_d|_|||_|j#|yyr3)rDEFAULT_REPRESENTATIONSrepresentationsurlsprefixdefault_mediatype decoratorscatch_all_404sserve_challenge_on_401url_part_ordererrorsblueprint_setupset endpoints resourcesr. blueprintinit_app) selfr.rArBrCrDrErFrGs r'__init__z Api.__init__fs ++BC  !2(2*,&<#,l # ?DH MM#  r1c |j|j||_y#t$r|j |YywxYw)aiInitialize this class with the given :class:`flask.Flask` application or :class:`flask.Blueprint` object. :param app: the Flask application or blueprint object :type app: flask.Flask :type app: flask.Blueprint Examples:: api = Api() api.add_resource(...) api.init_app(app) N)record_deferred_blueprint_initrLAttributeError _init_app)rNr.s r'rMz Api.init_app}s?  ! JJt44 5 !DN NN3  s%AAcl||j|ddjfd|jDS)aiThis method is used to defer the construction of the final url in the case that the Api is created with a Blueprint. :param url_part: The part of the url the endpoint is registered with :param registration_prefix: The part of the url contributed by the blueprint. Generally speaking, BlueprintSetupState.url_prefix )bar&c34K|]}|s |ywr3).0keypartss r' z$Api._complete_url..sOcE#JuSzOs  )rAjoinrF)rNurl_partregistration_prefixr]s @r' _complete_urlzApi._complete_urls6%  wwOT-@-@OOOr1c t|r||j}n|jr|j|z}|jd|j| |j}|j }d|vrt |fi|jd}|jj||jjd||fd|i|y)awMethod used to patch BlueprintSetupState.add_url_rule for setup state instance corresponding to this Api instance. Exists primarily to enable _complete_url's function. :param blueprint_setup: The BlueprintSetupState instance (self) :param rule: A string or callable that takes a string and returns a string(_complete_url) that is the url rule for the endpoint being registered :param endpoint: See BlueprintSetupState.add_url_rule :param view_func: See BlueprintSetupState.add_url_rule :param **options: See BlueprintSetupState.add_url_rule subdomainNdefaults.) callable url_prefix setdefaultrd__name__ url_defaultsdictpopr. add_url_rulerLname)rHruleendpoint view_funcoptionsres r'#_blueprint_setup_add_url_rule_patchz'Api._blueprint_setup_add_url_rule_patchs D>223D  ' '"--4D;(A(AB   ))H"//  H@ J(?@H(((/:S:S:X:XZb/c)2 R=E RIP Rr1c||_|jjdk7r0|j|_t t j ||_|js td|j|jy)aSynchronize prefix between blueprint/api and registration options, then perform initialization with setup_state.app :class:`flask.Flask` object. When a :class:`flask_restful.Api` object is initialized with a blueprint, this method is recorded on the blueprint to be run when the blueprint is later registered to a :class:`flask.Flask` object. This method also monkeypatches BlueprintSetupState.add_url_rule with _blueprint_setup_add_url_rule_patch. :param setup_state: The setup state object passed to deferred functions during blueprint registration :type setup_state: flask.blueprints.BlueprintSetupState rtz5flask-restful blueprints can only be registered once.N) rHrnrj_original_add_url_rulerrrtfirst_registration ValueErrorrTr.)rN setup_states r'rRzApi._deferred_blueprint_initsl +  # # , ,0U U1<1I1IK .'1#2Y2Y2=(?K $--TU U {'r1c"t|j|j|_t|j|j|_t |j dkDr-|j D]\}}}|j ||g|i|yy)zPerform initialization actions with the given :class:`flask.Flask` object. :param app: The flask application object :type app: flask.Flask rN)r error_routerhandle_exceptionhandle_user_exceptionr"rK_register_view)rNr.resourcer@r%s r'rTz Api._init_apps 't'8'8#:N:NO$+D,=,=s?X?X$Y! t~~  "*... D&$###CCDCFC D #r1c|jrS|j|jjr-|j|jjdzdd}ny||jvS)zTests if an endpoint name (not path) belongs to this Api. Takes in to account the Blueprint name part of the endpoint name. :param endpoint: The name of the endpoint being checked :return: bool rfF)rL startswithrosplitrJ)rNrqs r' owns_endpointzApi.owns_endpointsY >>""4>>#6#67#>>$..*=*=*CQGK4>>))r1c4tjt} |jy#t$rJ}|j d}|j|d\}}|j |jcYd}~Sd}~wt$r|jcYSYyxYw)a- Determine if error should be handled with FR or default Flask The goal is to return Flask error handlers for non-FR-related routes, and FR errors (with the correct media type) for FR endpoints. This method currently handles 404 and 405 errors. :return: bool rT)method return_ruleN) rcreate_url_adapterrmatchr valid_methodsrrqrrD)rNadapterr&valid_route_methodrp_s r'_should_use_fr_error_handlerz Api._should_use_fr_error_handlers009  MMO 5!"!3 mm+=4mPGD!%%dmm4 4 '&& &  s , B?A:4B:BBc|jrytjsy|jtjjS)zGEncapsulating the rules for whether the request was to a Flask endpointTF)rrurl_rulerrqrNs r' _has_fr_routezApi._has_fr_route s<  , , .!!'"2"2";";<z'Api.mediatypes_method..ysDOO$59O9O8P$Pr1rZrs`r'mediatypes_methodzApi.mediatypes_methodvs QPr1c|j"|j|j|g|i|y|jj|||fy)aAdds a resource to the api. :param resource: the class name of your resource :type resource: :class:`Type[Resource]` :param urls: one or more url routes to match for the resource, standard flask routing rules apply. Any url variables will be passed to the resource method as args. :type urls: str :param endpoint: endpoint name (defaults to :meth:`Resource.__name__.lower` Can be used to reference this route in :class:`fields.Url` fields :type endpoint: str :param resource_class_args: args to be forwarded to the constructor of the resource. :type resource_class_args: tuple :param resource_class_kwargs: kwargs to be forwarded to the constructor of the resource. :type resource_class_kwargs: dict Additional keyword arguments not specified above will be passed as-is to :meth:`flask.Flask.add_url_rule`. Examples:: api.add_resource(HelloWorld, '/', '/hello') api.add_resource(Foo, '/foo', endpoint="foo") api.add_resource(FooSpecial, '/special/foo', endpoint="foo") N)r.r~rKappend)rNrr@r%s r' add_resourcezApi.add_resource{sHB 88  D  ( DT DV D NN ! !8T6": ;r1cfd}|S)aWraps a :class:`~flask_restful.Resource` class, adding it to the api. Parameters are the same as :meth:`~flask_restful.Api.add_resource`. Example:: app = Flask(__name__) api = restful.Api(app) @api.resource('/foo') class Foo(Resource): def get(self): return 'Hello, World!' c4j|gi|Sr3)r)clsr%rNr@s r' decoratorzApi.resource..decorators" D  c 3D 3F 3Jr1rZ)rNr@r%rs``` r'rz Api.resources r1c$|jddxs|jj}|jj ||jdd}|jdi}|t |divr=|j |jd}||k7rtd|d|jd |j|_ ||_ |j|j|g|i|} |jD] } | | } |D]x} |jrC|j r |j j"| fd | i|;t%|j&| } n|j'| d } |j"| fd | i|zy) Nrqresource_class_argsrZresource_class_kwargsview_functions view_classzThis endpoint (z) is already set to the class rfrrrX)rmrjlowerrJaddrr__dict__rxrrrqoutputas_viewrCrLrHrnrrb) rNr.rr@r%rqrrprevious_view_class resource_funcrurlrps r'r~zApi._register_views::j$/L83D3D3J3J3L 8$$jj)>C & +BB G ws$4b9 9"%"4"4X">"G"G "U #h. Yacvcc"ABB"446$ $4H$4$4X%%@S%%#%%&  5I%m4M 5 FC~~''6D((55c]]]V\]#4#5#5s;D))#r2 C  T E] Ef E) Fr1c2tfd}|S)zWraps a resource (as a flask view function), for cases where the resource does not directly return a response object :param resource: The resource as a flask view function c~|i|}t|tr|St|\}}}j|||S)N)r)r4 ResponseBaserr )argsr%rr#rrrrNs r'wrapperzApi.output..wrappersIT,V,D$ - "(, D$%%dD'%B Br1r)rNrrs`` r'rz Api.outputs$ x C  C r1c |j}|jr&dj|jj|}t |fi|S)zQGenerates a URL to the given resource. Works like :func:`flask.url_for`.z{0}.{1})rqrLformatror)rNrvaluesrqs r'rz Api.url_forsB$$ >> ''(;(;XFHx*6**r1c|jddxs |j}tjj |j |}| t ||j vr*|j ||g|i|}||jd<|S|dk(r)tt|g|i|}d|jd<|St)aLooks up the representation transformer for the requested media type, invoking the transformer to create a response object. This defaults to default_mediatype if no transformer is found for the requested mediatype. If default_mediatype is None, a 406 Not Acceptable response will be sent as per RFC 2616 section 14.1 :param data: Python object containing response data to be transformed rNdefault Content-Typer) rmrBraccept_mimetypes best_matchr?rroriginal_flask_make_responsestrr)rNr#rr%rB mediatypers r'r zApi.make_responses#JJ';TB\dF\F\,,77  %8   / ! ,, ,24'' 24I$I&ID+4DLL (K , &/D KDKFKD+7DLL (K%' 'r1cttjtjddDcgc]\}}| c}}Scc}}w)z@Returns a list of requested mediatypes sent in the Accept headerrT)r\reverse)sortedrroperator itemgetter)rNhqs r'rzApi.mediatypessD$W%=%=)1)<).wrapper.s.2D  +Kr1rZ)rNrrs`` r'representationzApi.representations* r1c|jrAtjjdd}dj d|}||j d<|S)z4 Given a response, change it to ask for credentials HTTP_BASIC_AUTH_REALMz flask-restfulz{0} realm="{1}"BasiczWWW-Authenticate)rErr)r*rr)rNrrealm challenges r'rzApi.unauthorized3sN  & &&&**+BOTE,33GUCI3C.2.!0 PRR6(. D *0=#,HTQ $sO r1rc LdtttfrB|r&t|Dcgc]}t ||c}fgSDcgc]}t ||c}Sfd|j D}|rt|t|fgSt|Scc}wcc}w)aTakes raw data (in the form of a dict, list, object) and a dict of fields to output and filters the data based on those fields. :param data: the actual object(s) from which the fields are taken from :param fields: a dict of whose keys will make up the final serialized response output :param envelope: optional key that will be used to envelop the serialized response >>> from flask_restful import fields, marshal >>> data = { 'a': 100, 'b': 'foo' } >>> mfields = { 'a': fields.Raw } >>> marshal(data, mfields) OrderedDict([('a', 100)]) >>> marshal(data, mfields, envelope='data') OrderedDict([('data', OrderedDict([('a', 100)]))]) c4t|tr|S|Sr3)r4r)rs r'makezmarshal..makes c4 5L r1c3K|]=\}}|t|tr t|n|j|f?ywr3)r4rlrr)r[kvr#rs r'r^zmarshal..sF )AZ4%8q!7>>!T*, )sAA)r4rtuplerritems)r#fieldsenvelopedrrs` @r'rrns. $u &hT(JF);(JKLM E>B!C'!V"4!C E ) )E=E;;u#567 8\+V[J\\ )K!Cs B B!ceZdZdZddZdZy)ra1A decorator that apply marshalling to the return values of your methods. >>> from flask_restful import fields, marshal_with >>> mfields = { 'a': fields.Raw } >>> @marshal_with(mfields) ... def get(): ... return { 'a': 100, 'b': 'foo' } ... ... >>> get() OrderedDict([('a', 100)]) >>> @marshal_with(mfields, envelope='data') ... def get(): ... return { 'a': 100, 'b': 'foo' } ... ... >>> get() OrderedDict([('data', OrderedDict([('a', 100)]))]) see :meth:`flask_restful.marshal` Nc ||_||_y)z :param fields: a dict of whose keys will make up the final serialized response output :param envelope: optional key that will be used to envelop the serialized response N)rr)rNrrs r'rOzmarshal_with.__init__s   r1c2tfd}|S)Nc|i|}t|tr3t|\}}}t|jj ||fSt|jj Sr3)r4rrrrrrr%rr#rrfrNs r'rz&marshal_with.__call__..wrappersad%f%D$&&,Tl#dGtT[[$--@$OOtT[[$--@@r1rrNr rs`` r'__call__zmarshal_with.__call__s" q A  Ar1r3rjrrrrOr rZr1r'rrs,! r1rceZdZdZdZdZy)raT A decorator that formats the return values of your methods with a single field. >>> from flask_restful import marshal_with_field, fields >>> @marshal_with_field(fields.List(fields.Integer)) ... def get(): ... return ['1', 2, 3.0] ... >>> get() [1, 2, 3] see :meth:`flask_restful.marshal_with` cLt|tr ||_y||_y)zP :param field: a single field with which to marshal the output. N)r4rfield)rNrs r'rOzmarshal_with_field.__init__s eT "DJDJr1c2tfd}|S)Nc|i|}t|tr-t|\}}}jj |||fSjj |Sr3)r4rrrrr s r'rz,marshal_with_field.__call__..wrappers]d%f%D$&&,Tl#dGzz((.g==::$$T* *r1rr s`` r'r zmarshal_with_field.__call__s q +  +r1Nr rZr1r'rrs  r1rr3)5 __future__r functoolsrrflaskrrrr r!r r flask.viewsr flask.signalsr werkzeug.datastructuresr werkzeug.exceptionsrrrrrwerkzeug.wrappersrrflask_restful.utilsrrr"flask_restful.representations.jsonrr5typesrrcollections.abcr ImportError collectionsr+__all__r0r:r>objectrrrrrrZr1r'r#s&$///?"/+mm6HH: $'/ W   / <=x&xv-z-`#]L*6*Z!!_$#$s*B33 CC