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

nautobot/core/views/mixins.py

@@ -1,4 +1,5 @@
 import logging
+from typing import ClassVar, Optional
 
 from django.contrib import messages
 from django.contrib.auth.mixins import AccessMixin
@@ -22,6 +23,7 @@ from django.utils.encoding import iri_to_uri
 from django.utils.html import format_html
 from django.utils.http import url_has_allowed_host_and_scheme
 from django.views.generic.edit import FormView
+from django_filters import FilterSet
 from drf_spectacular.utils import extend_schema
 from rest_framework import exceptions, mixins
 from rest_framework.decorators import action as drf_action
@@ -29,6 +31,7 @@ from rest_framework.parsers import FormParser, MultiPartParser
 from rest_framework.response import Response
 from rest_framework.viewsets import GenericViewSet
 
+from nautobot.core import exceptions as core_exceptions
 from nautobot.core.api.views import BulkDestroyModelMixin, BulkUpdateModelMixin
 from nautobot.core.forms import (
     BootstrapMixin,
@@ -37,7 +40,8 @@ from nautobot.core.forms import (
     CSVFileField,
     restrict_form_fields,
 )
-from nautobot.core.utils import lookup, permissions
+from nautobot.core.jobs import BulkDeleteObjects, BulkEditObjects
+from nautobot.core.utils import filtering, lookup, permissions
 from nautobot.core.utils.requests import get_filterable_params_from_filter_params, normalize_querydict
 from nautobot.core.views.renderers import NautobotHTMLRenderer
 from nautobot.core.views.utils import (
@@ -48,7 +52,7 @@ from nautobot.core.views.utils import (
 )
 from nautobot.extras.context_managers import deferred_change_logging_for_bulk_operation
 from nautobot.extras.forms import NoteForm
-from nautobot.extras.models import ExportTemplate, SavedView, UserSavedViewAssociation
+from nautobot.extras.models import ExportTemplate, Job, JobResult, SavedView, UserSavedViewAssociation
 from nautobot.extras.tables import NoteTable, ObjectChangeTable
 from nautobot.extras.utils import bulk_delete_with_bulk_change_logging, get_base_template, remove_prefix_from_cf_key
 
@@ -223,7 +227,7 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
     # filterset and filter_params will be initialized in filter_queryset() in ObjectListViewMixin
     filter_params = None
     filterset = None
-    filterset_class = None
+    filterset_class: Optional[type[FilterSet]] = None
     filterset_form_class = None
     form_class = None
     create_form_class = None
@@ -473,7 +477,11 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
     def get_filter_params(self, request):
         """Helper function - take request.GET and discard any parameters that are not used for queryset filtering."""
         params = request.GET.copy()
-        filter_params = get_filterable_params_from_filter_params(params, self.non_filter_params, self.filterset_class())
+        filter_params = get_filterable_params_from_filter_params(
+            params,
+            self.non_filter_params,
+            self.filterset_class(),  # pylint: disable=not-callable  # only called if filterset_class is not None
+        )
         if params.get("saved_view") and not filter_params and not params.get("all_filters_removed"):
             return SavedView.objects.get(pk=params.get("saved_view")).config.get("filter_params", {})
         return filter_params
@@ -579,11 +587,11 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
             if self.action == "bulk_destroy":
                 queryset = self.get_queryset()
                 bulk_delete_all = bool(self.request.POST.get("_all"))
-                if bulk_delete_all:
-                    return ConfirmationForm
 
                 class BulkDestroyForm(ConfirmationForm):
-                    pk = ModelMultipleChoiceField(queryset=queryset, widget=MultipleHiddenInput)
+                    pk = ModelMultipleChoiceField(
+                        queryset=queryset, widget=MultipleHiddenInput, required=not bulk_delete_all
+                    )
 
                 return BulkDestroyForm
             else:
@@ -629,8 +637,8 @@ class ObjectListViewMixin(NautobotViewSetMixin, mixins.ListModelMixin):
     """
 
     action_buttons = ("add", "import", "export")
-    filterset_class = None
-    filterset_form_class = None
+    filterset_class: Optional[type[FilterSet]] = None
+    filterset_form_class: Optional[type[Form]] = None
     hide_hierarchy_ui = False
     non_filter_params = (
         "export",  # trigger for CSV/export-template/YAML export # 3.0 TODO: remove, irrelevant after #4746
@@ -780,7 +788,8 @@ class ObjectDestroyViewMixin(NautobotViewSetMixin, mixins.DestroyModelMixin):
             return self.perform_destroy(request, **kwargs)
         return Response(context)
 
-    def perform_destroy(self, request, **kwargs):
+    # TODO: this conflicts with DRF's DestroyModelMixin.perform_destroy(self, instance) API
+    def perform_destroy(self, request, **kwargs):  # pylint:disable=arguments-renamed
         """
         Function to validate the ObjectDeleteConfirmationForm and to delete the object.
         """
@@ -912,11 +921,13 @@ class ObjectEditViewMixin(NautobotViewSetMixin, mixins.CreateModelMixin, mixins.
             return self.form_invalid(form)
 
 
-class EditAndDeleteAllModelMixin:
+class BulkEditAndBulkDeleteModelMixin:
     """
-    UI mixin to bulk destroy all and bulk edit all model instances.
+    UI mixin to bulk destroy and bulk edit all model instances.
     """
 
+    logger = logging.getLogger(__name__)
+
     def _get_bulk_edit_delete_all_queryset(self, request):
         """
         Retrieve the queryset of model instances to be bulk-deleted or bulk-deleted, filtered based on request parameters.
@@ -934,7 +945,7 @@ class EditAndDeleteAllModelMixin:
             filterset_class = getattr(self, "filterset_class", None)
 
         if request.GET and filterset_class is not None:
-            queryset = filterset_class(request.GET, model.objects.all()).qs
+            queryset = filterset_class(request.GET, model.objects.all()).qs  # pylint: disable=not-callable
             # We take this approach because filterset.qs has already applied .distinct(),
             # and performing a .delete directly on a queryset with .distinct applied is not allowed.
             queryset = self.queryset.filter(pk__in=queryset)
@@ -942,24 +953,92 @@ class EditAndDeleteAllModelMixin:
             queryset = model.objects.all()
         return queryset
 
-    def _bulk_delete_all_context(self, request, queryset):
-        model = queryset.model
-        return {
-            "obj_type_plural": model._meta.verbose_name_plural,
-            "return_url": self.get_return_url(request),
-            "total_objs_to_delete": queryset.count(),
-            "delete_all": True,
-            "table": None,
-        }
+    def send_bulk_delete_objects_to_job(self, request, pk_list, model, delete_all):
+        """Prepare and enqueue bulk delete job."""
+        job_model = Job.objects.get_for_class_path(BulkDeleteObjects.class_path)
 
+        if filterset_class := lookup.get_filterset_for_model(model):
+            filter_query_params = normalize_querydict(request.GET, filterset=filterset_class())
+        else:
+            filter_query_params = {}
+
+        # Discarding non-filter query params
+        new_filter_query_params = {}
+
+        for key, value in filter_query_params.items():
+            try:
+                filtering.get_filterset_field(filterset_class(), key)
+                new_filter_query_params[key] = value
+            except core_exceptions.FilterSetFieldNotFound:
+                self.logger.debug(f"Query parameter `{key}` not found in `{filterset_class}`, discarding it")
+
+        filter_query_params = new_filter_query_params
+
+        job_form = BulkDeleteObjects.as_form(
+            data={
+                "pk_list": pk_list,
+                "content_type": ContentType.objects.get_for_model(model),
+                "delete_all": delete_all,
+                "filter_query_params": filter_query_params,
+            }
+        )
+        # BulkDeleteObjects job form cannot be invalid; Hence no handling of invalid case.
+        job_form.is_valid()
+        job_kwargs = BulkDeleteObjects.prepare_job_kwargs(job_form.cleaned_data)
+        job_result = JobResult.enqueue_job(
+            job_model,
+            request.user,
+            **BulkDeleteObjects.serialize_data(job_kwargs),
+        )
+        return redirect("extras:jobresult", pk=job_result.pk)
+
+    def send_bulk_edit_objects_to_job(self, request, form, model):
+        """Prepare and enqueue a bulk edit job."""
+        job_model = Job.objects.get_for_class_path(BulkEditObjects.class_path)
+        form_data = normalize_querydict(request.POST, form)
+        if filterset_class := lookup.get_filterset_for_model(model):
+            filter_query_params = normalize_querydict(request.GET, filterset=filterset_class())
+        else:
+            filter_query_params = {}
 
-class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, EditAndDeleteAllModelMixin):
+        # Discarding non-filter query params
+        new_filter_query_params = {}
+
+        for key, value in filter_query_params.items():
+            try:
+                filtering.get_filterset_field(filterset_class(), key)
+                new_filter_query_params[key] = value
+            except core_exceptions.FilterSetFieldNotFound:
+                self.logger.debug(f"Query parameter `{key}` not found in `{filterset_class}`, discarding it")
+
+        filter_query_params = new_filter_query_params
+
+        job_form = BulkEditObjects.as_form(
+            data={
+                "form_data": form_data,
+                "content_type": ContentType.objects.get_for_model(model),
+                "edit_all": request.POST.get("_all") is not None,
+                "filter_query_params": filter_query_params,
+            }
+        )
+        # NOTE: BulkEditObjects cant be invalid, so there is no need for handling invalid error
+        job_form.is_valid()
+        job_kwargs = BulkEditObjects.prepare_job_kwargs(job_form.cleaned_data)
+        job_result = JobResult.enqueue_job(
+            job_model,
+            request.user,
+            **BulkEditObjects.serialize_data(job_kwargs),
+        )
+        return redirect("extras:jobresult", pk=job_result.pk)
+
+
+class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, BulkEditAndBulkDeleteModelMixin):
     """
     UI mixin to bulk destroy model instances.
     """
 
-    bulk_destroy_form_class = None
-    filterset_class = None
+    bulk_destroy_form_class: Optional[type[Form]] = None
+    filterset_class: Optional[type[FilterSet]] = None
 
     def _process_bulk_destroy_form(self, form):
         request = self.request
@@ -992,7 +1071,8 @@ class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, Ed
         """
         return self.perform_bulk_destroy(request, **kwargs)
 
-    def perform_bulk_destroy(self, request, **kwargs):
+    # TODO: this conflicts with BulkDestroyModelMixin.perform_bulk_destroy(self, objects)
+    def perform_bulk_destroy(self, request, **kwargs):  # pylint:disable=arguments-renamed
         """
         request.POST "_delete": Function to render the user selection of objects in a table form/BulkDestroyConfirmationForm via Response that is passed to NautobotHTMLRenderer.
         request.POST "_confirm": Function to validate the table form/BulkDestroyConfirmationForm and to perform the action of bulk destroy. Render the form with errors if exceptions are raised.
@@ -1002,21 +1082,23 @@ class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, Ed
         data = {}
         # Are we deleting *all* objects in the queryset or just a selected subset?
         if delete_all:
+            self.pk_list = []
             queryset = self._get_bulk_edit_delete_all_queryset(self.request)
-            data = self._bulk_delete_all_context(request, queryset)
         else:
             self.pk_list = list(request.POST.getlist("pk"))
+            queryset = queryset.filter(pk__in=self.pk_list)
 
-        form_class = self.get_form_class(**kwargs)
         if "_confirm" in request.POST:
+            form_class = self.get_form_class(**kwargs)
             form = form_class(request.POST, initial=normalize_querydict(request.GET, form_class=form_class))
             if form.is_valid():
-                return self.form_valid(form)
+                return self.send_bulk_delete_objects_to_job(request, self.pk_list, queryset.model, delete_all)
             else:
                 return self.form_invalid(form)
+        table = None
         if not delete_all:
             table_class = self.get_table_class()
-            table = table_class(queryset.filter(pk__in=self.pk_list), orderable=False)
+            table = table_class(queryset, orderable=False)
             if not table.rows:
                 messages.warning(
                     request,
@@ -1024,7 +1106,13 @@ class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, Ed
                 )
                 return redirect(self.get_return_url(request))
 
-            data.update({"table": table})
+        data.update(
+            {
+                "table": table,
+                "total_objs_to_delete": queryset.count(),
+                "delete_all": delete_all,
+            }
+        )
         return Response(data)
 
 
@@ -1082,14 +1170,14 @@ class ObjectBulkCreateViewMixin(NautobotViewSetMixin):  # 3.0 TODO: remove, unus
             return self.form_invalid(form)
 
 
-class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, EditAndDeleteAllModelMixin):
+class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, BulkEditAndBulkDeleteModelMixin):
     """
     UI mixin to bulk update model instances.
     """
 
-    filterset_class = None
-    bulk_update_form_class = None
+    filterset_class: ClassVar[Optional[type[FilterSet]]] = None
 
+    # NOTE: Performing BulkEdit Objects has been moved to a system job, but the logic remains here to ensure backward compatibility.
     def _process_bulk_update_form(self, form):
         request = self.request
         queryset = self.get_queryset()
@@ -1104,7 +1192,7 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, Edit
             for field in form.fields
             if field not in form_custom_fields + form_relationships + ["pk"] + ["object_note"]
         ]
-        nullified_fields = request.POST.getlist("_nullify")
+        nullified_fields = request.POST.getlist("_nullify") or []
         with deferred_change_logging_for_bulk_operation():
             updated_objects = []
             edit_all = self.request.POST.get("_all")
@@ -1123,7 +1211,7 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, Edit
                         # This form field is used to modify a field rather than set its value directly
                         model_field = None
                     # Handle nullification
-                    if name in form.nullable_fields and name in nullified_fields:
+                    if name in form.nullable_fields and nullified_fields and name in nullified_fields:
                         if isinstance(model_field, ManyToManyField):
                             getattr(obj, name).set([])
                         else:
@@ -1137,7 +1225,7 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, Edit
                         setattr(obj, name, form.cleaned_data[name])
                 # Update custom fields
                 for field_name in form_custom_fields:
-                    if field_name in form.nullable_fields and field_name in nullified_fields:
+                    if field_name in form.nullable_fields and nullified_fields and field_name in nullified_fields:
                         obj.cf[remove_prefix_from_cf_key(field_name)] = None
                     elif form.cleaned_data.get(field_name) not in (None, "", []):
                         obj.cf[remove_prefix_from_cf_key(field_name)] = form.cleaned_data[field_name]
@@ -1200,7 +1288,7 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, Edit
             form = form_class(queryset.model, request.POST, edit_all=edit_all)
             restrict_form_fields(form, request.user)
             if form.is_valid():
-                return self.form_valid(form)
+                return self.send_bulk_edit_objects_to_job(self.request, form, queryset.model)
             else:
                 return self.form_invalid(form)
         table = None

nautobot/core/views/renderers.py

@@ -244,12 +244,11 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
                 restrict_form_fields(form, request.user)
             elif view.action == "bulk_destroy":
                 pk_list = getattr(view, "pk_list", [])
-                if pk_list:
-                    initial = {
-                        "pk": pk_list,
-                        "return_url": return_url,
-                    }
-                    form = form_class(initial=initial)
+                initial = {
+                    "pk": pk_list,
+                    "return_url": return_url,
+                }
+                form = form_class(initial=initial)
                 delete_all = request.POST.get("_all")
                 if not delete_all:
                     table = self.construct_table(view, pk_list=pk_list)
@@ -347,6 +346,7 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         # Ensure the proper inheritance of context variables is applied: the view's returned data takes priority over the viewset's get_extra_context
         context.update(view.get_extra_context(request, instance))
         context.update(self.get_template_context(data, renderer_context))
+
         return context
 
     def render(self, data, accepted_media_type=None, renderer_context=None):

nautobot/dcim/api/serializers.py

@@ -247,15 +247,15 @@ class LocationSerializer(
         # https://www.django-rest-framework.org/api-guide/validators/#optional-fields
         validators = []
 
-    def validate(self, data):
+    def validate(self, attrs):
         # Validate uniqueness of (parent, name) since we omitted the automatically created validator from Meta.
-        if data.get("parent") and data.get("name"):
+        if attrs.get("parent") and attrs.get("name"):
             validator = UniqueTogetherValidator(queryset=Location.objects.all(), fields=("parent", "name"))
-            validator(data, self)
+            validator(attrs, self)
 
-        super().validate(data)
+        super().validate(attrs)
 
-        return data
+        return attrs
 
 
 #
@@ -285,20 +285,20 @@ class RackSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
         # This prevents facility_id and rack_group from being interpreted as required fields.
         validators = []
 
-    def validate(self, data):
+    def validate(self, attrs):
         # Validate uniqueness of (rack_group, name) since we omitted the automatically-created validator above.
-        if data.get("rack_group", None):
+        if attrs.get("rack_group", None):
             validator = UniqueTogetherValidator(queryset=Rack.objects.all(), fields=("rack_group", "name"))
-            validator(data, self)
+            validator(attrs, self)
         # Validate uniqueness of (rack_group, facility_id) since we omitted the automatically-created validator above.
-        if data.get("facility_id", None) and data.get("rack_group", None):
+        if attrs.get("facility_id", None) and attrs.get("rack_group", None):
             validator = UniqueTogetherValidator(queryset=Rack.objects.all(), fields=("rack_group", "facility_id"))
-            validator(data, self)
+            validator(attrs, self)
 
         # Enforce model validation
-        super().validate(data)
+        super().validate(attrs)
 
-        return data
+        return attrs
 
 
 class RackUnitSerializer(serializers.Serializer):
@@ -369,7 +369,7 @@ class ManufacturerSerializer(NautobotModelSerializer):
         fields = "__all__"
 
 
-class DeviceFamilySerializer(NautobotModelSerializer):
+class DeviceFamilySerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
     device_type_count = serializers.IntegerField(read_only=True)
 
     class Meta:
@@ -534,14 +534,6 @@ class DeviceSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
             "vc_priority": {"label": "Virtual chassis priority"},
         }
 
-    def get_additional_detail_view_tabs(self):
-        """Add "Virtual Chassis" as a separate detail tab."""
-        tabs = super().get_additional_detail_view_tabs()
-        tabs["Virtual Chassis"] = [
-            {"Virtual Chassis": {"fields": ["virtual_chassis", "vc_position", "vc_priority"]}},
-        ]
-        return tabs
-
     def get_field_names(self, declared_fields, info):
         """
         Add a couple of special fields to the serializer.
@@ -558,20 +550,20 @@ class DeviceSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
     def get_config_context(self, obj):
         return obj.get_config_context()
 
-    def validate(self, data):
+    def validate(self, attrs):
         # Validate uniqueness of (rack, position, face) since we omitted the automatically-created validator from Meta.
-        if data.get("rack") and data.get("position") and data.get("face"):
+        if attrs.get("rack") and attrs.get("position") and attrs.get("face"):
             validator = UniqueTogetherValidator(
                 queryset=Device.objects.all(),
                 fields=("rack", "position", "face"),
                 message=f"The position and face is already occupied on this rack. {UniqueTogetherValidator.message}",
             )
-            validator(data, self)
+            validator(attrs, self)
 
         # Enforce model validation
-        super().validate(data)
+        super().validate(attrs)
 
-        return data
+        return attrs
 
 
 class DeviceNAPALMSerializer(serializers.Serializer):
@@ -644,22 +636,22 @@ class PowerPortSerializer(
 
 
 class InterfaceCommonSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
-    def validate(self, data):
+    def validate(self, attrs):
         # Validate many-to-many VLAN assignments
-        mode = data.get("mode", getattr(self.instance, "mode", None))
+        mode = attrs.get("mode", getattr(self.instance, "mode", None))
 
         if mode != InterfaceModeChoices.MODE_TAGGED:
-            if data.get("tagged_vlans"):
+            if attrs.get("tagged_vlans"):
                 raise serializers.ValidationError(
                     {
                         "tagged_vlans": f"Mode must be set to {InterfaceModeChoices.MODE_TAGGED} when specifying tagged_vlans"
                     }
                 )
 
-            if data.get("tagged_vlans") != [] and self.instance and self.instance.tagged_vlans.exists():
+            if attrs.get("tagged_vlans") != [] and self.instance and self.instance.tagged_vlans.exists():
                 raise serializers.ValidationError({"tagged_vlans": f"Clear tagged_vlans to set mode to {mode}"})
 
-        return super().validate(data)
+        return super().validate(attrs)
 
 
 class InterfaceSerializer(
@@ -671,7 +663,7 @@ class InterfaceSerializer(
     type = ChoiceField(choices=InterfaceTypeChoices)
     mode = ChoiceField(choices=InterfaceModeChoices, allow_blank=True, required=False)
     mac_address = serializers.CharField(allow_blank=True, allow_null=True, required=False)
-    ip_address_count = serializers.IntegerField(read_only=True)
+    ip_address_count = serializers.IntegerField(read_only=True, source="_ip_address_count")
 
     class Meta:
         model = Interface
@@ -760,18 +752,18 @@ class InventoryItemSerializer(TaggedModelSerializerMixin, TreeModelSerializerMix
         # https://www.django-rest-framework.org/api-guide/validators/#optional-fields
         validators = []
 
-    def validate(self, data):
+    def validate(self, attrs):
         # Validate uniqueness of (device, parent, name) since we omitted the automatically created validator from Meta.
-        if data.get("device") and data.get("parent") and data.get("name"):
+        if attrs.get("device") and attrs.get("parent") and attrs.get("name"):
             validator = UniqueTogetherValidator(
                 queryset=InventoryItem.objects.all(),
                 fields=("device", "parent", "name"),
             )
-            validator(data, self)
+            validator(attrs, self)
 
-        super().validate(data)
+        super().validate(attrs)
 
-        return data
+        return attrs
 
 
 #
@@ -989,7 +981,7 @@ class DeviceTypeToSoftwareImageFileSerializer(ValidatedModelSerializer):
 
 class ControllerSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
     capabilities = serializers.ListField(
-        child=ChoiceField(choices=ControllerCapabilitiesChoices, required=False), allow_empty=True
+        child=ChoiceField(choices=ControllerCapabilitiesChoices, required=False), allow_empty=True, required=False
     )
 
     class Meta:
@@ -999,7 +991,7 @@ class ControllerSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
 
 class ControllerManagedDeviceGroupSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
     capabilities = serializers.ListField(
-        child=ChoiceField(choices=ControllerCapabilitiesChoices, required=False), allow_empty=True
+        child=ChoiceField(choices=ControllerCapabilitiesChoices, required=False), allow_empty=True, required=False
     )
 
     class Meta:
@@ -1018,21 +1010,21 @@ class ModuleBaySerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
         fields = "__all__"
         validators = []
 
-    def validate(self, data):
+    def validate(self, attrs):
         """Validate device and module field constraints for module bay."""
-        if data.get("parent_device") and data.get("parent_module"):
+        if attrs.get("parent_device") and attrs.get("parent_module"):
             raise serializers.ValidationError("Only one of parent_device or parent_module must be set")
-        if data.get("parent_device"):
+        if attrs.get("parent_device"):
             validator = UniqueTogetherValidator(
                 queryset=self.Meta.model.objects.all(), fields=("parent_device", "name")
             )
-            validator(data, self)
-        if data.get("parent_module"):
+            validator(attrs, self)
+        if attrs.get("parent_module"):
             validator = UniqueTogetherValidator(
                 queryset=self.Meta.model.objects.all(), fields=("parent_module", "name")
             )
-            validator(data, self)
-        return super().validate(data)
+            validator(attrs, self)
+        return super().validate(attrs)
 
 
 class ModuleBayTemplateSerializer(NautobotModelSerializer):
@@ -1041,17 +1033,17 @@ class ModuleBayTemplateSerializer(NautobotModelSerializer):
         fields = "__all__"
         validators = []
 
-    def validate(self, data):
+    def validate(self, attrs):
         """Validate device_type and module_type field constraints for module bay template."""
-        if data.get("device_type") and data.get("module_type"):
+        if attrs.get("device_type") and attrs.get("module_type"):
             raise serializers.ValidationError("Only one of device_type or module_type must be set")
-        if data.get("device_type"):
+        if attrs.get("device_type"):
             validator = UniqueTogetherValidator(queryset=self.Meta.model.objects.all(), fields=("device_type", "name"))
-            validator(data, self)
-        if data.get("module_type"):
+            validator(attrs, self)
+        if attrs.get("module_type"):
             validator = UniqueTogetherValidator(queryset=self.Meta.model.objects.all(), fields=("module_type", "name"))
-            validator(data, self)
-        return super().validate(data)
+            validator(attrs, self)
+        return super().validate(attrs)
 
 
 class ModuleSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
@@ -1061,17 +1053,17 @@ class ModuleSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
 
         validators = []
 
-    def validate(self, data):
+    def validate(self, attrs):
         """Validate asset_Tag, serial, parent_module_bay and location field constraints for module."""
-        if data.get("parent_module_bay") and data.get("location"):
+        if attrs.get("parent_module_bay") and attrs.get("location"):
             raise serializers.ValidationError("Only one of parent_module_bay or location must be set")
-        if data.get("serial"):
+        if attrs.get("serial"):
             validator = UniqueTogetherValidator(queryset=Module.objects.all(), fields=("module_type", "serial"))
-            validator(data, self)
-        if data.get("asset_tag"):
+            validator(attrs, self)
+        if attrs.get("asset_tag"):
             validator = UniqueValidator(queryset=Module.objects.all())
-            validator(data["asset_tag"], self.fields["asset_tag"])
-        return super().validate(data)
+            validator(attrs["asset_tag"], self.fields["asset_tag"])
+        return super().validate(attrs)
 
 
 class ModuleTypeSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
@@ -1080,16 +1072,16 @@ class ModuleTypeSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
         fields = "__all__"
 
 
-class VirtualDeviceContextSerializer(NautobotModelSerializer):
+class VirtualDeviceContextSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
     class Meta:
         model = VirtualDeviceContext
         fields = "__all__"
 
-    def validate(self, data):
+    def validate(self, attrs):
         """Validate device cannot be changed for VirtualDeviceContext."""
-        if data.get("device") and self.instance and self.instance.device != data.get("device"):
+        if attrs.get("device") and self.instance and self.instance.device != attrs.get("device"):
             raise serializers.ValidationError("Changing the device of a VirtualDeviceContext is not allowed.")
-        return super().validate(data)
+        return super().validate(attrs)
 
 
 class InterfaceVDCAssignmentSerializer(ValidatedModelSerializer):