nautobot 2.3.16__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/core/api/metadata.py

@@ -1,202 +1,25 @@
-import contextlib
-from typing import Any, Dict, List
-
 from django.core.exceptions import PermissionDenied
 from django.http import Http404
-from django.urls import reverse
-from django.urls.exceptions import NoReverseMatch
-import django_filters
-import drf_react_template.schema_form_encoder as schema
-from rest_framework import exceptions, fields as drf_fields, serializers as drf_serializers
+from django.utils.encoding import force_str
+from rest_framework import exceptions
 from rest_framework.metadata import SimpleMetadata
 from rest_framework.request import clone_request
 
-from nautobot.core.utils.filtering import build_lookup_label, get_filter_field_label
-from nautobot.core.utils.lookup import get_route_for_model
-
-# FIXME(jathan): I hate this pattern that these fields are hard-coded here. But for the moment, this
-# works reliably.
-BOTTOM_FIELDS = ["computed_fields", "custom_fields", "relationships"]
-
-
-class NautobotProcessingMixin(schema.ProcessingMixin):
-    """Processing mixin to account for custom field types and behaviors for Nautobot."""
-
-    def _get_type_map_value(self, field: schema.SerializerType):
-        """Overload default to add "required" as a default mapping."""
-        # This adds "required" as a default type mapping compared to drf_react_template core.
-        result = {
-            "type": field.style.get("schema:type"),
-            "enum": field.style.get("schema:enum"),
-            "format": field.style.get("schema:format"),
-            "widget": field.style.get("ui:widget"),
-            "required": field.style.get("schema:required"),
-            "readOnly": field.style.get("schema:readOnly"),
-        }
-        result_default = self.TYPE_MAP.get(type(field).__name__, {})
-        for k in result_default:
-            if result[k] is None:
-                result[k] = result_default[k]
-        return result
-
-    def order_fields(self, fields):
-        """Explicitly order the "big ugly" fields to the bottom."""
-        # FIXME(jathan): Correct the behavior introduced in #3500 by switching to `__all__` to
-        # assert these get added at the end.
-        for field_name in BOTTOM_FIELDS:
-            if field_name in fields:
-                fields.remove(field_name)
-                fields.append(field_name)
-        return fields
-
-
-class NautobotSchemaProcessor(NautobotProcessingMixin, schema.SchemaProcessor):
-    """SchemaProcessor to account for custom field types and behaviors for Nautobot."""
-
-    def _get_field_properties(self, field: schema.SerializerType, name: str) -> Dict[str, Any]:
-        """
-        This method is used to generate the proper schema based on serializer field mappings or
-        per-field attribute markup.
-
-        This has been overloaded with an `elif` to account for `ManyRelatedField`.
-        """
-        type_map_obj = self._get_type_map_value(field)
-        result = {
-            "type": type_map_obj["type"] or "string",
-            "title": self._get_title(field, name),
-        }
-
-        if isinstance(field, drf_serializers.ListField):
-            if field.allow_empty:
-                result["required"] = not getattr(field, "allow_empty", True)
-            result["items"] = self._get_field_properties(field.child, "")
-            result["uniqueItems"] = True
-        elif isinstance(field, drf_serializers.ManyRelatedField):
-            if field.allow_empty:
-                result["required"] = type_map_obj.get("required", [])
-            result["items"] = self._get_field_properties(field.child_relation, "")
-            result["uniqueItems"] = True
-        else:
-            if isinstance(field, drf_serializers.RelatedField):
-                result["uniqueItems"] = True
-                if hasattr(field, "queryset") and hasattr(field.queryset, "model"):
-                    # We construct the correct list view url here so we can just append the object id to the end of the url in our frontend.
-                    # e.g. /dcim/locations/
-                    try:
-                        model_url = reverse(get_route_for_model(model=field.queryset.model, action="list"))
-                    except NoReverseMatch:
-                        model_url = None
-                    model_options = field.queryset.model._meta
-                    result["required"] = field.required
-                    # Custom Keyword: modelName, modelNamePlural and appLabel
-                    # modelName represents the model name of the uuid model
-                    # modelUrl represents the UI URL to list instances of this model
-                    # and appLabel represents the app_name of the model
-                    result["modelName"] = model_options.model_name
-                    result["appLabel"] = model_options.app_label
-                    result["modelUrl"] = model_url
-            if field.allow_null:
-                result["type"] = [result["type"], "null"]
-            if enum := type_map_obj.get("enum"):
-                if enum == "choices":
-                    choices = field.choices
-                    result["enum"] = list(choices.keys())
-                    result["enumNames"] = list(choices.values())
-                if isinstance(enum, (list, tuple)):
-                    result["enum"] = [item[0] for item in enum]
-                    result["enumNames"] = [item[1] for item in enum]
-            if format_ := type_map_obj["format"]:
-                result["format"] = format_
-
-            if read_only := field.read_only:
-                result["readOnly"] = read_only
-
-            with contextlib.suppress(drf_fields.SkipField):
-                result["default"] = field.get_default()
-
-        result = self._set_validation_properties(field, result)
-
-        return result
-
-    @staticmethod
-    def _filter_fields(all_fields):
-        """
-        Override super._filter_fields to return all fields, including read-only fields,
-        as read-only fields have to be displayed in Detail View.
-        """
-        return tuple((name, field) for name, field in all_fields)
-
-
-class NautobotUiSchemaProcessor(NautobotProcessingMixin, schema.UiSchemaProcessor):
-    """UiSchemaProcessor to account for custom field types and behaviors for Nautobot."""
-
-    def _field_order(self) -> List[str]:
-        """
-        Overload the base which just returns `Meta.fields` and doesn't play nicely with "__all__".
-
-        This instead calls `get_fields()` and returns the keys.
-        """
-        if self._is_list_serializer(self.serializer):
-            fields = self.serializer.child.get_fields()
-        else:
-            fields = self.serializer.get_fields()
-
-        field_names = self.order_fields(list(fields))
-
-        return field_names
-
-    def _get_ui_field_properties(self, field: schema.SerializerType, name: str) -> Dict[str, Any]:
-        """
-        We had to overload this here to make it so that array types with children validate properly
-        and to also use `NautobotUiSchemaProcessor` over the default.
-        """
-        data_index = self._generate_data_index(name)
-        result = {}
-        is_int = False
-        is_list = False
-        if self._is_field_serializer(field):
-            return NautobotUiSchemaProcessor(field, self.renderer_context, prefix=data_index).get_ui_schema()
-        elif isinstance(field, drf_serializers.ListField):
-            is_list = True
-            child = field.child
-            is_int = isinstance(child, drf_serializers.IntegerField)
-            widget = self._get_type_map_value(field=child).get("widget")
-            if not widget and isinstance(child, drf_serializers.ChoiceField):
-                widget = "checkbox"
-        else:
-            widget = self._get_type_map_value(field=field).get("widget")
-        help_text = field.help_text
-        if widget:
-            if is_list and is_int:
-                if "items" not in result:
-                    result["items"] = {}
-                result["items"]["ui:widget"] = widget
-            else:
-                result["ui:widget"] = widget
-        if help_text:
-            result["ui:help"] = help_text
-        result.update(self._get_style_dict(field))
-        result = self._set_validation_properties(field, result)
-        return result
-
-
-class NautobotColumnProcessor(NautobotProcessingMixin, schema.ColumnProcessor):
-    """ColumnProcessor to account for custom field types and behaviors for Nautobot."""
+from nautobot.core.api import ContentTypeField
 
 
 class NautobotMetadata(SimpleMetadata):
     """
-    Metadata class that emits JSON schema. It contains `schema` and `uiSchema` keys where:
-
-    - schema: The object JSON schema
-    - uiSchema: The object UI schema which describes the form layout in the UI
+    Metadata class that emits JSON schema.
     """
 
     def determine_actions(self, request, view):
         """Generate the actions and return the names of the allowed methods."""
-        actions = []
+        actions = {}
         for method in {"PUT", "POST"} & set(view.allowed_methods):
             view.request = clone_request(request, method)
+            view.request.major_version = request.major_version
+            view.request.minor_version = request.minor_version
             try:
                 # Test global permissions
                 if hasattr(view, "check_permissions"):
@@ -207,82 +30,31 @@ class NautobotMetadata(SimpleMetadata):
             except (exceptions.APIException, PermissionDenied, Http404):
                 pass
             else:
-                actions.append(method)
+                # If user has appropriate permissions for the view, include
+                # appropriate metadata about the fields that should be supplied.
+                serializer = view.get_serializer()
+                actions[method] = self.get_serializer_info(serializer)
             finally:
                 view.request = request
         return actions
 
-    def get_list_display_fields(self, serializer):
-        """Try to get the list display fields or default to an empty list."""
-        serializer_meta = getattr(serializer, "Meta", None)
-        return list(getattr(serializer_meta, "list_display_fields", []))
-
-    def determine_metadata(self, request, view):
-        """This is the metadata that gets returned on an `OPTIONS` request."""
-        metadata = super().determine_metadata(request, view)
-
-        # Include the object type label for this model.
-        object_type = view.queryset.model._meta.label_lower if getattr(view, "queryset", None) else "unknown"
-        metadata["object_type"] = object_type
+    def get_field_info(self, field):
+        """
+        Fixup field information:
 
-        # If there's a serializer, do the needful to bind the schema/uiSchema.
-        if hasattr(view, "get_serializer"):
-            serializer = view.get_serializer()
-            # TODO(jathan): Bit of a WIP here. Will likely refactor. There might be cases where we
-            # want to explicitly override the UI field ordering, but that's not yet accounted for
-            # here. For now the assertion is always put the `list_display_fields` first, and then
-            # include the rest in whatever order.
-            # See: https://rjsf-team.github.io/react-jsonschema-form/docs/usage/objects#specifying-property-order
-            ui_schema = NautobotUiSchemaProcessor(serializer, request.parser_context).get_ui_schema()
-            ui_schema["ui:order"] = [*self.get_list_display_fields(serializer), "*"]
-            metadata.update(
+        - Set choices for ContentTypeField
+        - Replace DRF choices `display_name` to `display` to match new pattern.
+        """
+        field_info = super().get_field_info(field)
+        for choice in field_info.get("choices", []):
+            choice["display"] = choice.pop("display_name")
+        if hasattr(field, "queryset") and not field_info.get("read_only") and isinstance(field, ContentTypeField):
+            field_info["choices"] = [
                 {
-                    "schema": NautobotSchemaProcessor(serializer, request.parser_context).get_schema(),
-                    "uiSchema": ui_schema,
+                    "value": choice_value,
+                    "display": force_str(choice_name, strings_only=True),
                 }
-            )
-
-            metadata["filters"] = self.get_filter_info(view)
-
-            if hasattr(serializer, "determine_view_options"):
-                metadata["view_options"] = serializer.determine_view_options(request)
-
-        return metadata
-
-    def get_filter_info(self, view):
-        """Enumerate filterset information for the view. Returns a dictionary with the following format:
-
-        {
-            "filter_name": {
-                "label": "Filter Label",
-                "lookup_types": [
-                    {"value": "filter_name__n", "label": "not exact (n)"},
-                    {"value": "filter_name__re", "label": "matches regex (re)"},
-                    ...
-                ]
-            }
-        }
-
-        """
-
-        if not getattr(view, "filterset_class", None):
-            return {}
-        filterset = view.filterset_class
-        filters = {}
-        for filter_name, filter_instance in sorted(
-            filterset.base_filters.items(),
-            key=lambda x: get_filter_field_label(x[1]),
-        ):
-            filter_key = filter_name.rsplit("__", 1)[0]
-            label = get_filter_field_label(filter_instance)
-            lookup_label = self._filter_lookup_label(filter_name, filter_instance)
-            filters.setdefault(filter_key, {"label": label})
-            filters[filter_key].setdefault("lookup_types", []).append({"value": filter_name, "label": lookup_label})
-        return filters
-
-    # TODO: move this into `build_lookup_label` when the legacy UI is removed
-    def _filter_lookup_label(self, filter_name, filter_instance):
-        """Fix confusing lookup labels for boolean filters."""
-        if isinstance(filter_instance, django_filters.BooleanFilter):
-            return "exact"
-        return build_lookup_label(filter_name, filter_instance.lookup_expr)
+                for choice_value, choice_name in field.choices.items()
+            ]
+            field_info["choices"].sort(key=lambda item: item["display"])
+        return field_info

nautobot/core/api/pagination.py

@@ -1,5 +1,6 @@
 from rest_framework.pagination import LimitOffsetPagination
 
+from nautobot.core.constants import MAX_PAGE_SIZE_DEFAULT, PAGINATE_COUNT_DEFAULT
 from nautobot.core.utils.config import get_settings_or_config
 
 
@@ -38,7 +39,7 @@ class OptionalLimitOffsetPagination(LimitOffsetPagination):
                 if limit < 0:
                     raise ValueError()
                 # Enforce maximum page size, if defined
-                max_page_size = get_settings_or_config("MAX_PAGE_SIZE")
+                max_page_size = get_settings_or_config("MAX_PAGE_SIZE", fallback=MAX_PAGE_SIZE_DEFAULT)
                 if max_page_size:
                     if limit == 0:
                         return max_page_size
@@ -48,7 +49,7 @@ class OptionalLimitOffsetPagination(LimitOffsetPagination):
             except (KeyError, ValueError):
                 pass
 
-        return get_settings_or_config("PAGINATE_COUNT")
+        return get_settings_or_config("PAGINATE_COUNT", fallback=PAGINATE_COUNT_DEFAULT)
 
     def get_next_link(self):
         # Pagination has been disabled

nautobot/core/api/renderers.py

@@ -156,6 +156,9 @@ class NautobotCSVRenderer(BaseRenderer):
                     #     value = [v["composite_key"] for v in value]
                     else:
                         value = [v["id"] for v in value]
+                if value and isinstance(value[0], dict) and ("value" in value[0]) and ("label" in value[0]):
+                    # Multiple enum types
+                    value = [v["value"] for v in value]
                 # The below makes for better UX than `json.dump()` for most current cases.
                 value = ",".join([str(v) if v is not None else "" for v in value])
             elif not isinstance(value, (str, int)):

nautobot/core/api/serializers.py

@@ -1,5 +1,4 @@
 import contextlib
-from copy import deepcopy
 import logging
 import uuid
 
@@ -18,7 +17,7 @@ from django.db.models.functions import Cast
 from django.urls import NoReverseMatch
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema_field, PolymorphicProxySerializer as _PolymorphicProxySerializer
-from rest_framework import relations as drf_relations, serializers
+from rest_framework import serializers
 from rest_framework.exceptions import PermissionDenied, ValidationError
 from rest_framework.fields import CreateOnlyDefault
 from rest_framework.reverse import reverse
@@ -31,11 +30,9 @@ from nautobot.core.api.utils import (
     dict_to_filter_params,
     nested_serializer_factory,
 )
-from nautobot.core.exceptions import ViewConfigException
 from nautobot.core.models.fields import LaxURLField as LaxURLModelField
 from nautobot.core.models.managers import TagsManager
 from nautobot.core.models.utils import construct_composite_key, construct_natural_slug
-from nautobot.core.templatetags.helpers import bettertitle
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.core.utils.requests import normalize_querydict
 from nautobot.extras.api.customfields import CustomFieldDefaultValues, CustomFieldsDataField
@@ -134,7 +131,6 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
 
     serializer_related_field = NautobotHyperlinkedRelatedField
 
-    id = serializers.UUIDField(read_only=False, default=serializers.CreateOnlyDefault(uuid.uuid4))
     display = serializers.SerializerMethodField(read_only=True, help_text="Human friendly display value")
     object_type = ObjectTypeField()
     # composite_key = serializers.SerializerMethodField()  # TODO: Revisit if we reintroduce composite keys
@@ -297,21 +293,6 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
         """Return whether this is a nested serializer."""
         return getattr(self.Meta, "is_nested", False)
 
-    @property
-    def list_display_fields(self):
-        return list(getattr(self.Meta, "list_display_fields", []))
-
-    @property
-    def advanced_tab_fields(self):
-        advanced_fields = list(
-            getattr(
-                self.Meta,
-                "advanced_tab_fields",
-                ["id", "url", "object_type", "created", "last_updated", "natural_slug"],
-            )
-        )
-        return [field for field in advanced_fields if field in self.fields]
-
     @extend_schema_field(serializers.CharField)
     def get_display(self, instance):
         """
@@ -405,221 +386,6 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
         fields = [field for field in fields if filter_field(field)]
         return fields
 
-    def determine_view_options(self, request=None):
-        """
-        Determine view options to use for rendering the list and detail views associated with this serializer.
-        """
-        list_display = []
-        fields = []
-
-        from nautobot.core.api.metadata import NautobotColumnProcessor  # avoid circular import
-
-        processor = NautobotColumnProcessor(self, request.parser_context if request else {})
-        field_map = dict(self.fields)
-        all_fields = list(field_map)
-
-        # Explicitly order the "big ugly" fields to the bottom
-        processor.order_fields(all_fields)
-        list_display_fields = self.list_display_fields
-
-        # Process the list_display_fields first.
-        for field_name in list_display_fields:
-            try:
-                field = field_map[field_name]
-            except KeyError:
-                continue  # Ignore unknown fields.
-            column_data = processor._get_column_properties(field, field_name)
-            list_display.append(column_data)
-            fields.append(column_data)
-
-        # Process the rest of the fields second.
-        for field_name in all_fields:
-            # Don't process list display fields twice.
-            if field_name in list_display_fields:
-                continue
-            try:
-                field = field_map[field_name]
-            except KeyError:
-                continue  # Ignore unknown fields.
-            column_data = processor._get_column_properties(field, field_name)
-            fields.append(column_data)
-
-        return {
-            "retrieve": {
-                "tabs": self._determine_detail_view_tabs(),
-            },
-            "list": {
-                "default_fields": list_display,
-                "all_fields": fields,
-            },
-        }
-
-    def _determine_detail_view_tabs(self):
-        """Determine the layout for the detail view tabs that are intrinsic to this serializer."""
-        tabs = self.get_additional_detail_view_tabs()
-
-        if hasattr(self.Meta, "detail_view_config"):
-            detail_view_config = self._validate_view_config(self.Meta.detail_view_config)
-        else:
-            detail_view_config = self._get_default_detail_view_config()
-        detail_view_config = self._refine_detail_view_config(detail_view_config, tabs)
-
-        return {
-            bettertitle(self.Meta.model._meta.verbose_name): detail_view_config,
-            **tabs,
-        }
-
-    def get_additional_detail_view_tabs(self):
-        """
-        Retrieve definitions of non-default detail view tabs.
-
-        By default provides an "Advanced" tab containing `self.advanced_tab_fields`, but subclasses
-        can override this to move additional serializer fields to this or other tabs.
-
-        Returns:
-            (dict): `{<tab label>: [{<panel label>: {"fields": [<list of fields>]}, ...}, ...], ...}`
-        """
-        return {
-            "Advanced": [{"Object Details": {"fields": self.advanced_tab_fields}}],
-        }
-
-    def _get_default_detail_view_config(self):
-        """
-        Generate detail view config for the view based on the serializer's fields.
-
-        Examples:
-            >>> DeviceSerializer._get_default_detail_view_config().
-            {
-                "layout":[
-                    {
-                        Device: {
-                            "fields": ["name", "subdevice_role", "height", "comments"...]
-                        }
-                    },
-                    {
-                        Tags: {
-                            "fields": ["tags"]
-                        }
-                    }
-                ]
-            }
-
-        Returns:
-            (list): A list representing the view config.
-        """
-        m2m_fields, other_fields = self._get_m2m_and_non_m2m_fields()
-        # TODO(timizuo): How do we get verbose_name of not model serializers?
-        model_verbose_name = self.Meta.model._meta.verbose_name
-        return {
-            "layout": [
-                {
-                    bettertitle(model_verbose_name): {
-                        "fields": [field["name"] for field in other_fields],
-                    }
-                },
-                {field["label"]: {"fields": [field["name"]]} for field in m2m_fields},
-            ]
-        }
-
-    def _get_m2m_and_non_m2m_fields(self):
-        """
-        Retrieve the many-to-many (m2m) fields and other non-m2m fields from the serializer.
-
-        Returns:
-            A tuple containing two lists: m2m_fields and non m2m fields.
-                - m2m_fields: A list of dictionaries, each containing the name and label of an m2m field.
-                - non_m2m_fields: A list of dictionaries, each containing the name and label of a non m2m field.
-        """
-        m2m_fields = []
-        non_m2m_fields = []
-
-        for field_name, field in self.fields.items():
-            if isinstance(field, drf_relations.ManyRelatedField):
-                m2m_fields.append({"name": field_name, "label": field.label or field_name})
-            else:
-                non_m2m_fields.append({"name": field_name, "label": field.label or field_name})
-
-        return m2m_fields, non_m2m_fields
-
-    def _refine_detail_view_config(self, detail_view_config, other_tabs):
-        """
-        Refine the detail view config for the default tab (auto-generated, or as defined by Meta.detail_view_config).
-
-        - Remove fields that should never be present in the detail view config (e.g. `notes_url`).
-        - Ensure that fields that are already present in `other_tabs` aren't included in the detail view config.
-        - Ensure that certain fields such as `tags` are always included in the detail view config if applicable.
-
-        Args:
-            detail_view_config (dict): `{"layout": [{<left-column>}, {<right-column}], "include_others": False}`
-
-        Returns:
-            (list): `[{"Panel 1 Name": {"fields": ["field1", "field2", ...]}, "Panel 2 Name": ...}, {...}]`
-        """
-        fields_to_always_move_to_right_column = [
-            "comments",
-            "tags",
-        ]
-        fields_to_always_remove = [
-            # always handled explicitly by the UI
-            "display",
-            "status",
-            # not yet supported in the UI
-            "custom_fields",
-            "relationships",
-            "computed_fields",
-            # irrelevant to the UI
-            "notes_url",
-        ]
-        fields_to_remove = fields_to_always_remove + fields_to_always_move_to_right_column
-        # Any field that's already present in another tab
-        for tab_layout in other_tabs.values():
-            for column in tab_layout:
-                for grouping in column.values():
-                    fields_to_remove += grouping["fields"]
-
-        # Make a deepcopy to avoid altering view_config
-        view_config_layout = deepcopy(detail_view_config.get("layout"))
-
-        # Remove fields_to_remove from the view_config_layout
-        for column in view_config_layout:
-            for section in column.values():
-                for field in fields_to_remove:
-                    if field in section["fields"]:
-                        section["fields"].remove(field)
-
-        serializer_fields = list(self.fields)
-
-        # Add special-cased fields to right column
-        for field in fields_to_always_move_to_right_column:
-            if field in serializer_fields:
-                if len(view_config_layout) < 2:
-                    view_config_layout.append({})
-                view_config_layout[1].setdefault(bettertitle(field), {}).setdefault("fields", []).append(field)
-
-        # Add fields not otherwise included in another tab, only if include_others is set to True.
-        if detail_view_config.get("include_others", False):
-            view_config_fields = [
-                field for column in view_config_layout for section in column.values() for field in section["fields"]
-            ]
-            missing_fields = sorted(set(serializer_fields) - set(view_config_fields) - set(fields_to_remove))
-            view_config_layout[0]["Other Fields"] = {"fields": missing_fields}
-
-        return view_config_layout
-
-    def _validate_view_config(self, view_config):
-        """Validate view config."""
-        # 1. Validate key `layout` is in view_config; as this is a required key is creating a view config
-        if not view_config["layout"]:
-            raise ViewConfigException("`layout` is a required key in creating a custom view_config")
-
-        # 2. Validate `Other Fields` is not part of a layout group name, as this is a reserved keyword for group names
-        for col in view_config["layout"]:
-            for group_name in col.keys():
-                if group_name in constants.RESERVED_NAMES_FOR_OBJECT_DETAIL_VIEW_SCHEMA:
-                    raise ViewConfigException(f"`{group_name}` is a reserved group name keyword.")
-
-        return view_config
-
     def build_field(self, field_name, info, model_class, nested_depth):
         """
         Return a two tuple of (cls, kwargs) to build a serializer field with.
@@ -759,27 +525,27 @@ class ValidatedModelSerializer(BaseModelSerializer):
     validation. (DRF does not do this by default; see https://github.com/encode/django-rest-framework/issues/3144)
     """
 
-    def validate(self, attrs):
+    def validate(self, data):
         # Remove custom fields data and tags (if any) prior to model validation
-        local_attrs = attrs.copy()
-        local_attrs.pop("custom_fields", None)
-        local_attrs.pop("relationships", None)
-        local_attrs.pop("tags", None)
+        attrs = data.copy()
+        attrs.pop("custom_fields", None)
+        attrs.pop("relationships", None)
+        attrs.pop("tags", None)
 
         # Skip ManyToManyFields
         for field in self.Meta.model._meta.get_fields():
             if isinstance(field, models.ManyToManyField):
-                local_attrs.pop(field.name, None)
+                attrs.pop(field.name, None)
 
         # Run clean() on an instance of the model
         if self.instance is None:
-            instance = self.Meta.model(**local_attrs)
+            instance = self.Meta.model(**attrs)
         else:
             instance = self.instance
-            for k, v in local_attrs.items():
+            for k, v in attrs.items():
                 setattr(instance, k, v)
         instance.full_clean()
-        return attrs
+        return data
 
 
 class WritableNestedSerializer(BaseModelSerializer):
@@ -1106,3 +872,17 @@ class NautobotModelSerializer(
 
     Can also be used for models derived from BaseModel, so long as they support custom fields, notes, and relationships.
     """
+
+
+#
+# Tools
+#
+
+
+class RenderJinjaSerializer(serializers.Serializer):  # pylint: disable=abstract-method
+    """Serializer for RenderJinjaView."""
+
+    template_code = serializers.CharField(required=True)
+    context = serializers.DictField(default=dict)
+    rendered_template = serializers.CharField(read_only=True)
+    rendered_template_lines = serializers.ListField(read_only=True, child=serializers.CharField())