nautobot 2.3.0b1__py3-none-any.whl → 2.3.1__py3-none-any.whl

nautobot/dcim/tests/test_filters.py

@@ -656,9 +656,15 @@ def common_test_data(cls):
     device_redundancy_groups = iter(DeviceRedundancyGroup.objects.all())
 
     module_types = (
-        ModuleType.objects.create(manufacturer=cls.manufacturers[0], model="Filter Test Module Type 1"),
-        ModuleType.objects.create(manufacturer=cls.manufacturers[1], model="Filter Test Module Type 2"),
-        ModuleType.objects.create(manufacturer=cls.manufacturers[2], model="Filter Test Module Type 3"),
+        ModuleType.objects.create(
+            manufacturer=cls.manufacturers[0], model="Filter Test Module Type 1", comments="Module Type 1"
+        ),
+        ModuleType.objects.create(
+            manufacturer=cls.manufacturers[1], model="Filter Test Module Type 2", comments="Module Type 2"
+        ),
+        ModuleType.objects.create(
+            manufacturer=cls.manufacturers[2], model="Filter Test Module Type 3", comments="Module Type 3"
+        ),
     )
 
     # Create 3 of each component template on the first two module types
@@ -898,7 +904,7 @@ class ModularDeviceComponentTestMixin(DeviceComponentTestMixin):
         )
         parent_module_bay = ModuleBay.objects.create(name="Parent module bay", position="1", parent_device=device)
         module_type = ModuleType.objects.create(
-            manufacturer=manufacturer, model=f"Test Device Filter for {model} Module Type"
+            manufacturer=manufacturer, model=f"Test Device Filter for {model} Module Type", comments="Module Type test"
         )
         module = Module.objects.create(
             module_type=module_type, parent_module_bay=parent_module_bay, status=self.module_statuses[0]
@@ -2526,7 +2532,7 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
             name="Parent module bay", position="1", parent_device=device_vc_master
         )
         module_type = ModuleType.objects.create(
-            manufacturer=manufacturer, model="Test Device Filter for Interface Module Type"
+            manufacturer=manufacturer, model="Test Device Filter for Interface Module Type", comments="Module Type test"
         )
         module = Module.objects.create(
             module_type=module_type, parent_module_bay=parent_module_bay, status=self.module_statuses[0]
@@ -2772,7 +2778,7 @@ class FrontPortTestCase(ModularDeviceComponentTestMixin, FilterTestCases.FilterT
         )
         parent_module_bay = ModuleBay.objects.create(name="Parent module bay", position="1", parent_device=device)
         module_type = ModuleType.objects.create(
-            manufacturer=manufacturer, model="Test Device Filter for FrontPort Module Type"
+            manufacturer=manufacturer, model="Test Device Filter for FrontPort Module Type", comments="Module Type test"
         )
         module = Module.objects.create(
             module_type=module_type, parent_module_bay=parent_module_bay, status=self.module_statuses[0]
@@ -3357,7 +3363,7 @@ class CableTestCase(FilterTestCases.FilterTestCase):
         )
         parent_module_bay = ModuleBay.objects.create(name="Parent module bay", position="1", parent_device=device)
         module_type = ModuleType.objects.create(
-            manufacturer=manufacturer, model="Test Device Filter for Cable Module Type"
+            manufacturer=manufacturer, model="Test Device Filter for Cable Module Type", comments="Module Type test"
         )
         module = Module.objects.create(
             module_type=module_type, parent_module_bay=parent_module_bay, status=self.module_statuses[0]
@@ -4012,6 +4018,7 @@ class ModuleTypeTestCase(FilterTestCases.FilterTestCase):
     queryset = ModuleType.objects.all()
     filterset = ModuleTypeFilterSet
     generic_filter_tests = [
+        ("comments",),
         ("manufacturer", "manufacturer__id"),
         ("manufacturer", "manufacturer__name"),
         ("model",),

nautobot/dcim/tests/test_forms.py

@@ -12,6 +12,8 @@ from nautobot.dcim.models import (
     Manufacturer,
     Platform,
     Rack,
+    SoftwareImageFile,
+    SoftwareVersion,
 )
 from nautobot.extras.models import Role, SecretsGroup, Status
 from nautobot.ipam.models import VLAN
@@ -43,6 +45,15 @@ class DeviceTestCase(FormTestCases.BaseFormTestCase):
         cls.manufacturer = cls.device_type.manufacturer
         cls.platform = Platform.objects.filter(manufacturer=cls.device_type.manufacturer).first()
         cls.device_role = Role.objects.get_for_model(Device).first()
+        cls.software_version_contains_no_valid_image_for_device_type = SoftwareVersion.objects.create(
+            platform=cls.platform,
+            version="New version 1.0.0",
+            status=Status.objects.get_for_model(SoftwareVersion).first(),
+        )
+        cls.software_version = SoftwareVersion.objects.first()
+        cls.software_image_files = SoftwareImageFile.objects.exclude(software_version=cls.software_version).exclude(
+            default_image=True
+        )
 
         Device.objects.create(
             name="Device 1",
@@ -134,6 +145,49 @@ class DeviceTestCase(FormTestCases.BaseFormTestCase):
         self.assertFalse(form.is_valid())
         self.assertIn("face", form.errors)
 
+    def test_no_software_image_file_specified_is_valid(self):
+        form = DeviceForm(
+            data={
+                "name": "New Device",
+                "role": self.device_role.pk,
+                "tenant": None,
+                "manufacturer": self.manufacturer.pk,
+                "device_type": self.device_type.pk,
+                "location": self.location.pk,
+                "rack": None,
+                "face": None,
+                "position": None,
+                "platform": self.platform.pk,
+                "status": self.device_status.pk,
+                "secrets_group": SecretsGroup.objects.first().pk,
+                "software_version": self.software_version_contains_no_valid_image_for_device_type.pk,
+                "software_image_files": [],
+            }
+        )
+        self.assertTrue(form.is_valid())
+
+    def test_invalid_software_image_file_specified(self):
+        form = DeviceForm(
+            data={
+                "name": "New Device",
+                "role": self.device_role.pk,
+                "tenant": None,
+                "manufacturer": self.manufacturer.pk,
+                "device_type": self.device_type.pk,
+                "location": self.location.pk,
+                "rack": None,
+                "face": None,
+                "position": None,
+                "platform": self.platform.pk,
+                "status": self.device_status.pk,
+                "secrets_group": SecretsGroup.objects.first().pk,
+                "software_version": self.software_version.pk,
+                "software_image_files": list(self.software_image_files.values_list("pk", flat=True)),
+            }
+        )
+        self.assertFalse(form.is_valid())
+        self.assertIn("software_image_files", form.errors)
+
     def test_non_racked_device_with_position(self):
         form = DeviceForm(
             data={

nautobot/dcim/tests/test_models.py

@@ -1723,11 +1723,19 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         software_version.software_image_files.all().update(default_image=False)
         self.device_type.software_image_files.set([])
         self.device.software_version = software_version
+        invalid_software_image_file = SoftwareImageFile.objects.filter(default_image=False).first()
+        invalid_software_image_file.device_types.set([])
+        self.device.software_image_files.set([invalid_software_image_file])
 
-        # No device type or default image match
+        # There is an invalid non-default software_image_file specified for the software version
+        # It is not a default image and it does not match any device type
         with self.assertRaises(ValidationError):
             self.device.validated_save()
 
+        # user should be able to specify any software version without specifying software_image_files
+        self.device.software_image_files.set([])
+        self.device.validated_save()
+
         # Default image matches
         software_image_file = software_version.software_image_files.first()
         software_image_file.default_image = True
@@ -1903,6 +1911,37 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         self.assertNotEqual(child_mtime_after_parent_rack_update_save, child_mtime_after_parent_site_update_save)
 
 
+class DeviceBayTestCase(ModelTestCases.BaseModelTestCase):
+    model = DeviceBay
+
+    def setUp(self):
+        self.devices = Device.objects.filter(device_type__subdevice_role=SubdeviceRoleChoices.ROLE_PARENT)
+        devicetype = DeviceType.objects.create(
+            manufacturer=self.devices[0].device_type.manufacturer,
+            model="TestDeviceType1",
+            u_height=0,
+            subdevice_role=SubdeviceRoleChoices.ROLE_CHILD,
+        )
+        child_device = Device.objects.create(
+            device_type=devicetype,
+            role=self.devices[0].role,
+            name="TestDevice1",
+            status=self.devices[0].status,
+            location=self.devices[0].location,
+        )
+        DeviceBay.objects.create(device=self.devices[0], name="Device Bay 1", installed_device=child_device)
+
+    def test_assigning_installed_device(self):
+        server = Device.objects.exclude(device_type__subdevice_role=SubdeviceRoleChoices.ROLE_CHILD).last()
+        bay = DeviceBay(device=self.devices[1], name="Device Bay Err", installed_device=server)
+        with self.assertRaises(ValidationError) as err:
+            bay.validated_save()
+        self.assertIn(
+            f'Cannot install device "{server}"; device-type "{server.device_type}" subdevice_role is not "child".',
+            str(err.exception),
+        )
+
+
 class DeviceTypeToSoftwareImageFileTestCase(ModelTestCases.BaseModelTestCase):
     model = DeviceTypeToSoftwareImageFile
 

nautobot/dcim/tests/test_views.py

@@ -817,6 +817,7 @@ class DeviceTypeTestCase(
         cls.bulk_edit_data = {
             "u_height": 0,
             "is_full_depth": False,
+            "comments": "changed comment",
         }
 
     def test_list_has_correct_links(self):
@@ -1196,6 +1197,7 @@ class ModuleTypeTestCase(
         ModuleType.objects.create(
             model="Test Module Type 1",
             manufacturer=manufacturers[0],
+            comments="test comment",
         )
         ModuleType.objects.create(
             model="Test Module Type 2",
@@ -1215,10 +1217,12 @@ class ModuleTypeTestCase(
             "model": "Test Module Type X",
             "part_number": "123ABC",
             "tags": [t.pk for t in Tag.objects.get_for_model(ModuleType)],
+            "comments": "test comment",
         }
 
         cls.bulk_edit_data = {
             "manufacturer": manufacturers[1].pk,
+            "comments": "changed comment",
         }
 
     def test_list_has_correct_links(self):
@@ -2080,7 +2084,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         status_active = statuses[0]
 
         # We want unique sets of software image files for each device type
-        software_image_files = list(SoftwareImageFile.objects.all()[:4])
+        software_image_files = list(SoftwareImageFile.objects.filter(default_image=False)[:4])
         software_versions = list(SoftwareVersion.objects.filter(software_image_files__isnull=False)[:2])
         software_image_files[0].software_version = software_versions[0]
         software_image_files[1].software_version = software_versions[0]
@@ -2090,6 +2094,10 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             software_image_file.save()
         devicetypes[0].software_image_files.set(software_image_files[:2])
         devicetypes[1].software_image_files.set(software_image_files[2:])
+        # Only valid software image files are those that belong to the device type or default images
+        valid_software_image_files = software_image_files[2:] + [
+            SoftwareImageFile.objects.filter(default_image=True).first()
+        ]
 
         cls.custom_fields = (
             CustomField.objects.create(
@@ -2201,7 +2209,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "cf_crash_counter": -1,
             "cr_router-id": None,
             "software_version": software_versions[1].pk,
-            "software_image_files": [f.pk for f in software_versions[0].software_image_files.all()],
+            "software_image_files": [f.pk for f in valid_software_image_files],
         }
 
         cls.bulk_edit_data = {
@@ -2359,6 +2367,19 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
                 sorted(interface_ips),
             )
 
+        with self.subTest("Assert Assigning IPAddress Without Selecting Any IPAddress Raises Exception"):
+            assign_ip_form_data["pk"] = []
+            assign_ip_request = {
+                "path": reverse("ipam:ipaddress_assign")
+                + f"?interface={self.interfaces[1].id}&return_url={device_list_url}",
+                "data": post_data(assign_ip_form_data),
+            }
+            response = self.client.post(**assign_ip_request, follow=True)
+            self.assertHttpStatus(response, 200)
+            self.assertIn(
+                "Please select at least one IP Address from the table.", response.content.decode(response.charset)
+            )
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_device_rearports(self):
         device = Device.objects.first()
@@ -4172,6 +4193,28 @@ class VirtualChassisTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "domain": "domain-x",
         }
 
+    def test_device_interfaces_count_correct(self):
+        """
+        This checks whether the other memebers' interfaces are included in the
+        interfaces tab of the master device and whether the interface count on the tab header is
+        rendered correctly.
+        """
+        self.user.is_superuser = True
+        self.user.save()
+        interface_status = Status.objects.get_for_model(Interface).first()
+        Interface.objects.create(device=self.devices[0], name="eth0", status=interface_status)
+        Interface.objects.create(device=self.devices[0], name="eth1", status=interface_status)
+        Interface.objects.create(device=self.devices[1], name="device 1 interface 1", status=interface_status)
+        Interface.objects.create(device=self.devices[1], name="device 1 interface 2", status=interface_status)
+        Interface.objects.create(device=self.devices[2], name="device 2 interface 1", status=interface_status)
+        Interface.objects.create(device=self.devices[2], name="device 2 interface 2", status=interface_status)
+        response = self.client.get(reverse("dcim:device_interfaces", kwargs={"pk": self.devices[0].pk}))
+        self.assertIn('Interfaces <span class="badge">6</span>', str(response.content))
+        self.assertIn("device 1 interface 1", str(response.content))
+        self.assertIn("device 1 interface 2", str(response.content))
+        self.assertIn("device 2 interface 1", str(response.content))
+        self.assertIn("device 2 interface 2", str(response.content))
+
     def test_device_column_visible(self):
         """
         This checks whether the device column on a device's interfaces

nautobot/dcim/views.py

@@ -1923,7 +1923,7 @@ class DeviceInterfacesView(DeviceComponentTabView):
 
     def get_extra_context(self, request, instance):
         interfaces = (
-            instance.all_interfaces.restrict(request.user, "view")
+            instance.vc_interfaces.restrict(request.user, "view")
             .prefetch_related(
                 Prefetch("ip_addresses", queryset=IPAddress.objects.restrict(request.user)),
                 Prefetch("member_interfaces", queryset=Interface.objects.restrict(request.user)),
@@ -4049,6 +4049,9 @@ class DeviceRedundancyGroupUIViewSet(NautobotUIViewSet):
             devices_table = tables.DeviceTable(devices)
             devices_table.columns.show("device_redundancy_group_priority")
             context["devices_table"] = devices_table
+            controllers = instance.controllers_sorted.restrict(request.user)
+            controllers_table = tables.ControllerTable(controllers)
+            context["controllers_table"] = controllers_table
         return context
 
 

nautobot/extras/api/serializers.py

@@ -228,7 +228,6 @@ class ContactAssociationSerializer(NautobotModelSerializer):
         fields = "__all__"
         validators = []
         extra_kwargs = {
-            "role": {"required": False},
             "contact": {"required": False},
             "team": {"required": False},
         }

nautobot/extras/api/views.py

@@ -1,5 +1,3 @@
-from datetime import timedelta
-
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.forms import ValidationError as FormsValidationError
@@ -492,59 +490,6 @@ class ImageAttachmentViewSet(ModelViewSet):
 #
 
 
-def _create_schedule(serializer, data, job_model, user, approval_required, task_queue=None):
-    """
-    This is an internal function to create a scheduled job from API data.
-    It has to handle both once-offs (i.e. of type TYPE_FUTURE) and interval
-    jobs.
-    """
-    type_ = serializer["interval"]
-    if type_ == JobExecutionType.TYPE_IMMEDIATELY:
-        time = timezone.now()
-        name = serializer.get("name") or f"{job_model.name} - {time}"
-    elif type_ == JobExecutionType.TYPE_CUSTOM:
-        time = serializer.get("start_time")  # doing .get("key", "default") returns None instead of "default"
-        if time is None:
-            # "start_time" is checked against models.ScheduledJob.earliest_possible_time()
-            # which returns timezone.now() + timedelta(seconds=15)
-            time = timezone.now() + timedelta(seconds=20)
-        name = serializer["name"]
-    else:
-        time = serializer["start_time"]
-        name = serializer["name"]
-    crontab = serializer.get("crontab", "")
-
-    celery_kwargs = {
-        "nautobot_job_profile": False,
-        "queue": task_queue,
-    }
-
-    # 2.0 TODO: To revisit this as part of a larger Jobs cleanup in 2.0.
-    #
-    # We pass in task and job_model here partly for forward/backward compatibility logic, and
-    # part fallback safety. It's mildly useful to store both the task module/class name and the JobModel
-    # FK on the ScheduledJob, as in the case where the JobModel gets deleted (and the FK becomes
-    # null) you still have a bit of context on the ScheduledJob as to what it was originally
-    # scheduled for.
-    scheduled_job = ScheduledJob(
-        name=name,
-        task=job_model.class_path,
-        job_model=job_model,
-        start_time=time,
-        description=f"Nautobot job {name} scheduled by {user} for {time}",
-        kwargs=data,
-        celery_kwargs=celery_kwargs,
-        interval=type_,
-        one_off=(type_ == JobExecutionType.TYPE_FUTURE),
-        user=user,
-        approval_required=approval_required,
-        crontab=crontab,
-        queue=task_queue,
-    )
-    scheduled_job.validated_save()
-    return scheduled_job
-
-
 class JobViewSetBase(
     NautobotAPIVersionMixin,
     # note no CreateModelMixin
@@ -744,13 +689,16 @@ class JobViewSetBase(
 
         # Try to create a ScheduledJob, or...
         if schedule_data:
-            schedule = _create_schedule(
-                schedule_data,
-                job_class.serialize_data(cleaned_data),
+            schedule = ScheduledJob.create_schedule(
                 job_model,
                 request.user,
-                approval_required,
+                name=schedule_data.get("name"),
+                start_time=schedule_data.get("start_time"),
+                interval=schedule_data.get("interval"),
+                crontab=schedule_data.get("crontab", ""),
+                approval_required=approval_required,
                 task_queue=input_serializer.validated_data.get("task_queue", None),
+                **job_class.serialize_data(cleaned_data),
             )
         else:
             schedule = None

nautobot/extras/factory.py

@@ -251,6 +251,24 @@ class MetadataTypeFactory(PrimaryModelFactory):
                 )
 
 
+def _available_field_names(metadata_type, assigned_object):
+    field_names = [field.name for field in assigned_object._meta.get_fields()]
+    # Avoid collisions, see ObjectMetadata.clean()
+    existing_metadata_scoped_fields = ObjectMetadata.objects.filter(
+        metadata_type=metadata_type,
+        assigned_object_type=ContentType.objects.get_for_model(assigned_object),
+        assigned_object_id=assigned_object.pk,
+    ).values_list("scoped_fields", flat=True)
+    for existing_scoped_fields in existing_metadata_scoped_fields:
+        if existing_scoped_fields:
+            field_names = sorted(set(field_names).difference(existing_scoped_fields))
+        else:
+            field_names = []
+            break
+
+    return field_names
+
+
 class ObjectMetadataFactory(BaseModelFactory):
     """ObjectMetadata model factory"""
 
@@ -263,7 +281,6 @@ class ObjectMetadataFactory(BaseModelFactory):
         MetadataType.objects.all(),
         allow_null=False,
     )
-    scoped_fields = factory.Faker("pylist", allowed_types=[str])
 
     @factory.lazy_attribute
     def contact(self):
@@ -308,22 +325,43 @@ class ObjectMetadataFactory(BaseModelFactory):
             raise RuntimeError(f"Unsupported metadatatype datatype {metadata_type_data_type}")
 
     @factory.lazy_attribute
-    def assigned_object_type(self):
-        while True:
-            allowed_content_types = list(self.metadata_type.content_types.values_list("pk", flat=True))
-            content_type = factory.random.randgen.choice(
-                ContentType.objects.filter(FeatureQuery("metadata").get_query(), pk__in=allowed_content_types)
-            )
+    def assigned_object(self):
+        allowed_content_types = list(self.metadata_type.content_types.all())
+        for content_type in factory.random.randgen.sample(allowed_content_types, len(allowed_content_types)):
             # It does not have a get_absolute_url attribute and is causing failure in API unittests
             if content_type.app_label == "extras" and content_type.model == "taggeditem":
                 continue
-            if content_type.model_class().objects.exists():
-                return content_type
+
+            assigned_model = content_type.model_class()
+            queryset = assigned_model.objects.all()
+
+            if not queryset.exists():
+                continue
+
+            for _ in range(10):
+                assigned_object = factory.random.randgen.choice(queryset)
+                if _available_field_names(self.metadata_type, assigned_object):
+                    return assigned_object
+
+        raise RuntimeError(f"Couldn't find any suitable instances not already covered by {self.metadata_type}")
 
     @factory.lazy_attribute
-    def assigned_object_id(self):
-        queryset = self.assigned_object_type.model_class().objects.all()
-        return factory.random.randgen.choice(queryset).pk
+    def scoped_fields(self):
+        all_field_names = [field.name for field in self.assigned_object._meta.get_fields()]
+        field_names = _available_field_names(self.metadata_type, self.assigned_object)
+        if not field_names:
+            raise RuntimeError(
+                f"All existing scoped_fields for {self.metadata_type} are covered by existing ObjectMetadata for {self.assigned_object}"
+            )
+
+        if len(field_names) < len(all_field_names):
+            minimum_fields = 1  # don't allow an empty list since that would cover all fields
+        else:
+            minimum_fields = 0
+
+        return factory.random.randgen.sample(
+            field_names, k=factory.random.randgen.randint(minimum_fields, len(field_names))
+        )
 
 
 class ObjectChangeFactory(BaseModelFactory):

nautobot/extras/filters/__init__.py

@@ -181,6 +181,7 @@ class ComputedFieldFilterSet(BaseFilterSet):
             "description": "icontains",
             "content_type__app_label": "icontains",
             "content_type__model": "icontains",
+            "grouping": "icontains",
             "template": "icontains",
             "fallback_value": "icontains",
         },
@@ -192,6 +193,7 @@ class ComputedFieldFilterSet(BaseFilterSet):
         fields = (
             "content_type",
             "key",
+            "grouping",
             "template",
             "fallback_value",
             "weight",
@@ -422,6 +424,7 @@ class CustomFieldFilterSet(BaseFilterSet):
         filter_predicates={
             "label": "icontains",
             "description": "icontains",
+            "grouping": "icontains",
         },
     )
     content_types = ContentTypeMultipleChoiceFilter(
@@ -430,7 +433,7 @@ class CustomFieldFilterSet(BaseFilterSet):
 
     class Meta:
         model = CustomField
-        fields = ["id", "content_types", "label", "required", "filter_logic", "weight"]
+        fields = ["id", "content_types", "label", "grouping", "required", "filter_logic", "weight"]
 
 
 class CustomFieldChoiceFilterSet(BaseFilterSet):

nautobot/extras/forms/base.py

@@ -26,11 +26,12 @@ __all__ = (
 
 
 class NautobotModelForm(
+    BootstrapMixin,
+    # The below must be listed *after* BootstrapMixin so that BootstrapMixin applies to their dynamic form fields
     CustomFieldModelFormMixin,
     DynamicGroupModelFormMixin,
     NoteModelFormMixin,
     RelationshipModelFormMixin,
-    BootstrapMixin,
 ):
     """
     This class exists to combine common functionality and is used to inherit from throughout the
@@ -40,9 +41,10 @@ class NautobotModelForm(
 
 
 class NautobotFilterForm(
-    ContactTeamModelFilterFormMixin,
     BootstrapMixin,
-    CustomFieldModelFilterFormMixin,  # currently must come *after* BootstrapMixin to get proper CSS classes applied
+    # The below must be listed *after* BootstrapMixin so that BootstrapMixin applies to their dynamic form fields
+    ContactTeamModelFilterFormMixin,
+    CustomFieldModelFilterFormMixin,
     RelationshipModelFilterFormMixin,
 ):
     """
@@ -53,6 +55,10 @@ class NautobotFilterForm(
 
 
 class NautobotBulkEditForm(
-    BootstrapMixin, CustomFieldModelBulkEditFormMixin, RelationshipModelBulkEditFormMixin, NoteModelBulkEditFormMixin
+    BootstrapMixin,
+    # The below must be listed *after* BootstrapMixin so that BootstrapMixin applies to their dynamic form fields
+    CustomFieldModelBulkEditFormMixin,
+    NoteModelBulkEditFormMixin,
+    RelationshipModelBulkEditFormMixin,
 ):
     """Base class for bulk-edit forms for models that support relationships, custom fields and notes."""

nautobot/extras/forms/forms.py

@@ -219,6 +219,7 @@ class ComputedFieldForm(BootstrapMixin, forms.ModelForm):
         fields = (
             "content_type",
             "label",
+            "grouping",
             "key",
             "description",
             "template",

nautobot/extras/homepage.py

@@ -7,14 +7,24 @@ def get_job_results(request):
     """Callback function to collect job history for panel."""
     return (
         JobResult.objects.filter(status__in=JobResultStatusChoices.READY_STATES)
-        .defer("result")
+        .restrict(request.user, "view")
+        .only("id", "name", "status", "date_done", "user")
         .order_by("-date_done")[:10]
     )
 
 
 def get_changelog(request):
     """Callback function to collect changelog for panel."""
-    return ObjectChange.objects.restrict(request.user, "view")[:15]
+    return ObjectChange.objects.restrict(request.user, "view").only(
+        "id",
+        "action",
+        "changed_object",
+        "changed_object_id",
+        "changed_object_type",
+        "object_repr",
+        "user_name",
+        "time",
+    )[:15]
 
 
 layout = (

nautobot/extras/jobs.py

@@ -20,7 +20,7 @@ from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.files.base import ContentFile
-from django.core.files.uploadedfile import InMemoryUploadedFile
+from django.core.files.uploadedfile import UploadedFile
 from django.core.validators import RegexValidator
 from django.db.models import Model
 from django.db.models.query import QuerySet
@@ -539,7 +539,7 @@ class BaseJob:
             elif isinstance(value, Model):
                 return_data[field_name] = value.pk
             # FileVar (Save each FileVar as a FileProxy)
-            elif isinstance(value, InMemoryUploadedFile):
+            elif isinstance(value, UploadedFile):
                 return_data[field_name] = BaseJob._save_file_to_proxy(value)
             # IPAddressVar, IPAddressWithMaskVar, IPNetworkVar
             elif isinstance(value, netaddr.ip.BaseIP):