nautobot 2.2.8__py3-none-any.whl → 2.2.9__py3-none-any.whl

nautobot/core/filters.py

@@ -7,9 +7,11 @@ from django import forms as django_forms
 from django.conf import settings
 from django.db import models
 from django.forms.utils import ErrorDict, ErrorList
+from django.utils.encoding import force_str
+from django.utils.text import capfirst
 import django_filters
 from django_filters.constants import EMPTY_VALUES
-from django_filters.utils import get_model_field, resolve_field
+from django_filters.utils import get_model_field, label_for_filter, resolve_field, verbose_lookup_expr
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema_field
 
@@ -681,6 +683,18 @@ class BaseFilterSet(django_filters.FilterSet):
                 # Of course setting the negation of the existing filter's exclude attribute handles both cases
                 new_filter.exclude = not filter_field.exclude
 
+            # If the base filter_field has a custom label, django_filters won't adjust it for the new_filter lookup,
+            # so we have to do it.
+            if filter_field.label and filter_field.label != label_for_filter(
+                cls.Meta.model, filter_field.field_name, filter_field.lookup_expr, filter_field.exclude
+            ):
+                # Lightly adjusted from label_for_filter() implementation:
+                verbose_expression = ["exclude", filter_field.label] if new_filter.exclude else [filter_field.label]
+                if isinstance(lookup_expr, str):
+                    verbose_expression.append(verbose_lookup_expr(lookup_expr))
+                verbose_expression = [force_str(part) for part in verbose_expression if part]
+                new_filter.label = capfirst(" ".join(verbose_expression))
+
             magic_filters[new_filter_name] = new_filter
 
         return magic_filters

nautobot/core/graphql/generators.py

@@ -64,8 +64,8 @@ def generate_filter_resolver(schema_type, resolver_name, field_name):
     """
     filterset_class = schema_type._meta.filterset_class
 
-    def resolve_filter(self, *args, **kwargs):
-        if not filterset_class:
+    def resolve_filter(self, info, **kwargs):
+        if not filterset_class or not kwargs:
             return getattr(self, field_name).all()
 
         # Inverse of substitution logic from get_filtering_args_from_filterset() - transform "_type" back to "type"

nautobot/core/graphql/schema.py

@@ -370,10 +370,9 @@ def extend_schema_type_relationships(schema_type, model):
     """Extend the schema type with attributes and resolvers corresponding
     to the relationships associated with this model."""
 
-    ct = ContentType.objects.get_for_model(model)
     relationships_by_side = {
-        "source": Relationship.objects.filter(source_type=ct),
-        "destination": Relationship.objects.filter(destination_type=ct),
+        "source": Relationship.objects.get_for_model_source(model),
+        "destination": Relationship.objects.get_for_model_destination(model),
     }
 
     prefix = ""

nautobot/core/jobs/__init__.py

@@ -1,3 +1,4 @@
+import codecs
 import contextlib
 from io import BytesIO
 
@@ -282,7 +283,9 @@ class ImportObjects(Job):
         if not csv_data and not csv_file:
             raise RunJobTaskFailed("Either csv_data or csv_file must be provided")
         if csv_file:
-            csv_bytes = csv_file
+            # data_encoding is utf-8 and file_encoding is utf-8-sig
+            # Bytes read from the original file are decoded according to file_encoding, and the result is encoded using data_encoding.
+            csv_bytes = codecs.EncodedFile(csv_file, "utf-8", "utf-8-sig")
         else:
             csv_bytes = BytesIO(csv_data.encode("utf-8"))
 

nautobot/core/settings.py

@@ -907,13 +907,24 @@ CELERY_TASK_TRACK_STARTED = True
 # If enabled, a `task-sent` event will be sent for every task so tasks can be tracked before they're consumed by a worker.
 CELERY_TASK_SEND_SENT_EVENT = True
 
+# How many tasks a worker is allowed to reserve for its own consumption and execution.
+# If set to zero (not recommended) a single worker can reserve all tasks even if other workers are free.
+# For short running tasks (such as webhooks) you may want to set this to a larger number to increase throughput.
+# Conversely, for long running tasks (such as SSoT or Golden-Config Jobs at scale) you may want to set this to 1
+# so that a worker executing a long-running task will not prefetch other tasks, which would block their execution
+# until the long-running task completes.
+# https://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits
+CELERY_WORKER_PREFETCH_MULTIPLIER = int(os.getenv("NAUTOBOT_CELERY_WORKER_PREFETCH_MULTIPLIER", "4"))
+
 # If enabled stdout and stderr of running jobs will be redirected to the task logger.
 CELERY_WORKER_REDIRECT_STDOUTS = is_truthy(os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS", "True"))
 
-# The log level of log messages generated by redirected job stdout and stderr. Can be one of `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL`.
+# The log level of log messages generated by redirected job stdout and stderr.
+# Can be one of `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL`.
 CELERY_WORKER_REDIRECT_STDOUTS_LEVEL = os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS_LEVEL", "WARNING")
 
-# Send task-related events so that tasks can be monitored using tools like flower. Sets the default value for the workers -E argument.
+# Send task-related events so that tasks can be monitored using tools like flower.
+# Sets the default value for the workers -E argument.
 CELERY_WORKER_SEND_TASK_EVENTS = True
 
 # Default celery queue name that will be used by workers and tasks if no queue is specified

nautobot/core/settings.yaml

@@ -426,6 +426,20 @@ properties:
     see_also:
       "`CELERY_TASK_SOFT_TIME_LIMIT`": "#celery_task_soft_time_limit"
     type: "integer"
+  CELERY_WORKER_PREFETCH_MULTIPLIER:
+    default: 4
+    description: "How many tasks a worker is allowed to reserve for its own consumption and execution."
+    details: >-
+      If set to `0` (not recommended) a single worker can reserve all tasks even if other workers are free.
+      For short running tasks (such as webhooks) you may want to set this to a larger number to increase throughput.
+      Conversely, for long-running tasks (such as SSoT or Golden-Config Jobs at scale) you may want to set this to `1`
+      so that a worker executing a long-running task will not prefetch other tasks, which would block their execution
+      until the long-running task completes.
+    environment_variable: "NAUTOBOT_CELERY_WORKER_PREFETCH_MULTIPLIER"
+    see_also:
+      "Celery documentation": "https://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits"
+    type: "integer"
+    version_added: "2.2.9"
   CELERY_WORKER_PROMETHEUS_PORTS:
     default: []
     description: "Ports for Prometheus metric HTTP server running on the celery worker(s)."

nautobot/core/templates/nautobot_config.py.j2

@@ -282,6 +282,15 @@ SECRET_KEY = os.getenv("NAUTOBOT_SECRET_KEY", "{{ secret_key }}")
 # CELERY_TASK_SOFT_TIME_LIMIT = int(os.getenv("NAUTOBOT_CELERY_TASK_SOFT_TIME_LIMIT", str(5 * 60)))
 # CELERY_TASK_TIME_LIMIT = int(os.getenv("NAUTOBOT_CELERY_TASK_TIME_LIMIT", str(10 * 60)))
 
+# How many tasks a worker is allowed to reserve for its own consumption and execution.
+# If set to zero (not recommended) a single worker can reserve all tasks even if other workers are free.
+# For short running tasks (such as webhooks) you may want to set this to a larger number to increase throughput.
+# Conversely, for long running tasks (such as SSoT or Golden-Config Jobs at scale) you may want to set this to 1
+# so that a worker executing a long-running task will not prefetch other tasks, which would block their execution
+# until the long-running task completes.
+# https://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits
+# CELERY_WORKER_PREFETCH_MULTIPLIER = int(os.getenv("NAUTOBOT_CELERY_WORKER_PREFETCH_MULTIPLIER", "4"))
+
 # Ports for prometheus metric HTTP server running on the celery worker.
 # Normally this should be set to a single port, unless you have multiple workers running on a single machine, i.e.
 # sharing the same available ports. In that case you need to specify a range of ports greater than or equal to the
@@ -294,6 +303,12 @@ SECRET_KEY = os.getenv("NAUTOBOT_SECRET_KEY", "{{ secret_key }}")
 #         int(value) for value in os.getenv("NAUTOBOT_CELERY_WORKER_PROMETHEUS_PORTS").split(",")
 #     ]
 
+# If enabled stdout and stderr of running jobs will be redirected to the task logger.
+# CELERY_WORKER_REDIRECT_STDOUTS = is_truthy(os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS", "True"))
+
+# The log level of log messages generated by redirected job stdout and stderr.
+# Can be one of `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL`.
+# CELERY_WORKER_REDIRECT_STDOUTS_LEVEL = os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS_LEVEL", "WARNING")
 
 # Number of days to retain changelog entries. Set to 0 to retain changes indefinitely. Defaults to 90 if not set here.
 #

nautobot/core/tests/integration/test_general_functionality.py

@@ -24,7 +24,7 @@ class StaticMediaFailureTestCase(SeleniumTestCase):
             reverse("graphql"),
             reverse("api_docs"),
             "/admin/",
-            "/static/docs/overview/index.html",
+            "/static/docs/index.html",
         ]
         for url in test_urls:
             with self.subTest(test_url=url):

nautobot/core/tests/test_jobs.py

@@ -1,12 +1,22 @@
 from pathlib import Path
 
 from django.contrib.contenttypes.models import ContentType
+from django.core.files.base import ContentFile
 import yaml
 
 from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
-from nautobot.dcim.models import DeviceType, Location, LocationType, Manufacturer
+from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
-from nautobot.extras.models import Contact, ContactAssociation, ExportTemplate, JobLogEntry, Role, Status
+from nautobot.extras.models import (
+    Contact,
+    ContactAssociation,
+    ExportTemplate,
+    FileProxy,
+    JobLogEntry,
+    Role,
+    Status,
+)
+from nautobot.ipam.models import Prefix
 from nautobot.users.models import ObjectPermission
 
 
@@ -204,6 +214,76 @@ class ImportObjectsTestCase(TransactionTestCase):
         )
         self.assertEqual(4, Status.objects.filter(name__startswith="test_status").count())
 
+    def test_csv_import_with_utf_8_with_bom_encoding(self):
+        """
+        A superuser running the job with a .csv file with utf_8 with bom encoding should successfully create all specified objects.
+        Test for bug fix https://github.com/nautobot/nautobot/issues/5812 and https://github.com/nautobot/nautobot/issues/5985
+        """
+
+        status = Status.objects.get(name="Active").pk
+        content = f"prefix,status\n192.168.1.1/32,{status}"
+        content = content.encode("utf-8-sig")
+        filename = "test.csv"
+        csv_file = FileProxy.objects.create(name=filename, file=ContentFile(content, name=filename))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ImportObjects",
+            content_type=ContentType.objects.get_for_model(Prefix).pk,
+            csv_file=csv_file.id,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+        self.assertEqual(
+            1, Prefix.objects.filter(status=Status.objects.get(name="Active"), prefix="192.168.1.1/32").count()
+        )
+        mfr = Manufacturer.objects.create(name="Test Cisco Manufacturer")
+        device_type = DeviceType.objects.create(
+            manufacturer=mfr,
+            model="Cisco CSR1000v",
+            u_height=0,
+        )
+        location_type = LocationType.objects.create(name="Test Location Type")
+        location_type.content_types.set([ContentType.objects.get_for_model(Device)])
+        location = Location.objects.create(
+            name="Device Location",
+            location_type=location_type,
+            status=Status.objects.get_for_model(Location).first(),
+        )
+        role = Role.objects.create(name="Device Status")
+        role.content_types.set([ContentType.objects.get_for_model(Device)])
+        content = "\n".join(
+            [
+                "serial,asset_tag,device_type,location,status,name,role",
+                f"1021C4,CA211,{device_type.pk},{location.pk},{status},Test-AC-01,{role}",
+                f"1021C5,CA212,{device_type.pk},{location.pk},{status},Test-AC-02,{role}",
+            ]
+        )
+        content = content.encode("utf-8-sig")
+        filename = "test.csv"
+        csv_file = FileProxy.objects.create(name=filename, file=ContentFile(content, name=filename))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ImportObjects",
+            content_type=ContentType.objects.get_for_model(Device).pk,
+            csv_file=csv_file.id,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+        device_1 = Device.objects.get(name="Test-AC-01")
+        device_2 = Device.objects.get(name="Test-AC-02")
+        self.assertEqual(device_1.serial, "1021C4")
+        self.assertEqual(device_2.serial, "1021C5")
+
     def test_csv_import_bad_row(self):
         """A row of incorrect data should fail validation for that object but import all others successfully if `roll_back_if_error` is False."""
         csv_data = self.csv_data.split("\n")

nautobot/core/tests/test_templatetags_netutils.py

@@ -20,15 +20,15 @@ class NautobotTemplateTagsNetutilsTest(TestCase):
                 i = 1
                 for param_name, param in signature.parameters.items():
                     template_string += f" {param_name}="
-                    if param.annotation == str:
+                    if param.annotation is str:
                         template_string += f'"{i}"'
-                    elif param.annotation == bool:
+                    elif param.annotation is bool:
                         template_string += "True"
                     elif param.annotation in (int, float):
                         template_string += str(i)
                     elif param.annotation in (list, tuple):
                         template_string += "[]"
-                    elif param.annotation == dict:
+                    elif param.annotation is dict:
                         template_string += "{}"
                     else:
                         template_string += "None"

nautobot/dcim/models/device_components.py

@@ -24,6 +24,7 @@ from nautobot.dcim.choices import (
     PowerOutletFeedLegChoices,
     PowerOutletTypeChoices,
     PowerPortTypeChoices,
+    SubdeviceRoleChoices,
 )
 from nautobot.dcim.constants import (
     NONCONNECTABLE_IFACE_TYPES,
@@ -1019,6 +1020,12 @@ class DeviceBay(ComponentModel):
                         "installed_device": f"Cannot install the specified device; device is already installed in {current_bay}"
                     }
                 )
+            if self.installed_device.device_type.subdevice_role != SubdeviceRoleChoices.ROLE_CHILD:
+                raise ValidationError(
+                    {
+                        "installed_device": f'Cannot install device "{self.installed_device}"; device-type "{self.installed_device.device_type}" subdevice_role is not "child".'
+                    }
+                )
 
     @property
     def parent(self):

nautobot/dcim/models/devices.py

@@ -1065,6 +1065,10 @@ class DeviceRedundancyGroup(PrimaryModel):
     def devices_sorted(self):
         return self.devices.order_by("device_redundancy_group_priority")
 
+    @property
+    def controllers_sorted(self):
+        return self.controllers.order_by("name")
+
     def __str__(self):
         return self.name
 

nautobot/dcim/tables/devices.py

@@ -938,17 +938,32 @@ class VirtualChassisTable(BaseTable):
 class DeviceRedundancyGroupTable(BaseTable):
     pk = ToggleColumn()
     name = tables.Column(linkify=True)
-    device_count = tables.TemplateColumn(
-        template_code=LINKED_RECORD_COUNT,
+    device_count = LinkedCountColumn(
+        viewname="dcim:device_list",
+        url_params={"device_redundancy_group": "pk"},
         verbose_name="Devices",
     )
+    controller_count = LinkedCountColumn(
+        viewname="dcim:controller_list",
+        url_params={"controller_device_redundancy_group": "pk"},
+        verbose_name="Controllers",
+    )
     secrets_group = tables.Column(linkify=True)
     tags = TagColumn(url_name="dcim:deviceredundancygroup_list")
 
     class Meta(BaseTable.Meta):
         model = DeviceRedundancyGroup
-        fields = ("pk", "name", "status", "failover_strategy", "device_count", "secrets_group", "tags")
-        default_columns = ("pk", "name", "status", "failover_strategy", "device_count")
+        fields = (
+            "pk",
+            "name",
+            "status",
+            "failover_strategy",
+            "controller_count",
+            "device_count",
+            "secrets_group",
+            "tags",
+        )
+        default_columns = ("pk", "name", "status", "failover_strategy", "controller_count", "device_count")
 
 
 #

nautobot/dcim/templates/dcim/deviceredundancygroup_retrieve.html

@@ -45,6 +45,12 @@
 {% endblock content_right_page %}
 
 {% block content_full_width_page %}
+        <div class="panel panel-default">
+            <div class="panel-heading">
+                <strong>Controllers</strong>
+            </div>
+            {% include 'responsive_table.html' with table=controllers_table %}
+        </div>
         <div class="panel panel-default">
             <div class="panel-heading">
                 <strong>Devices</strong>

nautobot/dcim/tests/test_models.py

@@ -1264,6 +1264,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

@@ -1789,6 +1789,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()

nautobot/dcim/views.py

@@ -3029,8 +3029,11 @@ class DeviceRedundancyGroupUIViewSet(NautobotUIViewSet):
     form_class = forms.DeviceRedundancyGroupForm
     queryset = (
         DeviceRedundancyGroup.objects.select_related("status")
-        .prefetch_related("devices")
-        .annotate(device_count=count_related(Device, "device_redundancy_group"))
+        .prefetch_related("controllers", "devices")
+        .annotate(
+            device_count=count_related(Device, "device_redundancy_group"),
+            controller_count=count_related(Controller, "controller_device_redundancy_group"),
+        )
     )
     serializer_class = serializers.DeviceRedundancyGroupSerializer
     table_class = tables.DeviceRedundancyGroupTable
@@ -3043,6 +3046,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/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
@@ -449,59 +447,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
@@ -701,13 +646,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/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):