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

vng_api_common/inspectors/cache.py

@@ -1,57 +0,0 @@
-from collections import OrderedDict
-
-from django.utils.translation import gettext_lazy as _
-
-from drf_yasg import openapi
-from rest_framework.views import APIView
-
-from ..caching.introspection import has_cache_header
-
-CACHE_REQUEST_HEADERS = [
-    openapi.Parameter(
-        name="If-None-Match",
-        type=openapi.TYPE_STRING,
-        in_=openapi.IN_HEADER,
-        required=False,
-        description=_(
-            "Perform conditional requests. This header should contain one or "
-            "multiple ETag values of resources the client has cached. If the "
-            "current resource ETag value is in this set, then an HTTP 304 "
-            "empty body will be returned. See "
-            "[MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match) "
-            "for details."
-        ),
-        examples={
-            "oneValue": {
-                "summary": _("One ETag value"),
-                "value": '"79054025255fb1a26e4bc422aef54eb4"',
-            },
-            "multipleValues": {
-                "summary": _("Multiple ETag values"),
-                "value": '"79054025255fb1a26e4bc422aef54eb4", "e4d909c290d0fb1ca068ffaddf22cbd0"',
-            },
-        },
-    )
-]
-
-
-def get_cache_headers(view: APIView) -> OrderedDict:
-    if not has_cache_header(view):
-        return OrderedDict()
-
-    return OrderedDict(
-        (
-            (
-                "ETag",
-                openapi.Schema(
-                    type=openapi.TYPE_STRING,
-                    description=_(
-                        "De ETag berekend op de response body JSON. "
-                        "Indien twee resources exact dezelfde ETag hebben, dan zijn "
-                        "deze resources identiek aan elkaar. Je kan de ETag gebruiken "
-                        "om caching te implementeren."
-                    ),
-                ),
-            ),
-        )
-    )

vng_api_common/inspectors/fields.py

@@ -1,126 +0,0 @@
-import logging
-
-from drf_yasg import openapi
-from drf_yasg.inspectors.base import NotHandled
-from drf_yasg.inspectors.field import FieldInspector, InlineSerializerInspector
-from rest_framework import serializers
-
-from ..serializers import GegevensGroepSerializer, LengthHyperlinkedRelatedField
-
-logger = logging.getLogger(__name__)
-
-
-TYPES_MAP = {
-    str: openapi.TYPE_STRING,
-    int: openapi.TYPE_INTEGER,
-    bool: openapi.TYPE_BOOLEAN,
-}
-
-
-class ReadOnlyFieldInspector(FieldInspector):
-    """
-    Provides conversion for derived ReadOnlyField from model fields.
-
-    This inspector looks at the type hint to determine the type/format of
-    a model property.
-    """
-
-    def field_to_swagger_object(
-        self, field, swagger_object_type, use_references, **kwargs
-    ):
-        SwaggerType, ChildSwaggerType = self._get_partial_types(
-            field, swagger_object_type, use_references, **kwargs
-        )
-
-        if (
-            isinstance(field, serializers.ReadOnlyField)
-            and swagger_object_type == openapi.Schema
-        ):
-            prop = getattr(field.parent.Meta.model, field.source)
-            if not isinstance(prop, property):
-                return NotHandled
-
-            return_type = prop.fget.__annotations__.get("return")
-            if return_type is None:  # no type annotation, too bad...
-                logger.debug(
-                    "Missing return type annotation for prop %s on model %s",
-                    field.source,
-                    field.parent.Meta.model,
-                )
-                return NotHandled
-
-            type_ = TYPES_MAP.get(return_type)
-            if type_ is None:
-                logger.debug("Missing type mapping for %r", return_type)
-
-            return SwaggerType(type=type_ or openapi.TYPE_STRING)
-
-        return NotHandled
-
-
-class HyperlinkedIdentityFieldInspector(FieldInspector):
-    def field_to_swagger_object(
-        self, field, swagger_object_type, use_references, **kwargs
-    ):
-        SwaggerType, ChildSwaggerType = self._get_partial_types(
-            field, swagger_object_type, use_references, **kwargs
-        )
-
-        if (
-            isinstance(field, serializers.HyperlinkedIdentityField)
-            and swagger_object_type == openapi.Schema
-        ):
-            return SwaggerType(
-                type=openapi.TYPE_STRING,
-                format=openapi.FORMAT_URI,
-                min_length=1,
-                max_length=1000,
-                description="URL-referentie naar dit object. Dit is de unieke identificatie en locatie van dit object.",
-            )
-
-        return NotHandled
-
-
-class HyperlinkedRelatedFieldInspector(FieldInspector):
-    def field_to_swagger_object(
-        self, field, swagger_object_type, use_references, **kwargs
-    ):
-        SwaggerType, ChildSwaggerType = self._get_partial_types(
-            field, swagger_object_type, use_references, **kwargs
-        )
-
-        if (
-            isinstance(field, LengthHyperlinkedRelatedField)
-            and swagger_object_type == openapi.Schema
-        ):
-            max_length = field.max_length
-            min_length = field.min_length
-            return SwaggerType(
-                type=openapi.TYPE_STRING,
-                format=openapi.FORMAT_URI,
-                min_length=min_length,
-                max_length=max_length,
-                description=field.help_text,
-            )
-
-        return NotHandled
-
-
-class GegevensGroepInspector(InlineSerializerInspector):
-    def process_result(self, result, method_name, obj, **kwargs):
-        if not isinstance(result, openapi.Schema.OR_REF):
-            return result
-
-        if not isinstance(obj, GegevensGroepSerializer):
-            return result
-
-        if method_name != "field_to_swagger_object":
-            return result
-
-        if not obj.allow_null:
-            return result
-
-        schema = openapi.resolve_ref(result, self.components)
-        schema.x_nullable = True
-
-        return result

vng_api_common/inspectors/files.py

@@ -1,121 +0,0 @@
-from collections import OrderedDict
-
-from django.utils.translation import gettext as _
-
-from drf_extra_fields.fields import Base64FieldMixin
-from drf_yasg import openapi
-from drf_yasg.inspectors import (
-    CamelCaseJSONFilter,
-    FieldInspector,
-    NotHandled,
-    ViewInspector,
-)
-from drf_yasg.utils import filter_none, get_serializer_ref_name
-from rest_framework import serializers
-
-
-class FileFieldInspector(CamelCaseJSONFilter):
-    def get_schema(self, serializer):
-        if self.method not in ViewInspector.body_methods:
-            return NotHandled
-
-        # only do this if there are base64 mixin fields
-        if any(
-            isinstance(field, Base64FieldMixin) for field in serializer.fields.values()
-        ):
-            return self.probe_field_inspectors(serializer, openapi.Schema, True)
-
-        return NotHandled
-
-    def field_to_swagger_object(
-        self, field, swagger_object_type, use_references, **kwargs
-    ):
-        if isinstance(field, serializers.Serializer):
-            return self._serializer_to_swagger_object(
-                field, swagger_object_type, use_references, **kwargs
-            )
-
-        if not isinstance(field, Base64FieldMixin):
-            return NotHandled
-
-        SwaggerType, ChildSwaggerType = self._get_partial_types(
-            field, swagger_object_type, use_references, **kwargs
-        )
-
-        type_b64 = SwaggerType(
-            type=openapi.TYPE_STRING,
-            format=openapi.FORMAT_BASE64,
-            description=_("Base64 encoded binary content."),
-        )
-        type_uri = SwaggerType(
-            type=openapi.TYPE_STRING,
-            read_only=True,
-            format=openapi.FORMAT_URI,
-            description=_("Download URL of the binary content."),
-        )
-
-        if swagger_object_type == openapi.Schema:
-            # on writes, it's always b64
-            if self.method in ViewInspector.body_methods:
-                return type_b64
-
-            # if not representing in base64, it's a link
-            return type_uri if not field.represent_in_base64 else type_b64
-
-        return NotHandled
-
-    def _serializer_to_swagger_object(
-        self, serializer, swagger_object_type, use_references, **kwargs
-    ):
-        if self.method not in ViewInspector.body_methods:
-            return NotHandled
-
-        if not any(
-            isinstance(field, Base64FieldMixin) for field in serializer.fields.values()
-        ):
-            return NotHandled
-
-        SwaggerType, ChildSwaggerType = self._get_partial_types(
-            serializer, swagger_object_type, use_references, **kwargs
-        )
-
-        ref_name = get_serializer_ref_name(serializer)
-        ref_name = f"{ref_name}Data" if ref_name else None
-
-        def make_schema_definition():
-            properties = OrderedDict()
-            required = []
-            for property_name, child in serializer.fields.items():
-                prop_kwargs = {"read_only": bool(child.read_only) or None}
-                prop_kwargs = filter_none(prop_kwargs)
-
-                child_schema = self.probe_field_inspectors(
-                    child, ChildSwaggerType, use_references, **prop_kwargs
-                )
-                properties[property_name] = child_schema
-
-                if child.required and not getattr(child_schema, "read_only", False):
-                    required.append(property_name)
-
-            result = SwaggerType(
-                type=openapi.TYPE_OBJECT,
-                properties=properties,
-                required=required or None,
-            )
-            if not ref_name and "title" in result:
-                # on an inline model, the title is derived from the field name
-                # but is visually displayed like the model name, which is confusing
-                # it is better to just remove title from inline models
-                del result.title
-
-            # Provide an option to add manual paremeters to a schema
-            # for example, to add examples
-            # self.add_manual_fields(serializer, result)
-            return self.process_result(result, None, None)
-
-        if not ref_name or not use_references:
-            return make_schema_definition()
-
-        definitions = self.components.with_scope(openapi.SCHEMA_DEFINITIONS)
-        definitions.setdefault(ref_name, make_schema_definition)
-        return openapi.SchemaRef(definitions, ref_name)

vng_api_common/inspectors/geojson.py

@@ -1,360 +0,0 @@
-from collections import OrderedDict
-
-from drf_yasg import openapi
-from drf_yasg.inspectors import FieldInspector, NotHandled
-from rest_framework import serializers
-from rest_framework_gis.fields import GeometryField
-
-from ..geo import DEFAULT_CRS, HEADER_ACCEPT, HEADER_CONTENT
-
-REF_NAME_GEOJSON_GEOMETRY = "GeoJSONGeometry"
-
-
-def register_geojson(definitions):
-    Geometry = openapi.Schema(
-        type=openapi.TYPE_OBJECT,
-        title="Geometry",
-        description="GeoJSON geometry",
-        required=["type"],
-        externalDocs=OrderedDict(url="https://tools.ietf.org/html/rfc7946#section-3.1"),
-        properties=OrderedDict(
-            (
-                (
-                    "type",
-                    openapi.Schema(
-                        type=openapi.TYPE_STRING,
-                        enum=[
-                            "Point",
-                            "MultiPoint",
-                            "LineString",
-                            "MultiLineString",
-                            "Polygon",
-                            "MultiPolygon",
-                            "Feature",
-                            "FeatureCollection",
-                            "GeometryCollection",
-                        ],
-                        description="The geometry type",
-                    ),
-                ),
-            )
-        ),
-    )
-    definitions.set("Geometry", Geometry)
-
-    Point2D = openapi.Schema(
-        type=openapi.TYPE_ARRAY,
-        title="Point2D",
-        description="A 2D point",
-        items=openapi.Schema(type=openapi.TYPE_NUMBER),
-        maxItems=2,
-        minItems=2,
-    )
-    definitions.set("Point2D", Point2D)
-
-    Point = openapi.Schema(
-        type=openapi.TYPE_OBJECT,
-        description="GeoJSON point geometry",
-        externalDocs=OrderedDict(
-            url="https://tools.ietf.org/html/rfc7946#section-3.1.2"
-        ),
-        allOf=[
-            openapi.SchemaRef(definitions, "Geometry"),
-            openapi.Schema(
-                type=openapi.TYPE_OBJECT,
-                required=["coordinates"],
-                properties=OrderedDict(
-                    (("coordinates", openapi.SchemaRef(definitions, "Point2D")),)
-                ),
-            ),
-        ],
-    )
-    definitions.set("Point", Point)
-
-    MultiPoint = openapi.Schema(
-        type=openapi.TYPE_OBJECT,
-        description="GeoJSON multi-point geometry",
-        externalDocs=OrderedDict(
-            url="https://tools.ietf.org/html/rfc7946#section-3.1.3"
-        ),
-        allOf=[
-            openapi.SchemaRef(definitions, "Geometry"),
-            openapi.Schema(
-                type=openapi.TYPE_OBJECT,
-                required=["coordinates"],
-                properties=OrderedDict(
-                    (
-                        (
-                            "coordinates",
-                            openapi.Schema(
-                                type=openapi.TYPE_ARRAY,
-                                items=openapi.SchemaRef(definitions, "Point2D"),
-                            ),
-                        ),
-                    )
-                ),
-            ),
-        ],
-    )
-    definitions.set("MultiPoint", MultiPoint)
-
-    LineString = openapi.Schema(
-        type=openapi.TYPE_OBJECT,
-        description="GeoJSON line-string geometry",
-        externalDocs=OrderedDict(
-            url="https://tools.ietf.org/html/rfc7946#section-3.1.4"
-        ),
-        allOf=[
-            openapi.SchemaRef(definitions, "Geometry"),
-            openapi.Schema(
-                type=openapi.TYPE_OBJECT,
-                required=["coordinates"],
-                properties=OrderedDict(
-                    (
-                        (
-                            "coordinates",
-                            openapi.Schema(
-                                type=openapi.TYPE_ARRAY,
-                                items=openapi.SchemaRef(definitions, "Point2D"),
-                                minItems=2,
-                            ),
-                        ),
-                    )
-                ),
-            ),
-        ],
-    )
-    definitions.set("LineString", LineString)
-
-    MultiLineString = openapi.Schema(
-        type=openapi.TYPE_OBJECT,
-        description="GeoJSON multi-line-string geometry",
-        externalDocs=OrderedDict(
-            url="https://tools.ietf.org/html/rfc7946#section-3.1.5"
-        ),
-        allOf=[
-            openapi.SchemaRef(definitions, "Geometry"),
-            openapi.Schema(
-                type=openapi.TYPE_OBJECT,
-                required=["coordinates"],
-                properties=OrderedDict(
-                    (
-                        (
-                            "coordinates",
-                            openapi.Schema(
-                                type=openapi.TYPE_ARRAY,
-                                items=openapi.Schema(
-                                    type=openapi.TYPE_ARRAY,
-                                    items=openapi.SchemaRef(definitions, "Point2D"),
-                                ),
-                            ),
-                        ),
-                    )
-                ),
-            ),
-        ],
-    )
-    definitions.set("MultiLineString", MultiLineString)
-
-    Polygon = openapi.Schema(
-        type=openapi.TYPE_OBJECT,
-        description="GeoJSON polygon geometry",
-        externalDocs=OrderedDict(
-            url="https://tools.ietf.org/html/rfc7946#section-3.1.6"
-        ),
-        allOf=[
-            openapi.SchemaRef(definitions, "Geometry"),
-            openapi.Schema(
-                type=openapi.TYPE_OBJECT,
-                required=["coordinates"],
-                properties=OrderedDict(
-                    (
-                        (
-                            "coordinates",
-                            openapi.Schema(
-                                type=openapi.TYPE_ARRAY,
-                                items=openapi.Schema(
-                                    type=openapi.TYPE_ARRAY,
-                                    items=openapi.SchemaRef(definitions, "Point2D"),
-                                ),
-                            ),
-                        ),
-                    )
-                ),
-            ),
-        ],
-    )
-    definitions.set("Polygon", Polygon)
-
-    MultiPolygon = openapi.Schema(
-        type=openapi.TYPE_OBJECT,
-        description="GeoJSON multi-polygon geometry",
-        externalDocs=OrderedDict(
-            url="https://tools.ietf.org/html/rfc7946#section-3.1.7"
-        ),
-        allOf=[
-            openapi.SchemaRef(definitions, "Geometry"),
-            openapi.Schema(
-                type=openapi.TYPE_OBJECT,
-                required=["coordinates"],
-                properties=OrderedDict(
-                    (
-                        (
-                            "coordinates",
-                            openapi.Schema(
-                                type=openapi.TYPE_ARRAY,
-                                items=openapi.Schema(
-                                    type=openapi.TYPE_ARRAY,
-                                    items=openapi.Schema(
-                                        type=openapi.TYPE_ARRAY,
-                                        items=openapi.SchemaRef(definitions, "Point2D"),
-                                    ),
-                                ),
-                            ),
-                        ),
-                    )
-                ),
-            ),
-        ],
-    )
-    definitions.set("MultiPolygon", MultiPolygon)
-
-    GeometryCollection = openapi.Schema(
-        type=openapi.TYPE_OBJECT,
-        description="GeoJSON multi-polygon geometry",
-        externalDocs=OrderedDict(
-            url="https://tools.ietf.org/html/rfc7946#section-3.1.8"
-        ),
-        allOf=[
-            openapi.SchemaRef(definitions, "Geometry"),
-            openapi.Schema(
-                type=openapi.TYPE_OBJECT,
-                required=["geometries"],
-                properties=OrderedDict(
-                    (
-                        (
-                            "geometries",
-                            openapi.Schema(
-                                type=openapi.TYPE_ARRAY,
-                                items=openapi.SchemaRef(definitions, "Geometry"),
-                            ),
-                        ),
-                    )
-                ),
-            ),
-        ],
-    )
-    definitions.set("GeometryCollection", GeometryCollection)
-
-    GeoJSONGeometry = openapi.Schema(
-        title=REF_NAME_GEOJSON_GEOMETRY,
-        type=openapi.TYPE_OBJECT,
-        oneOf=[
-            openapi.SchemaRef(definitions, "Point"),
-            openapi.SchemaRef(definitions, "MultiPoint"),
-            openapi.SchemaRef(definitions, "LineString"),
-            openapi.SchemaRef(definitions, "MultiLineString"),
-            openapi.SchemaRef(definitions, "Polygon"),
-            openapi.SchemaRef(definitions, "MultiPolygon"),
-            openapi.SchemaRef(definitions, "GeometryCollection"),
-        ],
-        discriminator="type",
-    )
-    definitions.set(REF_NAME_GEOJSON_GEOMETRY, GeoJSONGeometry)
-
-
-class GeometryFieldInspector(FieldInspector):
-    def field_to_swagger_object(
-        self, field, swagger_object_type, use_references, **kwargs
-    ):
-        if not isinstance(field, GeometryField):
-            return NotHandled
-
-        definitions = self.components.with_scope(openapi.SCHEMA_DEFINITIONS)
-
-        if not definitions.has("Geometry"):
-            register_geojson(definitions)
-
-        return openapi.SchemaRef(definitions, REF_NAME_GEOJSON_GEOMETRY)
-
-    def has_geo_fields(self, serializer) -> bool:
-        """
-        Check if any of the serializer fields are a GeometryField.
-
-        If the serializer has nested serializers, a depth-first search is done
-        to check if the nested serializers has `GeometryField`\ s.
-        """
-        for field in serializer.fields.values():
-            if isinstance(field, serializers.Serializer):
-                has_nested_geo_fields = self.probe_inspectors(
-                    self.field_inspectors,
-                    "has_geo_fields",
-                    field,
-                    {"field_inspectors": self.field_inspectors},
-                )
-                if has_nested_geo_fields:
-                    return True
-
-            elif isinstance(field, (serializers.ListSerializer, serializers.ListField)):
-                field = field.child
-
-            if isinstance(field, GeometryField):
-                return True
-
-        return False
-
-    def get_request_header_parameters(self, serializer):
-        if not self.has_geo_fields(serializer):
-            return []
-
-        if self.method == "DELETE":
-            return []
-
-        # see also http://lyzidiamond.com/posts/4326-vs-3857 for difference
-        # between coordinate system and projected coordinate system
-        return [
-            openapi.Parameter(
-                name=HEADER_ACCEPT,
-                type=openapi.TYPE_STRING,
-                in_=openapi.IN_HEADER,
-                required=True,
-                description="Het gewenste 'Coordinate Reference System' (CRS) van de "
-                "geometrie in het antwoord (response body). Volgens de "
-                "GeoJSON spec is WGS84 de default (EPSG:4326 is "
-                "hetzelfde als WGS84).",
-                enum=[DEFAULT_CRS],
-            ),
-            openapi.Parameter(
-                name=HEADER_CONTENT,
-                type=openapi.TYPE_STRING,
-                in_=openapi.IN_HEADER,
-                required=True,
-                description="Het 'Coordinate Reference System' (CRS) van de "
-                "geometrie in de vraag (request body). Volgens de "
-                "GeoJSON spec is WGS84 de default (EPSG:4326 is "
-                "hetzelfde als WGS84).",
-                enum=[DEFAULT_CRS],
-            ),
-        ]
-
-    def get_response_headers(self, serializer, status=None):
-        if not self.has_geo_fields(serializer):
-            return None
-
-        if int(status) != 200:
-            return None
-
-        return OrderedDict(
-            (
-                (
-                    HEADER_CONTENT,
-                    openapi.Schema(
-                        type=openapi.TYPE_STRING,
-                        enum=[DEFAULT_CRS],
-                        description="Het 'Coordinate Reference System' (CRS) van de "
-                        "antwoorddata. Volgens de GeoJSON spec is WGS84 de "
-                        "default (EPSG:4326 is hetzelfde als WGS84).",
-                    ),
-                ),
-            )
-        )