commonground-api-common 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

vng_api_common/extensions/geojson.py

@@ -0,0 +1,270 @@
+from drf_spectacular.extensions import OpenApiSerializerFieldExtension
+from drf_spectacular.plumbing import ResolvedComponent
+
+
+class GeometryFieldExtension(OpenApiSerializerFieldExtension):
+    target_class = "rest_framework_gis.fields.GeometryField"
+    match_subclasses = True
+    priority = 1
+
+    def get_name(self):
+        return "GeoJSONGeometry"
+
+    def map_serializer_field(self, auto_schema, direction):
+        geometry = ResolvedComponent(
+            name="Geometry",
+            type=ResolvedComponent.SCHEMA,
+            object="Geometry",
+            schema={
+                "type": "object",
+                "title": "Geometry",
+                "description": "GeoJSON geometry",
+                "required": ["type"],
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1"
+                },
+                "properties": {
+                    "type": {
+                        "type": "string",
+                        "enum": [
+                            "Point",
+                            "MultiPoint",
+                            "LineString",
+                            "MultiLineString",
+                            "Polygon",
+                            "MultiPolygon",
+                            "Feature",
+                            "FeatureCollection",
+                            "GeometryCollection",
+                        ],
+                        "description": "The geometry type",
+                    }
+                },
+            },
+        )
+        point_2d = ResolvedComponent(
+            name="Point2D",
+            type=ResolvedComponent.SCHEMA,
+            object="Point2D",
+            schema={
+                "type": "array",
+                "title": "Point2D",
+                "description": "A 2D point",
+                "items": {"type": "number"},
+                "maxItems": 2,
+                "minItems": 2,
+            },
+        )
+        point = ResolvedComponent(
+            name="Point",
+            type=ResolvedComponent.SCHEMA,
+            object="Point",
+            schema={
+                "type": "object",
+                "description": "GeoJSON point geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.2"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {"coordinates": point_2d.ref},
+                    },
+                ],
+            },
+        )
+
+        multi_point = ResolvedComponent(
+            name="MultiPoint",
+            type=ResolvedComponent.SCHEMA,
+            object="MultiPoint",
+            schema={
+                "type": "object",
+                "description": "GeoJSON multi-point geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.3"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {"type": "array", "items": point_2d.ref}
+                        },
+                    },
+                ],
+            },
+        )
+
+        line_string = ResolvedComponent(
+            name="LineString",
+            type=ResolvedComponent.SCHEMA,
+            object="LineString",
+            schema={
+                "type": "object",
+                "description": "GeoJSON line-string geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.4"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {
+                                "type": "array",
+                                "items": point_2d.ref,
+                                "minItems": 2,
+                            }
+                        },
+                    },
+                ],
+            },
+        )
+
+        multi_line_string = ResolvedComponent(
+            name="MultiLineString",
+            type=ResolvedComponent.SCHEMA,
+            object="MultiLineString",
+            schema={
+                "type": "object",
+                "description": "GeoJSON multi-line-string geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.5"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {
+                                "type": "array",
+                                "items": {
+                                    "type": "array",
+                                    "items": point_2d.ref,
+                                },
+                            }
+                        },
+                    },
+                ],
+            },
+        )
+
+        polygon = ResolvedComponent(
+            name="Polygon",
+            type=ResolvedComponent.SCHEMA,
+            object="Polygon",
+            schema={
+                "type": "object",
+                "description": "GeoJSON polygon geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.6"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {
+                                "type": "array",
+                                "items": {
+                                    "type": "array",
+                                    "items": point_2d.ref,
+                                },
+                            }
+                        },
+                    },
+                ],
+            },
+        )
+
+        multi_polygon = ResolvedComponent(
+            name="MultiPolygon",
+            type=ResolvedComponent.SCHEMA,
+            object="MultiPolygon",
+            schema={
+                "type": "object",
+                "description": "GeoJSON multi-polygon geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.7"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {
+                                "type": "array",
+                                "items": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "array",
+                                        "items": point_2d.ref,
+                                    },
+                                },
+                            }
+                        },
+                    },
+                ],
+            },
+        )
+
+        geometry_collection = ResolvedComponent(
+            name="GeometryCollection",
+            type=ResolvedComponent.SCHEMA,
+            object="GeometryCollection",
+            schema={
+                "type": "object",
+                "description": "GeoJSON geometry collection",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.8"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["geometries"],
+                        "properties": {
+                            "geometries": {"type": "array", "items": geometry.ref}
+                        },
+                    },
+                ],
+            },
+        )
+
+        for component in [
+            geometry,
+            point_2d,
+            point,
+            multi_point,
+            line_string,
+            multi_line_string,
+            polygon,
+            multi_polygon,
+            geometry_collection,
+        ]:
+            auto_schema.registry.register_on_missing(component)
+
+        return {
+            "title": "GeoJSONGeometry",
+            "type": "object",
+            "oneOf": [
+                point.ref,
+                multi_point.ref,
+                line_string.ref,
+                multi_line_string.ref,
+                polygon.ref,
+                multi_polygon.ref,
+                geometry_collection.ref,
+            ],
+            "discriminator": {
+                "propertyName": "type",
+            },
+        }

vng_api_common/extensions/hyperlink.py

@@ -0,0 +1,37 @@
+from django.utils.translation import gettext_lazy as _
+
+from drf_spectacular.extensions import OpenApiSerializerFieldExtension
+from drf_spectacular.openapi import AutoSchema
+
+
+class HyperlinkedRelatedFieldExtension(OpenApiSerializerFieldExtension):
+    target_class = "vng_api_common.serializers.LengthHyperlinkedRelatedField"
+    match_subclasses = True
+
+    def map_serializer_field(self, auto_schema: AutoSchema, direction):
+        default_schema = auto_schema._map_serializer_field(
+            self.target, direction, bypass_extensions=True
+        )
+        return {
+            **default_schema,
+            "minLength": self.target.min_length,
+            "maxLength": self.target.max_length,
+        }
+
+
+class HyperlinkedIdentityFieldExtension(OpenApiSerializerFieldExtension):
+    target_class = "rest_framework.serializers.HyperlinkedIdentityField"
+    match_subclasses = True
+
+    def map_serializer_field(self, auto_schema: AutoSchema, direction):
+        default_schema = auto_schema._map_serializer_field(
+            self.target, direction, bypass_extensions=True
+        )
+        return {
+            **default_schema,
+            "minLength": 1,
+            "maxLength": 1000,
+            "description": _(
+                "URL-referentie naar dit object. Dit is de unieke identificatie en locatie van dit object."
+            ),
+        }

vng_api_common/extensions/polymorphic.py

@@ -0,0 +1,68 @@
+from drf_spectacular.extensions import OpenApiSerializerExtension
+from drf_spectacular.plumbing import ResolvedComponent
+from drf_spectacular.settings import spectacular_settings
+
+from ..utils import underscore_to_camel
+
+
+class PolymorphicSerializerExtension(OpenApiSerializerExtension):
+    target_class = "vng_api_common.polymorphism.PolymorphicSerializer"
+    match_subclasses = True
+
+    def map_serializer(self, auto_schema, direction):
+        if not getattr(self.target, "discriminator", None):
+            raise AttributeError(
+                "'PolymorphicSerializer' derived serializers need to have 'discriminator' set"
+            )
+
+        discriminator = self.target.discriminator
+
+        # resolve component with base path
+        base_schema = auto_schema._map_serializer(
+            self.target, direction, bypass_extensions=True
+        )
+        base_name = f"Base_{self.target.__class__.__name__}"
+        if direction == "request" and spectacular_settings.COMPONENT_SPLIT_REQUEST:
+            base_name = base_name + "Request"
+        base_component = ResolvedComponent(
+            name=base_name,
+            type=ResolvedComponent.SCHEMA,
+            object=base_name,
+            schema=base_schema,
+        )
+        auto_schema.registry.register_on_missing(base_component)
+
+        components = {}
+        # resolve sub components and components
+        for resource_type, sub_serializer in discriminator.mapping.items():
+            if not sub_serializer or not sub_serializer.fields:
+                schema = {"allOf": [base_component.ref]}
+            else:
+                sub_component = auto_schema.resolve_serializer(
+                    sub_serializer, direction
+                )
+                schema = {"allOf": [base_component.ref, sub_component.ref]}
+
+            component_name = f"{resource_type.value}_{self.target.__class__.__name__}"
+            if direction == "request" and spectacular_settings.COMPONENT_SPLIT_REQUEST:
+                component_name = component_name + "Request"
+            component = ResolvedComponent(
+                name=component_name,
+                type=ResolvedComponent.SCHEMA,
+                object=component_name,
+                schema=schema,
+            )
+            auto_schema.registry.register_on_missing(component)
+
+            components[resource_type.value] = component
+
+        return {
+            "oneOf": [component.ref for _, component in components.items()],
+            "discriminator": {
+                "propertyName": underscore_to_camel(discriminator.discriminator_field),
+                "mapping": {
+                    resource: component.ref["$ref"]
+                    for resource, component in components.items()
+                },
+            },
+        }

vng_api_common/extensions/query.py

@@ -0,0 +1,20 @@
+from drf_spectacular.contrib.django_filters import DjangoFilterExtension
+
+from vng_api_common.utils import underscore_to_camel
+
+
+class CamelizeFilterExtension(DjangoFilterExtension):
+    priority = 1
+
+    def get_schema_operation_parameters(self, auto_schema, *args, **kwargs):
+        """
+        camelize query parameters
+        """
+        parameters = super().get_schema_operation_parameters(
+            auto_schema, *args, **kwargs
+        )
+
+        for parameter in parameters:
+            parameter["name"] = underscore_to_camel(parameter["name"])
+
+        return parameters

vng_api_common/filters.py

@@ -26,7 +26,6 @@ logger = logging.getLogger(__name__)
 
 
 class Backend(DjangoFilterBackend):
-    # Taken from drf_yasg.inspectors.field.CamelCaseJSONFilter
     def _is_camel_case(self, view):
         return any(
             issubclass(parser, CamelCaseJSONParser) for parser in view.parser_classes

vng_api_common/generators.py

@@ -1,16 +1,7 @@
-from collections import OrderedDict
-from typing import List
-
-from drf_yasg import openapi
-from drf_yasg.generators import (
+from drf_spectacular.generators import (
     EndpointEnumerator as _EndpointEnumerator,
-    OpenAPISchemaGenerator as _OpenAPISchemaGenerator,
+    SchemaGenerator as _OpenAPISchemaGenerator,
 )
-from drf_yasg.utils import get_consumes, get_produces
-from rest_framework.schemas.utils import is_list_view
-from rest_framework.settings import api_settings
-
-from vng_api_common.utils import get_view_summary
 
 
 class EndpointEnumerator(_EndpointEnumerator):
@@ -29,110 +20,18 @@ class EndpointEnumerator(_EndpointEnumerator):
 
 
 class OpenAPISchemaGenerator(_OpenAPISchemaGenerator):
-    endpoint_enumerator_class = EndpointEnumerator
-
-    def get_tags(self, request=None, public=False):
-        """Retrieve the tags for the root schema.
-
-        :param request: the request used for filtering accessible endpoints and finding the spec URI
-        :param bool public: if True, all endpoints are included regardless of access through `request`
-
-        :return: List of tags containing the tag name and a description.
-        """
-        tags = {}
+    endpoint_inspector_cls = EndpointEnumerator
 
-        endpoints = self.get_endpoints(request)
-        for path, (view_cls, methods) in sorted(endpoints.items()):
-            if "{" in path:
-                continue
-
-            tag = path.rsplit("/", 1)[-1]
-            if tag in tags:
-                continue
-
-            # exclude special non-rest actions
-            if tag.startswith("_"):
-                continue
-            tags[tag] = get_view_summary(view_cls)
-
-        return [
-            OrderedDict([("name", operation), ("description", desc)])
-            for operation, desc in sorted(tags.items())
-        ]
-
-    def get_schema(self, request=None, public=False):
-        """
-        Rewrite parent class to add 'responses' in components
+    def create_view(self, callback, method, request=None):
         """
-        endpoints = self.get_endpoints(request)
-        components = self.reference_resolver_class(
-            openapi.SCHEMA_DEFINITIONS, "responses", force_init=True
-        )
-        self.consumes = get_consumes(api_settings.DEFAULT_PARSER_CLASSES)
-        self.produces = get_produces(api_settings.DEFAULT_RENDERER_CLASSES)
-        paths, prefix = self.get_paths(endpoints, components, request, public)
-
-        security_definitions = self.get_security_definitions()
-        if security_definitions:
-            security_requirements = self.get_security_requirements(security_definitions)
-        else:
-            security_requirements = None
-
-        url = self.url
-        if url is None and request is not None:
-            url = request.build_absolute_uri()
-
-        return openapi.Swagger(
-            info=self.info,
-            paths=paths,
-            consumes=self.consumes or None,
-            produces=self.produces or None,
-            tags=self.get_tags(request, public),
-            security_definitions=security_definitions,
-            security=security_requirements,
-            _url=url,
-            _prefix=prefix,
-            _version=self.version,
-            **dict(components),
-        )
-
-    def get_path_parameters(self, path, view_cls):
-        """Return a list of Parameter instances corresponding to any templated path variables.
-
-        :param str path: templated request path
-        :param type view_cls: the view class associated with the path
-        :return: path parameters
-        :rtype: list[openapi.Parameter]
+        workaround for HEAD method which doesn't have action
         """
-        parameters = super().get_path_parameters(path, view_cls)
-
-        # see if we can specify UUID a bit more
-        for parameter in parameters:
-            # the most pragmatic of checks
-            if not parameter.name.endswith("_uuid"):
-                continue
-            parameter.format = openapi.FORMAT_UUID
-            parameter.description = "Unieke resource identifier (UUID4)"
-        return parameters
-
-    def get_operation_keys(self, subpath, method, view) -> List[str]:
-        if method != "HEAD":
-            return super().get_operation_keys(subpath, method, view)
-
-        assert not is_list_view(
-            subpath, method, view
-        ), "HEAD requests are only supported on detail endpoints"
-
-        # taken from DRF schema generation
-        named_path_components = [
-            component
-            for component in subpath.strip("/").split("/")
-            if "{" not in component
-        ]
+        if method == "HEAD":
+            view = super(_OpenAPISchemaGenerator, self).create_view(
+                callback, method, request=request
+            )
+            return view
 
-        return named_path_components + ["headers"]
+        return super().create_view(callback, method, request=request)
 
-    def get_overrides(self, view, method) -> dict:
-        if method == "HEAD":
-            return {}
-        return super().get_overrides(view, method)
+    # todo support registering and reusing Response components

vng_api_common/notifications/api/views.py

@@ -1,7 +1,7 @@
 from django.conf import settings
 from django.utils.module_loading import import_string
 
-from drf_yasg.utils import swagger_auto_schema
+from drf_spectacular.utils import extend_schema
 from notifications_api_common.api.serializers import NotificatieSerializer
 from notifications_api_common.constants import SCOPE_NOTIFICATIES_PUBLICEREN_LABEL
 from rest_framework import status
@@ -18,7 +18,7 @@ class NotificationBaseView(APIView):
     Abstract view to receive webhooks
     """
 
-    swagger_schema = None
+    schema = None
 
     permission_classes = (AuthScopesRequired,)
     required_scopes = Scope(SCOPE_NOTIFICATIES_PUBLICEREN_LABEL, private=True)
@@ -26,7 +26,7 @@ class NotificationBaseView(APIView):
     def get_serializer(self, *args, **kwargs):
         return NotificatieSerializer(*args, **kwargs)
 
-    @swagger_auto_schema(
+    @extend_schema(
         responses={
             204: "",
             400: ValidatieFoutSerializer,

vng_api_common/oas.py

@@ -6,15 +6,14 @@ from typing import Union
 
 import requests
 import yaml
-from drf_yasg import openapi
 
 TYPE_MAP = {
-    openapi.TYPE_OBJECT: dict,
-    openapi.TYPE_STRING: str,
-    openapi.TYPE_NUMBER: (float, int),
-    openapi.TYPE_INTEGER: int,
-    openapi.TYPE_BOOLEAN: bool,
-    openapi.TYPE_ARRAY: list,
+    "object": dict,
+    "string": str,
+    "number": (float, int),
+    "integer": int,
+    "boolean": bool,
+    "array": list,
 }