commonground-api-common 1.12.2__py3-none-any.whl → 2.4.1__py3-none-any.whl

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).",
-                    ),
-                ),
-            )
-        )

vng_api_common/inspectors/polymorphic.py

@@ -1,72 +0,0 @@
-"""
-Introspect polymorphic resources
-
-Bulk of the code taken from https://github.com/axnsan12/drf-yasg/issues/100
-"""
-
-from drf_yasg import openapi
-from drf_yasg.errors import SwaggerGenerationError
-from drf_yasg.inspectors.base import NotHandled
-from drf_yasg.inspectors.field import (
-    CamelCaseJSONFilter,
-    ReferencingSerializerInspector,
-)
-
-from ..polymorphism import PolymorphicSerializer
-from ..utils import underscore_to_camel
-
-
-class PolymorphicSerializerInspector(
-    CamelCaseJSONFilter, ReferencingSerializerInspector
-):
-    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 not isinstance(field, PolymorphicSerializer):
-            return NotHandled
-
-        if not getattr(field, "discriminator", None):
-            raise SwaggerGenerationError(
-                "'PolymorphicSerializer' derived serializers need to have 'discriminator' set"
-            )
-
-        base_schema_ref = super().field_to_swagger_object(
-            field, swagger_object_type, use_references, **kwargs
-        )
-        if not isinstance(base_schema_ref, openapi.SchemaRef):
-            raise SwaggerGenerationError(
-                "discriminator inheritance requires model references"
-            )
-
-        base_schema = base_schema_ref.resolve(self.components)  # type: openapi.Schema
-        base_schema.discriminator = underscore_to_camel(
-            field.discriminator.discriminator_field
-        )
-
-        for value, serializer in field.discriminator.mapping.items():
-            if serializer is None:
-                allof_derived = openapi.Schema(
-                    type=openapi.TYPE_OBJECT, all_of=[base_schema_ref]
-                )
-            else:
-                derived_ref = self.probe_field_inspectors(
-                    serializer, openapi.Schema, use_references=True
-                )
-                if not isinstance(derived_ref, openapi.SchemaRef):
-                    raise SwaggerGenerationError(
-                        "discriminator inheritance requies model references"
-                    )
-
-                allof_derived = openapi.Schema(
-                    type=openapi.TYPE_OBJECT, all_of=[base_schema_ref, derived_ref]
-                )
-            if not self.components.has(value, scope=openapi.SCHEMA_DEFINITIONS):
-                self.components.set(
-                    value, allof_derived, scope=openapi.SCHEMA_DEFINITIONS
-                )
-
-        return base_schema_ref

vng_api_common/inspectors/query.py

@@ -1,96 +0,0 @@
-from django.db import models
-
-try:
-    from django.utils.encoding import force_str
-except ImportError:  # Django < 4.0
-    from django.utils.encoding import force_text as force_str
-
-from django.utils.translation import gettext as _
-
-from django_filters.filters import BaseCSVFilter, ChoiceFilter
-from drf_yasg import openapi
-from drf_yasg.inspectors.query import CoreAPICompatInspector
-from rest_framework.filters import OrderingFilter
-
-from ..filters import URLModelChoiceFilter
-from ..utils import underscore_to_camel
-from .utils import get_target_field
-
-
-class FilterInspector(CoreAPICompatInspector):
-    """
-    Filter inspector that specifies the format of URL-based fields and lists
-    enum options.
-    """
-
-    def get_filter_parameters(self, filter_backend):
-        fields = super().get_filter_parameters(filter_backend)
-        if isinstance(filter_backend, OrderingFilter):
-            return fields
-
-        if fields:
-            queryset = self.view.get_queryset()
-            filter_class = filter_backend.get_filterset_class(self.view, queryset)
-
-            for parameter in fields:
-                filter_field = filter_class.base_filters[parameter.name]
-                model_field = get_target_field(queryset.model, parameter.name)
-                parameter._filter_field = filter_field
-
-                help_text = filter_field.extra.get(
-                    "help_text",
-                    getattr(model_field, "help_text", "") if model_field else "",
-                )
-
-                if isinstance(filter_field, BaseCSVFilter):
-                    if "choices" in filter_field.extra:
-                        schema = openapi.Schema(
-                            type=openapi.TYPE_ARRAY,
-                            items=openapi.Schema(
-                                type=openapi.TYPE_STRING,
-                                enum=[
-                                    choice[0]
-                                    for choice in filter_field.extra["choices"]
-                                ],
-                            ),
-                        )
-                    else:
-                        schema = openapi.Schema(
-                            type=openapi.TYPE_ARRAY,
-                            items=openapi.Schema(type=openapi.TYPE_STRING),
-                        )
-                    parameter["type"] = openapi.TYPE_ARRAY
-                    parameter["schema"] = schema
-                    parameter["style"] = "form"
-                    parameter["explode"] = False
-                elif isinstance(filter_field, URLModelChoiceFilter):
-                    description = _("URL to the related {resource}").format(
-                        resource=parameter.name
-                    )
-                    parameter.description = help_text or description
-                    parameter.format = openapi.FORMAT_URI
-                elif isinstance(filter_field, ChoiceFilter):
-                    parameter.enum = [
-                        choice[0] for choice in filter_field.extra["choices"]
-                    ]
-                elif model_field and isinstance(model_field, models.URLField):
-                    parameter.format = openapi.FORMAT_URI
-
-                if not parameter.description and help_text:
-                    parameter.description = force_str(help_text)
-
-                if "max_length" in filter_field.extra:
-                    parameter.max_length = filter_field.extra["max_length"]
-                if "min_length" in filter_field.extra:
-                    parameter.min_length = filter_field.extra["min_length"]
-
-        return fields
-
-    def process_result(self, result, method_name, obj, **kwargs):
-        """
-        Convert snake-case to camelCase.
-        """
-        if result and type(result) is list:
-            for parameter in result:
-                parameter.name = underscore_to_camel(parameter.name)
-        return result

vng_api_common/inspectors/utils.py

@@ -1,40 +0,0 @@
-from typing import Optional, Type
-
-from django.db import models
-
-from rest_framework.utils.model_meta import get_field_info
-
-
-def get_target_field(model: Type[models.Model], field: str) -> Optional[models.Field]:
-    """
-    Retrieve the end-target that ``field`` points to.
-
-    :param field: A string containing a lookup, potentially spanning relations. E.g.:
-      foo__bar__lte.
-    :return: A Django model field instance or `None`
-    """
-
-    start, *remaining = field.split("__")
-    field_info = get_field_info(model)
-
-    # simple, non relational field?
-    if start in field_info.fields:
-        return field_info.fields[start]
-
-    # simple relational field?
-    if start in field_info.forward_relations:
-        relation_info = field_info.forward_relations[start]
-        if not remaining:
-            return relation_info.model_field
-        else:
-            return get_target_field(relation_info.related_model, "__".join(remaining))
-
-    # check the reverse relations - note that the model name is used instead of model_name_set
-    # in the queries -> we can't just test for containment in field_info.reverse_relations
-    for relation_info in field_info.reverse_relations.values():
-        # not sure about this - what if there are more relations with different related names?
-        if relation_info.related_model._meta.model_name != start:
-            continue
-        return get_target_field(relation_info.related_model, "__".join(remaining))
-
-    return None