=!gR.ddlZddlZddlmZddlmZddlmZmZm Z m Z e Z ej eZdZddZGdd ZGd d eZGd d eZGddeZGddeZGddeZdS)N) serializers)openapi)force_real_strget_field_defaultget_object_classes is_list_viewct||}tj|rt|ddr|dfSddlm}|t |||dt fS)N__self__Tr)getattr_static)getattrinspectismethodr isinstance staticmethod)cls_or_instance method_namemethodr s S/var/www/html/nourish/venv/lib/python3.11/site-packages/drf_yasg/inspectors/base.pyis_callable_methodrsw _k 2 2FGFJ$E$Et|&&&&&& :nn_k4PPR^__ __c*t||r` t||\}}|r |Sn?#t$r2tdt |jdYnwxYw|r t||rt||S|S)aCall a view method which might throw an exception. If an exception is thrown, log an informative error message and return the value of fallback_attr, or default if not present. The method must be callable without any arguments except cls or self. :param view: view class or instance; if a class is passed, instance methods won't be called :type view: rest_framework.views.APIView or type[rest_framework.views.APIView] :param str method_name: name of a method on the view :param str fallback_attr: name of an attribute on the view to fall back on, if calling the method fails :param default: default value if all else fails :return: view method's return value, or value of view's fallback_attr, or default :rtype: any or None zview's %s raised exception during schema generation; use `getattr(self, 'swagger_fake_view', False)` to detect and short-circuit thisT)exc_info)hasattrr Exceptionloggerwarningtype__name__r )viewr fallback_attrdefault view_method is_callabales rcall_view_methodr%st[!!? ?(:4(M(M %K %"{}}$ % ? ? ? NNj::.  ? ? ? ? ? ? ,}55,t]+++ Ns29A.-A.c.eZdZdZdZddZdZdZdS) BaseInspectorcL||_||_||_||_||_dS)a :param rest_framework.views.APIView view: the view associated with this endpoint :param str path: the path component of the operation URL :param str method: the http method of the operation :param openapi.ReferenceResolver components: referenceable components :param rest_framework.request.Request request: the request made against the schema view; can be None N)r pathr componentsrequest)selfr r)rr*r+s r__init__zBaseInspector.__init__7s+   $ rc |S)apAfter an inspector handles an object (i.e. returns a value other than :data:`.NotHandled`), all inspectors that were probed get the chance to alter the result, in reverse order. The inspector that handled the object is the first to receive a ``process_result`` call with the object it just returned. This behavior is similar to the Django request/response middleware processing. If this inspector has no post-processing to do, it should just ``return result`` (the default implementation). :param result: the return value of the winning inspector, or ``None`` if no inspector handled the object :param str method_name: name of the method that was called on the inspector :param obj: first argument passed to inspector method :param kwargs: additional arguments passed to inspector method :return: )r,resultrobjkwargss rprocess_resultzBaseInspector.process_resultEs  rNc |pi}g}|D]}tj|s Jdt|ts Jd||j|j|j|j|jfi|}| |t||d}|||fi|} | turn t d|||d} t|D]}|j| ||fi|} | S)afProbe a list of inspectors with a given object. The first inspector in the list to return a value that is not :data:`.NotHandled` wins. :param list[type[BaseInspector]] inspectors: list of inspectors to probe :param str method_name: name of the target method on the inspector :param obj: first argument to inspector method :param dict initkwargs: extra kwargs for instantiating inspector class :param kwargs: additional arguments to inspector method :return: the return value of the winning inspector, or ``None`` if no inspector handled the object z(inspector must be a class, not an objectz&inspectors must subclass BaseInspectorNz@%s ignored because no inspector in %s handled it (operation: %s))risclass issubclassr'r r)rr*r+appendr NotHandledrrreversedr3) r, inspectorsrr1 initkwargsr2tried_inspectors inspectorrr0s rprobe_inspectorszBaseInspector.probe_inspectorsVsL %2 #  I?9-- Y Y/Y Y Y-i77 a a9a a a7! $)TY T_VZVbqqfpqqI  # #I . . .Y T::F~VC**6**FZ''( NN] K 9 9 9F!"233 R RI-Y-fk3QQ&QQFF rcJtt|jddgS)zGet the renderer classes of this view by calling `get_renderers`. :return: renderer classes :rtype: list[type[rest_framework.renderers.BaseRenderer]] get_renderersrenderer_classesrr%r r,s rget_renderer_classesz"BaseInspector.get_renderer_classes{s% ""249oOace"f"fgggrcJtt|jddgS)zGet the parser classes of this view by calling `get_parsers`. :return: parser classes :rtype: list[type[rest_framework.parsers.BaseParser]] get_parsersparser_classesrBrCs rget_parser_classesz BaseInspector.get_parser_classess% ""249mM]_a"b"bcccrN)r __module__ __qualname__r-r3r>rDrHr/rrr'r'6sm   "####Jhhhdddddrr'ceZdZdZdZdZdS)PaginatorInspectorzBase inspector for paginators. Responsible for determining extra query parameters and response structure added by given paginators. ctS)aGet the pagination parameters for a single paginator **instance**. Should return :data:`.NotHandled` if this inspector does not know how to handle the given `paginator`. :param BasePagination paginator: the paginator :rtype: list[openapi.Parameter] r8)r, paginators rget_paginator_parametersz+PaginatorInspector.get_paginator_parameters rctS)adAdd appropriate paging fields to a response :class:`.Schema`. Should return :data:`.NotHandled` if this inspector does not know how to handle the given `paginator`. :param BasePagination paginator: the paginator :param openapi.Schema response_schema: the response schema that must be paged. :rtype: openapi.Schema rO)r,rPresponse_schemas rget_paginated_responsez)PaginatorInspector.get_paginated_response rN)rrJrK__doc__rQrUr/rrrMrMs<      rrMceZdZdZdZdS)FilterInspectorzBase inspector for filter backends. Responsible for determining extra query parameters added by given filter backends. ctS)a.Get the filter parameters for a single filter backend **instance**. Should return :data:`.NotHandled` if this inspector does not know how to handle the given `filter_backend`. :param BaseFilterBackend filter_backend: the filter backend :rtype: list[openapi.Parameter] rO)r,filter_backends rget_filter_parametersz%FilterInspector.get_filter_parametersrRrN)rrJrKrWr\r/rrrYrYs- rrYc:eZdZdZfdZdZdZdZdZxZ S)FieldInspectorz6Base inspector for serializers and serializer fields. cntt||||||||_dSrI)superr^r-field_inspectors)r,r r)rr*r+ra __class__s rr-zFieldInspector.__init__s7 nd##,,T4WUUU 0rct|dd}t|di}|r+|D]\}}t|||dSdS)aVSet fields from the ``swagger_schema_fields`` attribute on the Meta class. This method is called only for serializers or fields that are converted into ``openapi.Schema`` objects. :param serializer_or_field: serializer or field instance :param openapi.Schema schema: the schema object to be modified in-place MetaNswagger_schema_fields)r itemssetattr)r,serializer_or_fieldschemametareattrvals radd_manual_fieldsz FieldInspector.add_manual_fieldssy*FD99 '.Er J J  +288:: + + cc**** + + + +rc tS)aConvert a drf Serializer or Field instance into a Swagger object. Should return :data:`.NotHandled` if this inspector does not know how to handle the given `field`. :param rest_framework.serializers.Field field: the source field :param type[openapi.SwaggerDict] swagger_object_type: should be one of Schema, Parameter, Items :param bool use_references: if False, forces all objects to be declared inline instead of by referencing other components :param kwargs: extra attributes for constructing the object; if swagger_object_type is Parameter, ``name`` and ``in_`` should be provided :return: the swagger object :rtype: openapi.Parameter or openapi.Items or openapi.Schema or openapi.SchemaRef rOr,fieldswagger_object_typeuse_referencesr2s rfield_to_swagger_objectz&FieldInspector.field_to_swagger_objects rc B|j|jd|d|jif||d|S)zHelper method for recursively probing `field_inspectors` to handle a given field. All arguments are the same as :meth:`.field_to_swagger_object`. :rtype: openapi.Parameter or openapi.Items or openapi.Schema or openapi.SchemaRef rsra)rqrrr>raros rprobe_field_inspectorsz%FieldInspector.probe_field_inspectorssI%t$  !#.SwaggerTypes005HGL]5]5].3n +//4G7=4X4X+E224):";;;18OI. ;?#6#6vt#D#DHZ#Z#Z**7E:::&**=+FFFulD11 504 -  " "6 * * **!/3FGGGGG &'<'<'>'> ? ?77HCOS#6666(,,????#gn44&&uf555Mr)NT) rrrrr SwaggerDictlabelrr ) r,rprqrrr2rxrchild_swagger_typer|r{s ``` ` @@r_get_partial_typesz!FieldInspector._get_partial_typess<#w~w7H'-&XXXXXeW%899ii;iii9/4{Du{+++,>>DE;55 3<FnY///$ %8GM%I%Ikkt            D0Cgn/T/TW^^ZaZg...r) rrJrKrWr-rmrsrvr __classcell__rbs@rr^r^s@@11111 + + +    I/I/I/I/I/I/I/rr^ceZdZdZdZdS)SerializerInspectorctS)a-Convert a DRF Serializer instance to an :class:`.openapi.Schema`. Should return :data:`.NotHandled` if this inspector does not know how to handle the given `serializer`. :param serializers.BaseSerializer serializer: the ``Serializer`` instance :rtype: openapi.Schema rOr, serializers r get_schemazSerializerInspector.get_schema6rRrctS)aConvert a DRF serializer into a list of :class:`.Parameter`\ s. Should return :data:`.NotHandled` if this inspector does not know how to handle the given `serializer`. :param serializers.BaseSerializer serializer: the ``Serializer`` instance :param str in_: the location of the parameters, one of the `openapi.IN_*` constants :rtype: list[openapi.Parameter] rOr,rin_s rget_request_parametersz*SerializerInspector.get_request_parameters@rVrN)rrJrKrrr/rrrr5s2     rrcxeZdZdZdZdZgZgZgZfdZ dZ dZ dZ dZ d Zd Zd Zd Zd ZdZdZxZS) ViewInspector)PUTPATCHPOSTDELETE)rrr)GETctt||||||||_|d|d|ddS)z Inspector class responsible for providing :class:`.Operation` definitions given a view, path and method. :param dict overrides: manual overrides as passed to :func:`@swagger_auto_schema <.swagger_auto_schema>` rafilter_inspectorspaginator_inspectorsN)r`rr- overrides_prepend_inspector_overrides)r,r r)rr*r+rrbs rr-zViewInspector.__init__Zsw mT""++D$ GTTT" ))*<=== ))*=>>> ))*@AAAAArc|j|dr2fdt||D}t|||zdSdS)Ncg|]}|v| Sr/r/).0inspextra_inspectorss r z>ViewInspector._prepend_inspector_overrides..is%!m!m!m4PT\lPlPl$PlPlPlr)rrr rg)r,r:default_inspectorsrs @rrz*ViewInspector._prepend_inspector_overridesfss>--j$??  M!m!m!m!m743L3L!m!m!m  D*&69K&K L L L L L M Mrc td)awGet an :class:`.Operation` for the given API endpoint (path, method). This includes query, body parameters and response schemas. :param tuple[str] operation_keys: an array of keys describing the hierarchical layout of this view in the API; e.g. ``('snippets', 'list')``, ``('snippets', 'retrieve')``, etc. :rtype: openapi.Operation z-ViewInspector must implement get_operation()!)NotImplementedError)r,operation_keyss r get_operationzViewInspector.get_operationls""QRRRrcBt|j|j|jS)aDetermine whether this view is a list or a detail view. The difference between the two is that detail views depend on a pk/id path parameter. Note that a non-detail view does not necessarily imply a list response (:meth:`.has_list_response`), nor are list responses limited to non-detail views. For example, one might have a `/topic//posts` endpoint which is a detail view that has a list response. :rtype: bool)r r)rr rCs rr zViewInspector.is_list_viewvsDIt{DI>>>rcj|o|j|jvS)zDetermine whether this view returns multiple objects. By default this is any non-detail view (see :meth:`.is_list_view`) whose request method is one of :attr:`.implicit_list_response_methods`. :rtype: bool )r rupperimplicit_list_response_methodsrCs rhas_list_responsezViewInspector.has_list_responses1   ""c (9(9(;(;t?b(bcrcVt|jddo|S)zoDetermine whether filter backend parameters should be included for this request. :rtype: bool filter_backendsNr r rrCs r should_filterzViewInspector.should_filters* ty"3T::Wt?U?U?W?WWrc|sgSg}t|jdD]+}|||jd|pgz },|S)zqReturn the parameters added to the view by its filter backends. :rtype: list[openapi.Parameter] rr\)rr r r>r)r,fieldsr[s rr\z#ViewInspector.get_filter_parameterssw !!## I%di1BCC u uN d++D,BD[]k]k]m]mnntrt tFF rcVt|jddo|S)zDetermine whether paging parameters and structure should be added to this operation's request and response. :rtype: bool rPNrrCs r should_pagezViewInspector.should_pages) ty+t44Q9O9O9Q9QQrc|sgS||jdt|jdpgS)zkReturn the parameters added to the view by its paginator. :rtype: list[openapi.Parameter] rQrP)rr>rr r rCs rget_pagination_parametersz'ViewInspector.get_pagination_parameterssX !! I$$T%>@Z%,TY %D%DFFLIK LrcJ||jd|d|jiS)a#Convert a serializer to an OpenAPI :class:`.Schema`. :param serializers.BaseSerializer serializer: the ``Serializer`` instance :returns: the converted :class:`.Schema`, or ``None`` in case of an unknown serializer :rtype: openapi.Schema or openapi.SchemaRef rrarurs rserializer_to_schemaz"ViewInspector.serializer_to_schemas2$$  !<>PRVRg=h   rcR||jd|d|ji|pgS)a(Convert a serializer to a possibly empty list of :class:`.Parameter`\ s. :param serializers.BaseSerializer serializer: the ``Serializer`` instance :param str in_: the location of the parameters, one of the `openapi.IN_*` constants :rtype: list[openapi.Parameter] rra)rrurs rserializer_to_parametersz&ViewInspector.serializer_to_parameterssE$$  !#;ZJ\^b^sIt%   rcd||jdt|jd|S)a+Add appropriate paging fields to a response :class:`.Schema`. :param openapi.Schema response_schema: the response schema that must be paged. :returns: the paginated response class:`.Schema`, or ``None`` in case of an unknown pagination scheme :rtype: openapi.Schema rUrP)rT)r>rr r )r,rTs rrUz$ViewInspector.get_paginated_responses>$$T%>@X%,TY %D%DVe%gg gr)rrJrK body_methodsimplicit_body_methodsrrarrr-rrr rrr\rrrrrUrrs@rrrLs$5L5&." B B B B BMMM SSS???dddXXX   RRR L L L       gggggggrr)NN)rloggingrest_frameworkrrutilsrrrr objectr8 getLoggerrrrr%r'rMrYr^rrr/rrrs&&&&&&WWWWWWWWWWWWVXX  8 $ $```:SdSdSdSdSdSdSdSdl8m"y/y/y/y/y/]y/y/y/x..BgBgBgBgBgMBgBgBgBgBgr