nautobot 2.0.0a2__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/core/api/utils.py

@@ -8,6 +8,8 @@ from django.http import JsonResponse
 from django.urls import reverse
 from rest_framework import status
 from rest_framework.utils import formatting
+from rest_framework.utils.field_mapping import get_nested_relation_kwargs
+from rest_framework.utils.model_meta import RelationInfo, _get_to_field
 
 from nautobot.core.api import exceptions
 
@@ -79,14 +81,14 @@ def get_api_version_serializer(serializer_choices, api_version):
 
 
 def versioned_serializer_selector(obj, serializer_choices, default_serializer):
-    """Returns appropriate serializer class depending on request api_version, brief and swagger_fake_view
+    """Returns appropriate serializer class depending on request api_version, and swagger_fake_view
 
     Args:
         obj (ViewSet instance):
         serializer_choices (tuple): Tuple of SerializerVersions
         default_serializer (Serializer): Default Serializer class
     """
-    if not obj.brief and not getattr(obj, "swagger_fake_view", False) and hasattr(obj.request, "major_version"):
+    if not getattr(obj, "swagger_fake_view", False) and hasattr(obj.request, "major_version"):
         api_version = f"{obj.request.major_version}.{obj.request.minor_version}"
         serializer = get_api_version_serializer(serializer_choices, api_version)
         if serializer is not None:
@@ -102,6 +104,8 @@ def get_serializer_for_model(model, prefix=""):
         SerializerNotFound: if the requested serializer cannot be located.
     """
     app_name, model_name = model._meta.label.split(".")
+    if app_name == "contenttypes" and model_name == "ContentType":
+        app_name = "extras"
     # Serializers for Django's auth models are in the users app
     if app_name == "auth":
         app_name = "users"
@@ -177,3 +181,171 @@ def rest_api_server_error(request, *args, **kwargs):
         "python_version": platform.python_version(),
     }
     return JsonResponse(data, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+# TODO: This is part of the drf-react-template work towards auto-generating create/edit form UI from the REST API.
+def format_output(field, field_value):
+    """TODO: docstring required."""
+    data = {
+        "field_name": field,  # Form field placeholder
+        "type": "others",  # Param type e.g select field, char field, datetime field etc.
+        "choices": [],  # Param choices for select fields
+        "help_text": None,  # Form field placeholder
+        "label": None,  # Form field placeholder
+        "required": False,  # Form field placeholder
+    }
+    # TODO: fix these local imports if at all possible
+    from nautobot.core.api import WritableNestedSerializer
+    from rest_framework.fields import CharField
+    from rest_framework.fields import IntegerField
+    from rest_framework.serializers import ListSerializer
+    from nautobot.core.api import ChoiceField
+
+    kwargs = {}
+    if isinstance(field_value, (WritableNestedSerializer, ListSerializer)):
+        kwargs = {
+            "type": "dynamic-choice-field",
+        }
+        extra_kwargs = {}
+
+        if isinstance(field_value, WritableNestedSerializer):
+            extra_kwargs = {
+                "label": getattr(field_value, "label", None) or field,
+                "required": field_value.required,
+                "help_text": field_value.help_text,
+            }
+        elif isinstance(field_value, ListSerializer):
+            extra_kwargs = {
+                "label": "Tags",
+                "required": False,
+            }
+        kwargs.update(extra_kwargs)
+    elif isinstance(field_value, ChoiceField):
+        kwargs = {
+            "type": "choice-field",
+            "label": getattr(field_value, "label", None) or field,
+            "required": field_value.required,
+            "help_text": field_value.help_text,
+            "choices": field_value.choices.items(),
+        }
+    elif isinstance(field_value, CharField):
+        kwargs = {
+            "type": "char-field",
+            "label": getattr(field_value, "label", None) or field,
+            "required": field_value.required,
+            "help_text": field_value.help_text,
+        }
+    elif isinstance(field_value, IntegerField):
+        kwargs = {
+            "type": "integer-field",
+            "label": getattr(field_value, "label", None) or field,
+            "required": field_value.required,
+            "help_text": field_value.help_text,
+        }
+    data.update(kwargs)
+    return data
+
+
+# TODO: This is part of the drf-react-template work towards auto-generating create/edit form UI from the REST API.
+def get_data_for_serializer_parameter(model):
+    """TODO: docstring."""
+    serializer = get_serializer_for_model(model)
+    writeable_fields = {
+        field_name: format_output(field_name, field_value)
+        for field_name, field_value in serializer().get_fields().items()
+        if not field_value.read_only
+    }
+    return writeable_fields
+
+
+def get_relation_info_for_nested_serializers(model_class, related_model, field_name):
+    """Get the DRF RelationInfo object needed for build_nested_field()"""
+    relation_info = RelationInfo(
+        model_field=getattr(type(model_class), field_name),
+        related_model=type(related_model),
+        to_many=False,
+        has_through_model=False,
+        to_field=_get_to_field(getattr(type(model_class), field_name)),
+        reverse=False,
+    )
+    return relation_info
+
+
+def get_nested_serializer_depth(serializer):
+    """
+    Determine the correct depth value based on the request.
+    This method is used mostly in SerializerMethodField where
+    DRF does not automatically build a serializer for us because the field
+    is not a native model field.
+    """
+    request = serializer.context.get("request", None)
+    # If we do not have a request or request.method is not GET default depth to 0
+    if not request or request.method != "GET" or not hasattr(serializer.Meta, "depth"):
+        depth = 0
+    else:
+        depth = serializer.Meta.depth
+    return depth
+
+
+NESTED_SERIALIZER_CACHE = {}
+
+
+def nested_serializer_factory(relation_info, nested_depth):
+    """
+    Return a NestedSerializer representation of a serializer field.
+    This method should only be called in build_nested_field()
+    in which relation_info and nested_depth are already given.
+    """
+    nested_serializer_name = f"Nested{nested_depth}{relation_info.related_model.__name__}"
+    # If we already have built a suitable NestedSerializer we return the cached serializer.
+    # else we build a new one and store it in the cache for future use.
+    if nested_serializer_name in NESTED_SERIALIZER_CACHE:
+        field_class = NESTED_SERIALIZER_CACHE[nested_serializer_name]
+        field_kwargs = get_nested_relation_kwargs(relation_info)
+    else:
+        base_serializer_class = get_serializer_for_model(relation_info.related_model)
+
+        class NautobotNestedSerializer(base_serializer_class):
+            class Meta:
+                model = relation_info.related_model
+                is_nested = True
+                depth = nested_depth - 1
+                if hasattr(base_serializer_class.Meta, "fields"):
+                    fields = base_serializer_class.Meta.fields
+                if hasattr(base_serializer_class.Meta, "exclude"):
+                    exclude = base_serializer_class.Meta.exclude
+
+        NautobotNestedSerializer.__name__ = nested_serializer_name
+        NESTED_SERIALIZER_CACHE[nested_serializer_name] = NautobotNestedSerializer
+        field_class = NautobotNestedSerializer
+        field_kwargs = get_nested_relation_kwargs(relation_info)
+    return field_class, field_kwargs
+
+
+def return_nested_serializer_data_based_on_depth(serializer, depth, obj, obj_related_field, obj_related_field_name):
+    """
+    Handle serialization of GenericForeignKey fields at an appropriate depth.
+
+    When depth = 0, return the URL for the related object.
+    When depth > 0, return the data for the appropriate nested serializer, plus a "generic_foreign_key = True" field.
+
+    Args:
+        serializer: BaseSerializer
+        depth: Levels of nested serialization
+        obj: Object needs to be serialized
+        obj_related_field: Related object needs to be serialized
+        obj_related_field_name: Object's field name that represents the related object.
+    """
+    if depth == 0:
+        result = obj_related_field.get_absolute_url(api=True)
+        if serializer.context.get("request"):
+            result = serializer.context.get("request").build_absolute_uri(result)
+        return result
+    else:
+        relation_info = get_relation_info_for_nested_serializers(obj, obj_related_field, obj_related_field_name)
+        field_class, field_kwargs = serializer.build_nested_field(obj_related_field_name, relation_info, depth)
+        data = field_class(
+            obj_related_field, context={"request": serializer.context.get("request")}, **field_kwargs
+        ).data
+        data["generic_foreign_key"] = True
+        return data

nautobot/core/api/versioning.py

@@ -1,8 +1,9 @@
-from django.conf import settings
+from django.utils.functional import classproperty
 from django.utils.translation import gettext_lazy as _
 from rest_framework import exceptions
 from rest_framework.compat import unicode_http_header
 from rest_framework.utils.mediatypes import _MediaType
+from rest_framework.settings import api_settings
 from rest_framework.versioning import AcceptHeaderVersioning
 
 
@@ -14,16 +15,31 @@ class APIVersionMismatch(exceptions.APIException):
 class NautobotAPIVersioning(AcceptHeaderVersioning):
     """Support both accept-header versioning and query-parameter versioning as options."""
 
-    invalid_version_in_header = _('Invalid version in "Accept" header. Supported versions are %(versions)s') % {
-        "versions": ", ".join(settings.REST_FRAMEWORK["ALLOWED_VERSIONS"])
-    }
-    invalid_version_in_query = _("Invalid version in query parameter. Supported versions are %(versions)s") % {
-        "versions": ", ".join(settings.REST_FRAMEWORK["ALLOWED_VERSIONS"])
-    }
-
     header_version_param = "version"  # staying consistent with pre-1.3 versions of Nautobot
     query_version_param = "api_version"  # to avoid ambiguity with filtersets potentially including a "version" param
 
+    @classproperty  # https://github.com/PyCQA/pylint-django/issues/240
+    def allowed_versions(cls):  # pylint: disable=no-self-argument
+        """
+        List of version strings that are accepted by this class, based on api_settings.ALLOWED_VERSIONS.
+
+        The base `AcceptHeaderVersioning.allowed_versions` is a class property that is set at import time,
+        which means that things like `@override_settings` in tests happen "too late" to change it.
+        By re-implementing it as a property, we bypass that problem.
+        """
+        return api_settings.ALLOWED_VERSIONS
+
+    @classproperty  # https://github.com/PyCQA/pylint-django/issues/240
+    def default_version(cls):  # pylint: disable=no-self-argument
+        """
+        Default version number to use if unspecified by the requester, based on api_settings.DEFAULT_VERSION.
+
+        The base `AcceptHeaderVersioning.default_version` is a class property that is set at import time,
+        which means that things like `@override_settings` in tests happen "too late" to change it.
+        By re-implementing it as a property, we bypass that problem.
+        """
+        return api_settings.DEFAULT_VERSION
+
     def determine_version(self, request, *args, **kwargs):
         """Use either Accept header or query parameter for versioning."""
 
@@ -40,10 +56,16 @@ class NautobotAPIVersioning(AcceptHeaderVersioning):
             raise APIVersionMismatch()
         if header_version is not None and not self.is_allowed_version(header_version):
             # Behave like AcceptHeaderVersioning
-            raise exceptions.NotAcceptable(self.invalid_version_in_header)
+            raise exceptions.NotAcceptable(
+                f'Invalid version "{header_version}" in "Accept" header. Supported versions are: '
+                + ", ".join(self.allowed_versions)
+            )
         if query_version is not None and not self.is_allowed_version(query_version):
             # Behave like QueryParameterVersioning
-            raise exceptions.NotFound(self.invalid_version_in_query)
+            raise exceptions.NotFound(
+                f'Invalid version "{query_version}" in query parameter. Supported versions are: '
+                + ", ".join(self.allowed_versions)
+            )
         version = header_version or query_version or self.default_version
         # self.default_version is always allowed, no need to re-check is_allowed_version here
         return version