o `oiR@sddlZddlZddlmZddlmZddlmZmZm Z m Z e Z e eZddZddd ZGd d d ZGd d d eZGdddeZGdddeZGdddeZGdddeZdS)N) serializers)openapi)force_real_strget_field_defaultget_object_classes is_list_viewcCsJt||}t|rt|ddr|dfSddlm}|t|||dtfS)N__self__Tr)getattr_static)getattrinspectismethodr isinstance staticmethod)Zcls_or_instance method_namemethodr r`/var/www/html/kuke-dev/django-kuke/venv/lib/python3.10/site-packages/drf_yasg/inspectors/base.pyis_callable_methods  rcCsnt||r)zt||\}}|r|WSWnty(tjdt|jddYnw|r5t||r5t||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 )viewrZ fallback_attrdefaultZ view_methodZ is_callabalerrrcall_view_methods     rc@s6eZdZddZddZd ddZdd Zd d ZdS) BaseInspectorcCs"||_||_||_||_||_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)rpathr componentsrequest)selfrr rr!r"rrr__init__7s  zBaseInspector.__init__cKs|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)r#resultrobjkwargsrrrprocess_resultEszBaseInspector.process_resultNc Ks|pi}g}|D]C}t|sJdt|tsJd||j|j|j|j|jfi|}| |t ||d}|dur=q||fi|} | t urKn qt d|||d} t|D] }|j| ||fi|} qZ| 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))r isclass issubclassrrr rr!r"appendr NotHandledrrreversedr() r# inspectorsrr&Z initkwargsr'Ztried_inspectorsZ inspectorrr%rrrprobe_inspectorsVs* "   zBaseInspector.probe_inspectorscCtt|jddgS)zGet the renderer classes of this view by calling `get_renderers`. :return: renderer classes :rtype: list[type[rest_framework.renderers.BaseRenderer]] Z get_renderersZrenderer_classesrrrr#rrrget_renderer_classes{z"BaseInspector.get_renderer_classescCr0)zGet the parser classes of this view by calling `get_parsers`. :return: parser classes :rtype: list[type[rest_framework.parsers.BaseParser]] Z get_parsersZparser_classesr1r2rrrget_parser_classesr4z BaseInspector.get_parser_classesN)r __module__ __qualname__r$r(r/r3r5rrrrr6s  % rc@s eZdZdZddZddZdS)PaginatorInspectorzBase inspector for paginators. Responsible for determining extra query parameters and response structure added by given paginators. cCtS)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] r,)r# paginatorrrrget_paginator_parametersz+PaginatorInspector.get_paginator_parameterscCr:)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 r;)r#r<response_schemarrrget_paginated_response z)PaginatorInspector.get_paginated_responseN)rr7r8__doc__r=r@rrrrr9s r9c@seZdZdZddZdS)FilterInspectorzBase inspector for filter backends. Responsible for determining extra query parameters added by given filter backends. cCr:)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] r;)r#filter_backendrrrget_filter_parametersr>z%FilterInspector.get_filter_parametersN)rr7r8rBrErrrrrCs rCcs@eZdZdZfddZddZddZdd Zd d ZZ S) FieldInspectorz6Base inspector for serializers and serializer fields. cs"tt||||||||_dSr6)superrFr$field_inspectors)r#rr rr!r"rH __class__rrr$s zFieldInspector.__init__cCsBt|dd}t|di}|r|D] \}}t|||qdSdS)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 ZMetaNswagger_schema_fields)r itemssetattr)r#Zserializer_or_fieldZschemametarKattrvalrrradd_manual_fieldss  z FieldInspector.add_manual_fieldscKr:)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 r;r#fieldswagger_object_typeuse_referencesr'rrrfield_to_swagger_objectsz&FieldInspector.field_to_swagger_objectcKs&|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 rVrH)rTrUr/rHrRrrrprobe_field_inspectorssz%FieldInspector.probe_field_inspectorsc stjtjtjfvs JttjrJdjrtjndtjkr'ndtdd}|r5t|ndtjkr>nddfdd }tjkrTtjntj}||fS)a[Helper method to extract generic information from a field and return a partial constructor for the appropriate openapi object. All arguments are the same as :meth:`.field_to_swagger_object`. The return value is a tuple consisting of: * a function for constructing objects of `swagger_object_type`; its prototype is: :: def SwaggerType(existing_object=None, **instance_kwargs): This function creates an instance of `swagger_object_type`, passing the following attributes to its init, in order of precedence: - arguments specified by the ``kwargs`` parameter of :meth:`._get_partial_types` - ``instance_kwargs`` passed to the constructor function - ``title``, ``description``, ``required``, ``x-nullable`` and ``default`` inferred from the field, where appropriate If ``existing_object`` is not ``None``, it is updated instead of creating a new object. * a type that should be used for child objects if `field` is of an array type. This can currently have two values: - :class:`.Schema` if `swagger_object_type` is :class:`.Schema` - :class:`.Items` if `swagger_object_type` is :class:`.Parameter` or :class:`.Items` :rtype: (function,type[openapi.Schema] or type[openapi.Items]) z,passed field is already a SwaggerDict objectN help_textTcsd|vrtjkrj|d<d|vr&tjkr&t}|dtjfvr&||d<|r7|ddtjkr7| ddurA| dt ddrKd|d<| |durot |s[Jt |D] \}}t|||qa|}nd i|}tjkr||S) Nrequiredrrtitle descriptionZ allow_nullTZ x_nullabler)r ParameterrZItemsrremptyget TYPE_ARRAY setdefaultr updatersortedrLrMSchemarQ)Zexisting_objectZuse_field_titleZinstance_kwargsrkeyrPr%r\rSr'r#rTr[rr SwaggerTypes,       z6FieldInspector._get_partial_types..SwaggerType)NT) rrer]r^rZ SwaggerDictlabelrr )r#rSrTrUr'rYrhZchild_swagger_typerrgr_get_partial_typess "z!FieldInspector._get_partial_types) rr7r8rBr$rQrVrXrj __classcell__rrrIrrFs   rFc@seZdZddZddZdS)SerializerInspectorcCr:)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 r;r# serializerrrr get_schema6r>zSerializerInspector.get_schemacCr:)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] r;r#rnin_rrrget_request_parameters@rAz*SerializerInspector.get_request_parametersN)rr7r8rorrrrrrrl5s rlcseZdZdZdZdZgZgZgZfddZ ddZ dd Z d d Z d d Z ddZddZddZddZddZddZddZZS) ViewInspector)PUTPATCHPOSTDELETE)rtrurv)GETcs@tt||||||||_|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>` rHfilter_inspectorspaginator_inspectorsN)rGrsr$ overrides_prepend_inspector_overrides)r#rr rr!r"r{rIrrr$Zs   zViewInspector.__init__csB|j|drfddt||D}t|||dSdS)Ncsg|]}|vr|qSrr).0ZinspZextra_inspectorsrr isz>ViewInspector._prepend_inspector_overrides..)r{r`r rM)r#r.Zdefault_inspectorsrr~rr|fs z*ViewInspector._prepend_inspector_overridescCstd)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#Zoperation_keysrrr get_operationlszViewInspector.get_operationcCst|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)rr rrr2rrrrvszViewInspector.is_list_viewcCs|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 )rrupperimplicit_list_response_methodsr2rrrhas_list_responseszViewInspector.has_list_responsecCt|jddo |S)zoDetermine whether filter backend parameters should be included for this request. :rtype: bool filter_backendsNr rrr2rrr should_filterzViewInspector.should_filtercCs@|sgSg}t|jdD]}|||jd|pg7}q|S)zqReturn the parameters added to the view by its filter backends. :rtype: list[openapi.Parameter] rrE)rr rr/ry)r#fieldsrDrrrrEs z#ViewInspector.get_filter_parameterscCr)zDetermine whether paging parameters and structure should be added to this operation's request and response. :rtype: bool r<Nrr2rrr should_pagerzViewInspector.should_pagecCs(|sgS||jdt|jdpgS)zkReturn the parameters added to the view by its paginator. :rtype: list[openapi.Parameter] r=r<)rr/rzr rr2rrrget_pagination_parameterss  z'ViewInspector.get_pagination_parameterscCs||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 rorHrWrmrrrserializer_to_schemasz"ViewInspector.serializer_to_schemacCs |j|jd|d|ji|dpgS)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] rrrH)rqrWrprrrserializer_to_parameterss z&ViewInspector.serializer_to_parameterscCs|j|jdt|jd|dS)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 r@r<)r?)r/rzr r)r#r?rrrr@s  z$ViewInspector.get_paginated_response)rr7r8Z body_methodsZimplicit_body_methodsrrHryrzr$r|rrrrrErrrrr@rkrrrIrrsLs&       rs)NN)r loggingZrest_frameworkrrutilsrrrrobjectr, getLoggerrrrrrr9rCrFrlrsrrrrs    V|