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

nautobot/core/views/generic.py

@@ -1,4 +1,5 @@
 from copy import deepcopy
+from io import BytesIO
 import logging
 import re
 
@@ -12,16 +13,18 @@ from django.core.exceptions import (
 )
 from django.db import transaction, IntegrityError
 from django.db.models import ManyToManyField, ProtectedError
-from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput, Textarea
-from django.http import HttpResponse
+from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput
+from django.http import HttpResponse, JsonResponse
 from django.shortcuts import get_object_or_404, redirect, render
-from django.urls import NoReverseMatch, reverse
 from django.utils.html import escape
 from django.utils.http import is_safe_url
 from django.utils.safestring import mark_safe
 from django.views.generic import View
 from django_tables2 import RequestConfig
+from rest_framework.exceptions import ParseError
 
+from nautobot.core.api.parsers import NautobotCSVParser
+from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.forms import SearchForm
 from nautobot.core.exceptions import AbortTransaction
 from nautobot.core.forms import (
@@ -36,7 +39,6 @@ from nautobot.core.forms import (
 )
 from nautobot.core.forms.forms import DynamicFilterFormSet
 from nautobot.core.templatetags.helpers import bettertitle, validated_viewname
-from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.utils.requests import (
     convert_querydict_to_factory_formset_acceptable_querydict,
@@ -45,9 +47,13 @@ from nautobot.core.utils.requests import (
 )
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.mixins import GetReturnURLMixin, ObjectPermissionRequiredMixin
-from nautobot.core.views.utils import check_filter_for_display, csv_format, handle_protectederror, prepare_cloned_fields
-from nautobot.extras.models import CustomField, ExportTemplate
-from nautobot.extras.models.change_logging import ChangeLoggedModel
+from nautobot.core.views.utils import (
+    check_filter_for_display,
+    get_csv_form_fields_from_serializer_class,
+    handle_protectederror,
+    prepare_cloned_fields,
+)
+from nautobot.extras.models import ExportTemplate
 from nautobot.extras.utils import remove_prefix_from_cf_key
 
 
@@ -61,6 +67,7 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
 
     queryset = None
     template_name = None
+    use_new_ui = True
 
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "view")
@@ -89,55 +96,41 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
             "active_tab": request.GET.get("tab", "main"),
         }
 
-    # 2.0 TODO: Remove this method in 2.0. Can be retrieved from instance itself now
-    # instance.get_changelog_url()
-    # Only available on models that support changelogs
-    def get_changelog_url(self, instance):
-        """Return the changelog URL for a given instance."""
-        meta = self.queryset.model._meta
-
-        # Don't try to generate a changelog_url for an ObjectChange.
-        if meta.model_name == "objectchange":
-            return None
-
-        route = get_route_for_model(instance, "changelog")
-
-        # Iterate the pk-like fields and try to get a URL, or return None.
-        fields = ["pk", "slug"]
-        for field in fields:
-            if not hasattr(instance, field):
-                continue
-
-            try:
-                return reverse(route, kwargs={field: getattr(instance, field)})
-            except NoReverseMatch:
-                continue
-
-        # This object likely doesn't have a changelog route defined.
-        return None
-
     def get(self, request, *args, **kwargs):
         """
         Generic GET handler for accessing an object by PK or slug
         """
         instance = get_object_or_404(self.queryset, **kwargs)
 
-        changelog_url = None
-
-        if isinstance(instance, ChangeLoggedModel):
-            changelog_url = instance.get_changelog_url()
+        # TODO: this feels inelegant - should the tabs lookup be a dedicated endpoint rather than piggybacking
+        # on the object-retrieve endpoint?
+        # TODO: similar functionality probably needed in NautobotUIViewSet as well, not currently present
+        if request.GET.get("viewconfig", None) == "true":
+            # TODO: we shouldn't be importing a private-named function from another module. Should it be renamed?
+            from nautobot.extras.templatetags.plugins import _get_registered_content
 
-        return render(
-            request,
-            self.get_template_name(),
-            {
+            temp_fake_context = {
                 "object": instance,
-                "verbose_name": self.queryset.model._meta.verbose_name,
-                "verbose_name_plural": self.queryset.model._meta.verbose_name_plural,
-                "changelog_url": changelog_url,  # 2.0 TODO: Remove in 2.0. This information can be retrieved from the object itself now.
-                **self.get_extra_context(request, instance),
-            },
-        )
+                "request": request,
+                "settings": {},
+                "csrf_token": "",
+                "perms": {},
+            }
+
+            plugin_tabs = _get_registered_content(instance, "detail_tabs", temp_fake_context, return_html=False)
+            resp = {"tabs": plugin_tabs}
+            return JsonResponse(resp)
+        else:
+            return render(
+                request,
+                self.get_template_name(),
+                {
+                    "object": instance,
+                    "verbose_name": self.queryset.model._meta.verbose_name,
+                    "verbose_name_plural": self.queryset.model._meta.verbose_name_plural,
+                    **self.get_extra_context(request, instance),
+                },
+            )
 
 
 class ObjectListView(ObjectPermissionRequiredMixin, View):
@@ -165,6 +158,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         "per_page",  # used by get_paginate_count
         "sort",  # table sorting
     )
+    use_new_ui = True
 
     def get_filter_params(self, request):
         """Helper function - take request.GET and discard any parameters that are not used for queryset filtering."""
@@ -174,6 +168,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "view")
 
+    # TODO: remove this as well?
     def queryset_to_yaml(self):
         """
         Export the queryset of objects as concatenated YAML documents.
@@ -182,35 +177,6 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
 
         return "---\n".join(yaml_data)
 
-    def queryset_to_csv(self):
-        """
-        Export the queryset of objects as comma-separated value (CSV), using the model's to_csv() method.
-        """
-        csv_data = []
-        custom_field_keys = []
-
-        # Start with the column headers
-        headers = self.queryset.model.csv_headers.copy()
-
-        # Add custom field headers, if any
-        if hasattr(self.queryset.model, "_custom_field_data"):
-            for custom_field in CustomField.objects.get_for_model(self.queryset.model):
-                headers.append(custom_field.add_prefix_to_cf_key())
-                custom_field_keys.append(custom_field.key)
-
-        csv_data.append(",".join(headers))
-
-        # Iterate through the queryset appending each object
-        for obj in self.queryset:
-            data = obj.to_csv()
-
-            for custom_field_key in custom_field_keys:
-                data += (obj.cf.get(custom_field_key, ""),)
-
-            csv_data.append(csv_format(data))
-
-        return "\n".join(csv_data)
-
     def validate_action_buttons(self, request):
         """Verify actions in self.action_buttons are valid view actions."""
 
@@ -286,13 +252,6 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
             response["Content-Disposition"] = f'attachment; filename="{filename}"'
             return response
 
-        # Fall back to built-in CSV formatting if export requested but no template specified
-        elif "export" in request.GET and hasattr(model, "to_csv"):
-            response = HttpResponse(self.queryset_to_csv(), content_type="text/csv")
-            filename = f"{settings.BRANDING_PREPENDED_FILENAME}{self.queryset.model._meta.verbose_name_plural}.csv"
-            response["Content-Disposition"] = f'attachment; filename="{filename}"'
-            return response
-
         # Provide a hook to tweak the queryset based on the request immediately prior to rendering the object list
         self.queryset = self.alter_queryset(request)
 
@@ -871,31 +830,31 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     Import objects in bulk (CSV format).
 
     queryset: Base queryset for the model
-    model_form: The form used to create each imported object
     table: The django-tables2 Table used to render the list of imported objects
     template_name: The name of the template
-    widget_attrs: A dict of attributes to apply to the import widget (e.g. to require a session key)
     """
 
     queryset = None
-    model_form = None
     table = None
     template_name = "generic/object_bulk_import.html"
-    widget_attrs = {}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.serializer_class = get_serializer_for_model(self.queryset.model)
+        self.fields = get_csv_form_fields_from_serializer_class(self.serializer_class)
+        self.required_field_names = [
+            field["name"]
+            for field in get_csv_form_fields_from_serializer_class(self.serializer_class)
+            if field["required"]
+        ]
 
     def _import_form(self, *args, **kwargs):
         class CSVImportForm(BootstrapMixin, Form):
-            csv_data = CSVDataField(from_form=self.model_form, widget=Textarea(attrs=self.widget_attrs))
-            csv_file = CSVFileField(from_form=self.model_form)
+            csv_data = CSVDataField(required_field_names=self.required_field_names)
+            csv_file = CSVFileField()
 
         return CSVImportForm(*args, **kwargs)
 
-    def _save_obj(self, obj_form, request):
-        """
-        Provide a hook to modify the object immediately before saving it (e.g. to encrypt secret data).
-        """
-        return obj_form.save()
-
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "add")
 
@@ -905,8 +864,8 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
             self.template_name,
             {
                 "form": self._import_form(),
-                "fields": self.model_form().fields,
-                "obj_type": self.model_form._meta.model._meta.verbose_name,
+                "fields": self.fields,
+                "obj_type": self.queryset.model._meta.verbose_name,
                 "return_url": self.get_return_url(request),
                 "active_tab": "csv-data",
             },
@@ -927,18 +886,24 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
                         field_name = "csv_file"
                     else:
                         field_name = "csv_data"
-                    headers, records = form.cleaned_data[field_name]
-                    for row, data in enumerate(records, start=1):
-                        obj_form = self.model_form(data, headers=headers)
-                        restrict_form_fields(obj_form, request.user)
-
-                        if obj_form.is_valid():
-                            obj = self._save_obj(obj_form, request)
-                            new_objs.append(obj)
+                    csvtext = form.cleaned_data[field_name]
+
+                    try:
+                        data = NautobotCSVParser().parse(
+                            stream=BytesIO(csvtext.encode("utf-8")),
+                            parser_context={"request": request, "serializer_class": self.serializer_class},
+                        )
+                        serializer = self.serializer_class(data=data, context={"request": request}, many=True)
+                        if serializer.is_valid():
+                            new_objs = serializer.save()
                         else:
-                            for field, err in obj_form.errors.items():
-                                form.add_error(field_name, f"Row {row} {field}: {err[0]}")
+                            for row, errors in enumerate(serializer.errors, start=1):
+                                for field, err in errors.items():
+                                    form.add_error(field_name, f"Row {row}: {field}: {err[0]}")
                             raise ValidationError("")
+                    except ParseError as exc:
+                        form.add_error(None, str(exc))
+                        raise ValidationError("")
 
                     # Enforce object-level permissions
                     if self.queryset.filter(pk__in=[obj.pk for obj in new_objs]).count() != len(new_objs):
@@ -977,8 +942,8 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
             self.template_name,
             {
                 "form": form,
-                "fields": self.model_form().fields,
-                "obj_type": self.model_form._meta.model._meta.verbose_name,
+                "fields": self.fields,
+                "obj_type": self.queryset.model._meta.verbose_name,
                 "return_url": self.get_return_url(request),
                 "active_tab": "csv-file" if form.has_error("csv_file") else "csv-data",
             },

nautobot/core/views/mixins.py

@@ -1,3 +1,4 @@
+from io import BytesIO
 import logging
 
 from django.contrib import messages
@@ -11,7 +12,7 @@ from django.core.exceptions import (
 )
 from django.db import transaction
 from django.db.models import ManyToManyField, ProtectedError
-from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput, Textarea
+from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, redirect
 from django.template.loader import select_template, TemplateDoesNotExist
@@ -29,7 +30,8 @@ from rest_framework.viewsets import GenericViewSet
 
 from drf_spectacular.utils import extend_schema
 
-from nautobot.core.api.views import BulkCreateModelMixin, BulkDestroyModelMixin, BulkUpdateModelMixin
+from nautobot.core.api.parsers import NautobotCSVParser
+from nautobot.core.api.views import BulkDestroyModelMixin, BulkUpdateModelMixin
 from nautobot.core.forms import (
     BootstrapMixin,
     ConfirmationForm,
@@ -40,8 +42,12 @@ from nautobot.core.forms import (
 from nautobot.core.utils import lookup, permissions
 from nautobot.core.views.renderers import NautobotHTMLRenderer
 from nautobot.core.utils.requests import get_filterable_params_from_filter_params
-from nautobot.core.views.utils import csv_format, handle_protectederror, prepare_cloned_fields
-from nautobot.extras.models import CustomField, ExportTemplate
+from nautobot.core.views.utils import (
+    get_csv_form_fields_from_serializer_class,
+    handle_protectederror,
+    prepare_cloned_fields,
+)
+from nautobot.extras.models import ExportTemplate
 from nautobot.extras.forms import NoteForm
 from nautobot.extras.tables import ObjectChangeTable, NoteTable
 from nautobot.extras.utils import remove_prefix_from_cf_key
@@ -179,8 +185,12 @@ class GetReturnURLMixin:
         # Note that the use of both `obj.present_in_database` and `obj.pk` is correct here because this conditional
         # handles all three of the create, update, and delete operations. When Django deletes an instance
         # from the DB, it sets the instance's PK field to None, regardless of the use of a UUID.
-        if obj is not None and obj.present_in_database and obj.pk and hasattr(obj, "get_absolute_url"):
-            return obj.get_absolute_url()
+        try:
+            if obj is not None and obj.present_in_database and obj.pk:
+                return obj.get_absolute_url()
+        except AttributeError:
+            # Model has no get_absolute_url() method or no reverse match
+            pass
 
         # Fall back to the default URL (if specified) for the view.
         if self.default_return_url is not None:
@@ -205,7 +215,6 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
 
     renderer_classes = [NautobotHTMLRenderer]
     logger = logging.getLogger(__name__)
-    lookup_field = "slug"
     # Attributes that need to be specified: form_class, queryset, serializer_class, table_class for most mixins.
     # filterset and filter_params will be initialized in filter_queryset() in ObjectListViewMixin
     filter_params = None
@@ -522,12 +531,15 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
         if self.action in ["create", "update"]:
             form_class = getattr(self, "form_class", None)
         elif self.action == "bulk_create":
+            required_field_names = [
+                field["name"]
+                for field in get_csv_form_fields_from_serializer_class(self.serializer_class)
+                if field["required"]
+            ]
 
             class BulkCreateForm(BootstrapMixin, Form):
-                csv_data = CSVDataField(
-                    from_form=self.bulk_create_form_class, widget=Textarea(attrs=self.bulk_create_widget_attrs)
-                )
-                csv_file = CSVFileField(from_form=self.bulk_create_form_class)
+                csv_data = CSVDataField(required_field_names=required_field_names)
+                csv_file = CSVFileField()
 
             form_class = BulkCreateForm
         else:
@@ -566,6 +578,17 @@ class ObjectDetailViewMixin(NautobotViewSetMixin, mixins.RetrieveModelMixin):
     UI mixin to retrieve a model instance.
     """
 
+    def retrieve(self, request, *args, **kwargs):
+        """
+        Retrieve a model instance.
+        """
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+
+        context = serializer.data
+        context["use_new_ui"] = True
+        return Response(context)
+
 
 class ObjectListViewMixin(NautobotViewSetMixin, mixins.ListModelMixin):
     """
@@ -622,13 +645,6 @@ class ObjectListViewMixin(NautobotViewSetMixin, mixins.ListModelMixin):
             response["Content-Disposition"] = f'attachment; filename="{filename}"'
             return response
 
-        # Fall back to built-in CSV formatting if export requested but no template specified
-        elif "export" in request.GET and hasattr(model, "to_csv"):
-            response = HttpResponse(self.queryset_to_csv(), content_type="text/csv")
-            filename = f"nautobot_{queryset.model._meta.verbose_name_plural}.csv"
-            response["Content-Disposition"] = f'attachment; filename="{filename}"'
-            return response
-
         return None
 
     def queryset_to_yaml(self):
@@ -640,40 +656,11 @@ class ObjectListViewMixin(NautobotViewSetMixin, mixins.ListModelMixin):
 
         return "---\n".join(yaml_data)
 
-    def queryset_to_csv(self):
-        """
-        Export the queryset of objects as comma-separated value (CSV), using the model's to_csv() method.
-        """
-        queryset = self.filter_queryset(self.get_queryset())
-        csv_data = []
-        custom_fields = []
-        # Start with the column headers
-        headers = queryset.model.csv_headers.copy()
-
-        # Add custom field headers, if any
-        if hasattr(queryset.model, "_custom_field_data"):
-            for custom_field in CustomField.objects.get_for_model(queryset.model):
-                headers.append(custom_field.add_prefix_to_cf_key())
-                custom_fields.append(custom_field.key)
-
-        csv_data.append(",".join(headers))
-
-        # Iterate through the queryset appending each object
-        for obj in queryset:
-            data = obj.to_csv()
-
-            for custom_field in custom_fields:
-                data += (obj.cf.get(custom_field, ""),)
-
-            csv_data.append(csv_format(data))
-
-        return "\n".join(csv_data)
-
     def list(self, request, *args, **kwargs):
         """
         List the model instances.
         """
-        context = {}
+        context = {"use_new_ui": True}
         if "export" in request.GET:
             queryset = self.get_queryset()
             model = queryset.model
@@ -895,14 +882,12 @@ class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin):
         return Response(data)
 
 
-class ObjectBulkCreateViewMixin(NautobotViewSetMixin, BulkCreateModelMixin):
+class ObjectBulkCreateViewMixin(NautobotViewSetMixin):
     """
     UI mixin to bulk create model instances.
     """
 
     bulk_create_active_tab = "csv-data"
-    bulk_create_form_class = None
-    bulk_create_widget_attrs = {}
 
     def _process_bulk_create_form(self, form):
         # Iterate through CSV data and bind each row to a new model form instance.
@@ -918,18 +903,24 @@ class ObjectBulkCreateViewMixin(NautobotViewSetMixin, BulkCreateModelMixin):
                 self.bulk_create_active_tab = "csv-file"
             else:
                 field_name = "csv_data"
-            headers, records = form.cleaned_data[field_name]
-            for row, data in enumerate(records, start=1):
-                obj_form = self.bulk_create_form_class(data, headers=headers)
-                restrict_form_fields(obj_form, request.user)
-
-                if obj_form.is_valid():
-                    obj = self.form_save(obj_form)
-                    new_objs.append(obj)
+
+            csvtext = form.cleaned_data[field_name]
+            try:
+                data = NautobotCSVParser().parse(
+                    stream=BytesIO(csvtext.encode("utf-8")),
+                    parser_context={"request": request, "serializer_class": self.serializer_class},
+                )
+                serializer = self.serializer_class(data=data, context={"request": request}, many=True)
+                if serializer.is_valid():
+                    new_objs = serializer.save()
                 else:
-                    for field, err in obj_form.errors.items():
-                        form.add_error(field_name, f"Row {row} {field}: {err[0]}")
+                    for row, errors in enumerate(serializer.errors, start=1):
+                        for field, err in errors.items():
+                            form.add_error(field_name, f"Row {row}: {field}: {err[0]}")
                     raise ValidationError("")
+            except exceptions.ParseError as exc:
+                form.add_error(None, str(exc))
+                raise ValidationError("")
 
             # Enforce object-level permissions
             if queryset.filter(pk__in=[obj.pk for obj in new_objs]).count() != len(new_objs):

nautobot/core/views/renderers.py

@@ -19,8 +19,8 @@ from nautobot.core.utils.requests import (
     normalize_querydict,
 )
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
-from nautobot.core.views.utils import check_filter_for_display
-from nautobot.extras.models.change_logging import ChangeLoggedModel, ObjectChange
+from nautobot.core.views.utils import check_filter_for_display, get_csv_form_fields_from_serializer_class
+from nautobot.extras.models.change_logging import ObjectChange
 from nautobot.extras.utils import get_base_template
 
 
@@ -136,7 +136,6 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         form = None
         table = None
         search_form = None
-        changelog_url = None
         instance = None
         filter_form = None
         queryset = view.alter_queryset(request)
@@ -146,8 +145,6 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         if view.action in ["create", "retrieve", "update", "destroy", "changelog", "notes"]:
             instance = view.get_object()
             return_url = view.get_return_url(request, instance)
-            if isinstance(instance, ChangeLoggedModel):
-                changelog_url = instance.get_changelog_url()
         else:
             return_url = view.get_return_url(request)
         # Get form for context rendering according to view.action unless it is previously set.
@@ -208,7 +205,6 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
                 table = self.construct_table(view, object=instance, content_type=content_type)
 
         context = {
-            "changelog_url": changelog_url,  # NOTE: This context key is deprecated in favor of `object.get_changelog_url`.
             "content_type": content_type,
             "form": form,
             "filter_form": filter_form,
@@ -249,7 +245,7 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
                 context.update(
                     {
                         "active_tab": view.bulk_create_active_tab if view.bulk_create_active_tab else "csv-data",
-                        "fields": view.bulk_create_form_class(model).fields if view.bulk_create_form_class else None,
+                        "fields": get_csv_form_fields_from_serializer_class(view.serializer_class),
                     }
                 )
             elif view.action in ["changelog", "notes"]:
@@ -270,4 +266,7 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         # Get the corresponding template based on self.action in view.get_template_name() unless it is already specified in the Response() data.
         # See form_valid() for self.action == "bulk_create".
         self.template = data.get("template", view.get_template_name())
+
+        # NautobotUIViewSets pass "use_new_ui" in context as they share the same class and are just different methods
+        self.use_new_ui = data.get("use_new_ui", False)
         return super().render(data, accepted_media_type=accepted_media_type, renderer_context=renderer_context)

nautobot/core/views/utils.py

@@ -6,6 +6,9 @@ from django.db.models import ForeignKey
 from django.utils.html import escape
 from django.utils.safestring import mark_safe
 
+from rest_framework import serializers
+
+from nautobot.core.api.fields import ChoiceField, ContentTypeField, TimeZoneSerializerField
 from nautobot.core.models.utils import is_taggable
 from nautobot.core.utils.data import is_uuid
 from nautobot.core.utils.filtering import get_filter_field_label
@@ -56,9 +59,14 @@ def check_filter_for_display(filters, field_name, values):
     return resolved_filter
 
 
+# 2.2 TODO: remove this method as it's no longer used in core.
 def csv_format(data):
     """
+    Convert the given list of data to a CSV row string.
+
     Encapsulate any data which contains a comma within double quotes.
+
+    Obsolete, as CSV rendering in Nautobot core is now handled by nautobot.core.api.renderers.NautobotCSVRenderer.
     """
     csv = []
     for value in data:
@@ -85,6 +93,78 @@ def csv_format(data):
     return ",".join(csv)
 
 
+def get_csv_form_fields_from_serializer_class(serializer_class):
+    """From the given serializer class, build a list of field dicts suitable for rendering in the CSV import form."""
+    serializer = serializer_class(context={"request": None, "depth": 0})
+    fields = []
+    for field_name, field in serializer.fields.items():
+        if field.read_only:
+            continue
+        if field_name == "custom_fields":
+            from nautobot.extras.choices import CustomFieldTypeChoices
+            from nautobot.extras.models import CustomField
+
+            cfs = CustomField.objects.get_for_model(serializer_class.Meta.model)
+            for cf in cfs:
+                cf_form_field = cf.to_form_field(set_initial=False)
+                field_info = {
+                    "name": cf.add_prefix_to_cf_key(),
+                    "required": cf_form_field.required,
+                    "label": cf_form_field.label,
+                    "help_text": cf_form_field.help_text,
+                }
+                if cf.type == CustomFieldTypeChoices.TYPE_BOOLEAN:
+                    field_info["format"] = mark_safe("<code>true</code> or <code>false</code>")
+                elif cf.type == CustomFieldTypeChoices.TYPE_DATE:
+                    field_info["format"] = mark_safe("<code>YYYY-MM-DD</code>")
+                elif cf.type == CustomFieldTypeChoices.TYPE_SELECT:
+                    field_info["choices"] = {cfc.value: cfc.value for cfc in cf.custom_field_choices.all()}
+                elif cf.type == CustomFieldTypeChoices.TYPE_MULTISELECT:
+                    field_info["format"] = mark_safe('<code>"value,value"</code>')
+                    field_info["choices"] = {cfc.value: cfc.value for cfc in cf.custom_field_choices.all()}
+                fields.append(field_info)
+            continue
+
+        field_info = {
+            "name": field_name,
+            "required": field.required,
+            "label": field.label,
+            "help_text": field.help_text,
+        }
+        if isinstance(field, serializers.BooleanField):
+            field_info["format"] = mark_safe("<code>true</code> or <code>false</code>")
+        elif isinstance(field, serializers.DateField):
+            field_info["format"] = mark_safe("<code>YYYY-MM-DD</code>")
+        elif isinstance(field, TimeZoneSerializerField):
+            field_info["format"] = mark_safe(
+                '<a href="https://en.wikipedia.org/wiki/List_of_tz_database_time_zones">available options</a>'
+            )
+        elif isinstance(field, serializers.ManyRelatedField):
+            if isinstance(field.child_relation, ContentTypeField):
+                field_info["format"] = mark_safe('<code>"app_label.model,app_label.model"</code>')
+            else:
+                field_info["format"] = mark_safe('<code>"natural_key_slug,natural_key_slug"</code>')
+        elif isinstance(field, serializers.RelatedField):
+            if isinstance(field, ContentTypeField):
+                field_info["format"] = mark_safe("<code>app_label.model</code>")
+            else:
+                field_info["format"] = mark_safe("<code>natural_key_slug</code>")
+        elif isinstance(field, (serializers.ListField, serializers.MultipleChoiceField)):
+            field_info["format"] = mark_safe('<code>"value,value"</code>')
+        elif isinstance(field, (serializers.DictField, serializers.JSONField)):
+            pass  # Not trivial to specify a format as it could be a JSON dict or a comma-separated string
+
+        if isinstance(field, ChoiceField):
+            field_info["choices"] = field.choices
+
+        fields.append(field_info)
+
+    # Move all required fields to the start of the list
+    # TODO this ordering should be defined by the serializer instead...
+    fields = sorted(fields, key=lambda info: 1 if info["required"] else 2)
+    return fields
+
+
 def handle_protectederror(obj_list, request, e):
     """
     Generate a user-friendly error message in response to a ProtectedError exception.