nautobot 3.0.3__py3-none-any.whl → 3.0.4__py3-none-any.whl

nautobot/core/authentication.py

@@ -52,7 +52,6 @@ class ObjectPermissionBackend(ModelBackend):
             return user_obj.is_active and (user_obj.is_staff or user_obj.is_superuser)
 
         app_label, _action, model_name = resolve_permission(perm)
-
         if app_label == "users" and model_name == "admingroup":
             perm = perm.replace("users", "auth").replace("admingroup", "group")
 

nautobot/core/celery/schedulers.py

@@ -138,9 +138,7 @@ class NautobotDatabaseScheduler(DatabaseScheduler):
                         task_name=scheduled_job.job_model.class_path,
                         celery_kwargs=entry.options,
                     )
-                    job_result = run_kubernetes_job_and_return_job_result(
-                        job_queue, job_result, json.dumps(entry_kwargs)
-                    )
+                    job_result = run_kubernetes_job_and_return_job_result(job_result, json.dumps(entry_kwargs))
                     # Return an AsyncResult object to mimic the behavior of Celery tasks after the job is finished by Kubernetes Job Pod.
                     resp = AsyncResult(job_result.id)
                 else:

nautobot/core/cli/__init__.py

@@ -3,7 +3,9 @@ Utilities and primitives for the `nautobot-server` CLI command.
 """
 
 import argparse
+from copy import deepcopy
 import importlib.util
+import logging
 import os
 import sys
 
@@ -34,43 +36,46 @@ USAGE = """%(prog)s --help
        %(prog)s [-c CONFIG_PATH] SUBCOMMAND ..."""
 
 
-def _preprocess_settings(settings, config_path):
+logger = logging.getLogger(__name__)
+
+
+def _preprocess_settings(settings_module, config_path):
     """
     After loading nautobot_config.py and nautobot.core.settings, but before starting Django, modify the settings module.
 
-    - Set settings.SETTINGS_PATH for ease of reference
+    - Set settings_module.SETTINGS_PATH for ease of reference
     - Handle `EXTRA_*` settings
     - Create Nautobot storage directories if they don't already exist
     - Change database backends to django-prometheus if appropriate
     - Set up 'job_logs' database mirror
     - Handle our custom `STORAGE_BACKEND` setting.
-    - Load plugins based on settings.PLUGINS (potentially affecting INSTALLED_APPS, MIDDLEWARE, and CONSTANCE_CONFIG)
-    - Load event brokers based on settings.EVENT_BROKERS
+    - Load plugins based on settings_module.PLUGINS (may affect INSTALLED_APPS, MIDDLEWARE, and CONSTANCE_CONFIG)
+    - Load event brokers based on settings_module.EVENT_BROKERS
     """
-    settings.SETTINGS_PATH = config_path
+    settings_module.SETTINGS_PATH = config_path
 
     # Any setting that starts with EXTRA_ and matches a setting that is a list or tuple
     # will automatically append the values to the current setting.
     # "It might make sense to make this less magical"
     extras = {}
-    for setting in dir(settings):
+    for setting in dir(settings_module):
         if setting == setting.upper() and setting.startswith("EXTRA_"):
             base_setting = setting[6:]
-            if isinstance(getattr(settings, base_setting), (list, tuple)):
-                extras[base_setting] = getattr(settings, setting)
+            if isinstance(getattr(settings_module, base_setting), (list, tuple)):
+                extras[base_setting] = getattr(settings_module, setting)
     for base_setting, extra_values in extras.items():
-        base_value = getattr(settings, base_setting)
-        setattr(settings, base_setting, base_value + type(base_value)(extra_values))
+        base_value = getattr(settings_module, base_setting)
+        setattr(settings_module, base_setting, base_value + type(base_value)(extra_values))
 
     #
     # Storage directories
     #
-    os.makedirs(settings.GIT_ROOT, exist_ok=True)
-    os.makedirs(settings.JOBS_ROOT, exist_ok=True)
-    os.makedirs(settings.MEDIA_ROOT, exist_ok=True)
-    os.makedirs(os.path.join(settings.MEDIA_ROOT, "devicetype-images"), exist_ok=True)
-    os.makedirs(os.path.join(settings.MEDIA_ROOT, "image-attachments"), exist_ok=True)
-    os.makedirs(settings.STATIC_ROOT, exist_ok=True)
+    os.makedirs(settings_module.GIT_ROOT, exist_ok=True)
+    os.makedirs(settings_module.JOBS_ROOT, exist_ok=True)
+    os.makedirs(settings_module.MEDIA_ROOT, exist_ok=True)
+    os.makedirs(os.path.join(settings_module.MEDIA_ROOT, "devicetype-images"), exist_ok=True)
+    os.makedirs(os.path.join(settings_module.MEDIA_ROOT, "image-attachments"), exist_ok=True)
+    os.makedirs(settings_module.STATIC_ROOT, exist_ok=True)
 
     #
     # Databases
@@ -78,62 +83,99 @@ def _preprocess_settings(settings, config_path):
 
     # If metrics are enabled and postgres is the backend, set the driver to the
     # one provided by django-prometheus.
-    if settings.METRICS_ENABLED:
-        if "postgres" in settings.DATABASES["default"]["ENGINE"]:
-            settings.DATABASES["default"]["ENGINE"] = "django_prometheus.db.backends.postgresql"
-        elif "mysql" in settings.DATABASES["default"]["ENGINE"]:
-            settings.DATABASES["default"]["ENGINE"] = "django_prometheus.db.backends.mysql"
+    if settings_module.METRICS_ENABLED:
+        # Avoid modifying nautobot.core.settings.DATABASES by accident!
+        settings_module.DATABASES = deepcopy(settings_module.DATABASES)
+
+        if "postgres" in settings_module.DATABASES["default"]["ENGINE"]:
+            settings_module.DATABASES["default"]["ENGINE"] = "django_prometheus.db.backends.postgresql"
+        elif "mysql" in settings_module.DATABASES["default"]["ENGINE"]:
+            settings_module.DATABASES["default"]["ENGINE"] = "django_prometheus.db.backends.mysql"
 
     # Create secondary db connection for job logging. This still writes to the default db, but because it's a separate
     # connection, it allows allows us to "escape" from transaction.atomic() and ensure that job log entries are saved
     # to the database even when the rest of the job transaction is rolled back.
-    settings.DATABASES["job_logs"] = settings.DATABASES["default"].copy()
+    settings_module.DATABASES["job_logs"] = deepcopy(settings_module.DATABASES["default"])
     # When running unit tests, treat it as a mirror of the default test DB, not a separate test DB of its own
-    settings.DATABASES["job_logs"]["TEST"] = {"MIRROR": "default"}
+    settings_module.DATABASES["job_logs"]["TEST"] = {"MIRROR": "default"}
 
     #
     # Media storage
     #
 
-    if hasattr(settings, "JOB_FILE_IO_STORAGE"):
-        settings.STORAGES.setdefault("nautobotjobfiles", {})["BACKEND"] = settings.JOB_FILE_IO_STORAGE
+    # Avoid modifying nautobot.core.settings.STORAGES by accident!
+    settings_module.STORAGES = deepcopy(settings_module.STORAGES)
 
-    if hasattr(settings, "STORAGE_BACKEND") and settings.STORAGE_BACKEND is not None:
-        settings.STORAGES["default"]["BACKEND"] = settings.STORAGE_BACKEND
+    if hasattr(settings_module, "JOB_FILE_IO_STORAGE"):
+        settings_module.STORAGES.setdefault("nautobotjobfiles", {})["BACKEND"] = settings_module.JOB_FILE_IO_STORAGE
+
+    if hasattr(settings_module, "STORAGE_BACKEND") and settings_module.STORAGE_BACKEND is not None:
+        settings_module.STORAGES["default"]["BACKEND"] = settings_module.STORAGE_BACKEND
 
         # django-storages
-        if hasattr(settings, "STORAGE_BACKEND") and settings.STORAGE_BACKEND.startswith("storages."):
+        if hasattr(settings_module, "STORAGE_BACKEND") and settings_module.STORAGE_BACKEND.startswith("storages."):
             try:
                 import storages.utils
             except ModuleNotFoundError as e:
                 if getattr(e, "name") == "storages":
                     raise ImproperlyConfigured(
-                        f"STORAGE_BACKEND is set to {settings.STORAGE_BACKEND} but django-storages is not present. It "
-                        f"can be installed by running 'pip install django-storages'."
+                        f"STORAGE_BACKEND is set to {settings_module.STORAGE_BACKEND} but django-storages is not present. "
+                        "It can be installed by running 'pip install django-storages'."
                     )
                 raise e
 
             # Monkey-patch django-storages to fetch settings from STORAGE_CONFIG or fall back to settings
             def _setting(name, default=None):
-                if name in settings.STORAGE_CONFIG:
-                    return settings.STORAGE_CONFIG[name]
-                return getattr(settings, name, default)
+                if name in settings_module.STORAGE_CONFIG:
+                    return settings_module.STORAGE_CONFIG[name]
+                return getattr(settings_module, name, default)
 
             storages.utils.setting = _setting
 
+    # Django 4.2 will throw an exception if both:
+    # - DEFAULT_FILE_STORAGE/STATICFILES_STORAGE is set in nautobot_config.py (recommended until Nautobot v2.4.24)
+    # - STORAGES is configured in nautobot.core.settings (which it is nowadays).
+    # Unfortunately, it's not implemented as a standard system check (which we could opt out of) but is instead
+    # hard-coded, so we hack around it instead by explicitly copying any non-default *_STORAGE to STORAGES
+    # and then unsetting *_STORAGE.
+    for setting_name, storages_key, default_value in [
+        ("DEFAULT_FILE_STORAGE", "default", "django.core.files.storage.FileSystemStorage"),
+        ("STATICFILES_STORAGE", "staticfiles", "django.contrib.staticfiles.storage.StaticFilesStorage"),
+    ]:
+        if hasattr(settings_module, setting_name):
+            # Make sure we don't clobber any existing explicit configuration in STORAGES:
+            if settings_module.STORAGES[storages_key]["BACKEND"] not in (
+                default_value,  # Nautobot/Django default
+                getattr(settings_module, setting_name),  # same as explicitly set value for setting_name
+            ):
+                raise ImproperlyConfigured(
+                    f"It looks like you've configured both {setting_name} and STORAGES['{storages_key}']['BACKEND'],"
+                    "but their values do not match."
+                )
+
+            # No clobbering, but undesired, so warn the user and handle it:
+            logger.warning(
+                f"It looks like you've configured {setting_name} in {settings_module.SETTINGS_PATH}. "
+                "This setting is deprecated since Nautobot v2.4.24, and support will be removed in Nautobot v3.1. "
+                f"You should migrate to configuring STORAGES['{storages_key}']['BACKEND'] instead. Refer to "
+                "https://docs.nautobot.com/projects/core/en/stable/user-guide/administration/configuration/settings/#storages for guidance."
+            )
+            settings_module.STORAGES[storages_key]["BACKEND"] = getattr(settings_module, setting_name)
+            delattr(settings_module, setting_name)
+
     #
     # Plugins
     #
 
     # Process the plugins and manipulate the specified config settings that are
     # passed in.
-    load_plugins(settings)
+    load_plugins(settings_module)
 
     #
     # Event Broker
     #
 
-    load_event_brokers(settings.EVENT_BROKERS)
+    load_event_brokers(settings_module.EVENT_BROKERS)
 
 
 def load_settings(config_path):
@@ -144,10 +186,10 @@ def load_settings(config_path):
             "Please provide a valid --config-path path, or use 'nautobot-server init' to create a new configuration."
         )
     spec = importlib.util.spec_from_file_location("nautobot_config", config_path)
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["nautobot_config"] = module
-    spec.loader.exec_module(module)
-    _preprocess_settings(module, config_path)
+    settings_module = importlib.util.module_from_spec(spec)
+    sys.modules["nautobot_config"] = settings_module
+    spec.loader.exec_module(settings_module)
+    _preprocess_settings(settings_module, config_path)
 
 
 class _VerboseHelpFormatter(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescriptionHelpFormatter):

nautobot/core/settings.yaml

@@ -1886,8 +1886,8 @@ properties:
           For an example of using `django-storages` with AWS S3 buckets, visit the
           [django-storages with S3](../guides/s3-django-storage.md) user-guide.
 
-      The configuration parameters for the specified storage backend are defined under the
-      [`STORAGE_CONFIG`](#storage_config) setting.
+      The configuration parameters for the specified storage backend are defined under the settings
+      [`STORAGE_CONFIG`](#storage_config) (deprecated) or [`STORAGES`](#storages) (recommended).
     see_also:
       "`STORAGES`": "#storages"
     type: "string"
@@ -1895,8 +1895,16 @@ properties:
     description: "(Deprecated) Dictionary of config parameters for the storage backend configured as STORAGE_BACKEND."
     details: |-
       !!! warning
-          This setting is deprecated and will be removed in Nautobot v3.1.
-          In its place, you should set [`STORAGES["default"]["OPTIONS"]`](#storages).
+          This setting is deprecated and will be removed in Nautobot v3.1. In its place, you should set
+          [`STORAGES["default"]["OPTIONS"]` and/or `STORAGES["staticfiles"]["OPTIONS"]`](#storages).
+
+          Note that `STORAGE_CONFIG` is implemented to provide a bit of configuration "magic" that
+          `STORAGES["..."]["OPTIONS"]` does not; specifically, when `STORAGE_BACKEND` is using any module from
+          `django-storages`, if `STATICFILES_STORAGE` is also using `django-storages`, the `STORAGE_CONFIG` will be
+          automatically applied to both file storage types. When using `STORAGES` instead of `STORAGE_CONFIG`, this is
+          not automatically the case, permitting the two types to be configured independently, but also potentially
+          requiring duplicate configuration under `STORAGES["default"]["OPTIONS"]` and
+          `STORAGES["staticfiles"]["OPTIONS"]` if both types are using the same backend.
 
       The specific parameters to be used here are specific to each backend.
 

nautobot/core/tests/test_cli.py

@@ -1,4 +1,9 @@
-from nautobot.core.cli import migrate_deprecated_templates
+import importlib.util
+import os.path
+import sys
+from unittest import mock
+
+from nautobot.core.cli import _preprocess_settings, migrate_deprecated_templates
 from nautobot.core.testing import TestCase
 
 
@@ -38,3 +43,117 @@ class TestMigrateTemplates(TestCase):
         replaced_content, was_updated = migrate_deprecated_templates.replace_template_references(original_content)
         self.assertTrue(was_updated)
         self.assertEqual(replaced_content, new_content)
+
+
+@mock.patch("nautobot.core.cli.load_plugins")
+@mock.patch("nautobot.core.cli.load_event_brokers")
+class TestPreprocessSettings(TestCase):
+    """Tests for the `_preprocess_settings` function in nautobot.core.cli, as it's important to Nautobot startup."""
+
+    def load_settings_module(self):
+        # Load the testing nautobot_config.py as a self-contained module
+        config_path = os.path.join(os.path.dirname(__file__), "nautobot_config.py")
+        spec = importlib.util.spec_from_file_location("test_nautobot_config", config_path)
+        settings_module = importlib.util.module_from_spec(spec)
+        # nautobot.core.cli.load_settings would do the below, but obviously we don't want to do that here:
+        # sys.modules["nautobot_config"] = settings_module
+        spec.loader.exec_module(settings_module)
+        return settings_module, config_path
+
+    def test_basic_path(self, mock_load_event_brokers, mock_load_plugins):
+        """Basic operation of the function."""
+        settings_module, config_path = self.load_settings_module()
+
+        # Process the settings module
+        _preprocess_settings(settings_module, config_path)
+
+        # _preprocess_settings should have set SETTINGS_PATH on the module
+        self.assertEqual(settings_module.SETTINGS_PATH, config_path)
+
+        # the default test settings have no EXTRA_* settings to handle
+
+        # all media paths should exist
+        self.assertTrue(os.path.isdir(settings_module.GIT_ROOT))
+        self.assertTrue(os.path.isdir(settings_module.JOBS_ROOT))
+        self.assertTrue(os.path.isdir(settings_module.MEDIA_ROOT))
+        self.assertTrue(os.path.isdir(os.path.join(settings_module.MEDIA_ROOT, "devicetype-images")))
+        self.assertTrue(os.path.isdir(os.path.join(settings_module.MEDIA_ROOT, "image-attachments")))
+        self.assertTrue(os.path.isdir(settings_module.STATIC_ROOT))
+
+        # databases should be using the prometheus backends
+        self.assertTrue(settings_module.METRICS_ENABLED)
+        self.assertIn("django_prometheus.db.backends", settings_module.DATABASES["default"]["ENGINE"])
+
+        # job_logs database connection should exist
+        self.assertIn("job_logs", settings_module.DATABASES)
+        self.assertIn("TEST", settings_module.DATABASES["job_logs"])
+        self.assertEqual(settings_module.DATABASES["job_logs"]["TEST"], {"MIRROR": "default"})
+        for key, value in settings_module.DATABASES["default"].items():
+            if key == "TEST":
+                continue
+            self.assertEqual(value, settings_module.DATABASES["job_logs"][key])
+
+        # STORAGES should remain as default
+        self.assertEqual(
+            settings_module.STORAGES,
+            {
+                "default": {"BACKEND": "django.core.files.storage.FileSystemStorage"},
+                "staticfiles": {"BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage"},
+                "nautobotjobfiles": {"BACKEND": "db_file_storage.storage.DatabaseFileStorage"},
+            },
+        )
+
+        mock_load_plugins.assert_called_with(settings_module)
+        mock_load_event_brokers.assert_called_with(settings_module.EVENT_BROKERS)
+
+    def test_EXTRA_behavior(self, *args):
+        """Handling of special settings like EXTRA_INSTALLED_APPS and EXTRA_MIDDLEWARE."""
+        settings_module, config_path = self.load_settings_module()
+
+        # Inject EXTRA_INSTALLED_APPS and EXTRA_MIDDLEWARE to the settings module for test purposes
+        settings_module.EXTRA_INSTALLED_APPS = ["foo.bar"]
+        settings_module.EXTRA_MIDDLEWARE = ("baz.bat",)
+
+        # Process the settings module
+        _preprocess_settings(settings_module, config_path)
+
+        self.assertIn("foo.bar", settings_module.INSTALLED_APPS)
+        # more specifically:
+        self.assertEqual("foo.bar", settings_module.INSTALLED_APPS[-1])
+        self.assertIn("baz.bat", settings_module.MIDDLEWARE)
+        # more specifically:
+        self.assertEqual("baz.bat", settings_module.MIDDLEWARE[-1])
+
+    def test_legacy_storage_behavior(self, *args):
+        """Handling legacy storage settings."""
+        settings_module, config_path = self.load_settings_module()
+
+        settings_module.DEFAULT_FILE_STORAGE = "storages.some_custom_backend"
+        settings_module.JOB_FILE_IO_STORAGE = "some_custom_job_file_storage"
+        settings_module.STATICFILES_STORAGE = "some_custom_static_storage"
+        settings_module.STORAGE_BACKEND = "storages.some_custom_backend"
+        settings_module.STORAGE_CONFIG = {"MY_BACKEND_OPTION": "some_value"}
+
+        import storages.utils
+
+        original_setting = storages.utils.setting
+        del sys.modules["storages.utils"]
+        del storages.utils
+
+        try:
+            # Process the settings module
+            _preprocess_settings(settings_module, config_path)
+
+            self.assertFalse(hasattr(settings_module, "DEFAULT_FILE_STORAGE"))  # unset to avoid a Django exception
+            self.assertEqual("storages.some_custom_backend", settings_module.STORAGES["default"]["BACKEND"])
+            self.assertEqual("some_custom_job_file_storage", settings_module.STORAGES["nautobotjobfiles"]["BACKEND"])
+            self.assertFalse(hasattr(settings_module, "STATICFILES_STORAGE"))  # unset to avoid a Django exception
+            self.assertEqual("some_custom_static_storage", settings_module.STORAGES["staticfiles"]["BACKEND"])
+
+            self.assertEqual("some_value", storages.utils.setting("MY_BACKEND_OPTION"))
+        finally:
+            # Clean up the STORAGE_CONFIG monkeypatch
+            import storages.utils  # pylint: disable=reimported
+
+            storages.utils.setting = original_setting
+            self.assertIsNone(storages.utils.setting("MY_BACKEND_OPTION"))

nautobot/dcim/forms.py

@@ -4516,6 +4516,7 @@ class CableFilterForm(BootstrapMixin, StatusModelFilterFormMixin, forms.Form):
     color = forms.CharField(max_length=6, required=False, widget=ColorSelect())  # RGB color code
     device = DynamicModelMultipleChoiceField(
         queryset=Device.objects.all(),
+        to_field_name="name",
         required=False,
         label="Device",
         query_params={

nautobot/dcim/tables/devices.py

@@ -204,7 +204,7 @@ class DeviceTable(StatusTableMixin, RoleTableMixin, BaseTable):
     vc_priority = tables.Column(verbose_name="VC Priority")
     device_redundancy_group = tables.Column(linkify=True)
     device_redundancy_group_priority = tables.TemplateColumn(
-        template_code="""{% if record.device_redundancy_group %}<span class="badge badge-default">{{ record.device_redundancy_group_priority|default:'None' }}</span>{% else %}—{% endif %}"""
+        template_code="""{% if record.device_redundancy_group %}<span class="badge badge-default">{{ record.device_redundancy_group_priority|default:'None' }}</span>{% else %}<span class="text-secondary">—</span>{% endif %}"""
     )
     controller_managed_device_group = tables.Column(linkify=True, verbose_name="Device Group")
     software_version = tables.Column(linkify=True, verbose_name="Software Version")
@@ -1260,6 +1260,7 @@ class DeviceRedundancyGroupTable(BaseTable):
         fields = (
             "pk",
             "name",
+            "description",
             "status",
             "failover_strategy",
             "controller_count",

nautobot/dcim/templates/dcim/platform_create.html

@@ -6,12 +6,11 @@
 
 {% block form_fields %}
     {% render_field form.name %}
-    {% render_field form.slug %}
     {% render_field form.manufacturer %}
 
-    <div class="mb-10 d-flex justify-content-center{% if form.network_driver.errors %} has-error{% endif %}">
-        <label class="col-lg-3 col-form-label" for="id_network_driver">Network driver</label>
-        <div class="col-lg-9">
+    <div class="mb-10 d-md-flex justify-content-center{% if form.network_driver.errors %} has-error{% endif %}">
+        <label class="col-md-3 col-form-label" for="id_network_driver">Network driver</label>
+        <div class="col-md-9">
             {{ form.network_driver }}
             <span class="form-text">
                 The <a href="https://netutils.readthedocs.io/en/latest/user/lib_use_cases_lib_mapper/">normalized network driver</a> to use when interacting with devices

nautobot/extras/models/jobs.py

@@ -253,6 +253,7 @@ class Job(PrimaryModel):
     )
     objects = BaseManager.from_queryset(JobQuerySet)()
     is_data_compliance_model = False
+    is_version_controlled = False
 
     documentation_static_path = "docs/user-guide/platform-functionality/jobs/models.html"
 
@@ -533,6 +534,7 @@ class JobLogEntry(BaseModel):
 
     is_metadata_associable_model = False
     is_data_compliance_model = False
+    is_version_controlled = False
 
     documentation_static_path = "docs/user-guide/platform-functionality/jobs/models.html"
     hide_in_diff_view = True
@@ -585,6 +587,7 @@ class JobQueue(PrimaryModel):
 
     documentation_static_path = "docs/user-guide/platform-functionality/jobs/jobqueue.html"
     is_data_compliance_model = False
+    is_version_controlled = False
 
     class Meta:
         ordering = ["name"]
@@ -616,6 +619,7 @@ class JobQueueAssignment(BaseModel):
     job_queue = models.ForeignKey(JobQueue, on_delete=models.CASCADE, related_name="job_assignments")
     is_metadata_associable_model = False
     is_data_compliance_model = False
+    is_version_controlled = False
 
     class Meta:
         unique_together = ["job", "job_queue"]
@@ -695,6 +699,7 @@ class JobResult(SavedViewMixin, BaseModel, CustomFieldModel):
     documentation_static_path = "docs/user-guide/platform-functionality/jobs/models.html"
     hide_in_diff_view = True
     is_data_compliance_model = False
+    is_version_controlled = False
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -897,7 +902,7 @@ class JobResult(SavedViewMixin, BaseModel, CustomFieldModel):
         # so that `run_kubernetes_job_and_return_job_result` is not executed again and the job will be run locally.
         if job_queue.queue_type == JobQueueTypeChoices.TYPE_KUBERNETES and not synchronous:
             # TODO: make this branch aware!
-            return run_kubernetes_job_and_return_job_result(job_queue, job_result, json.dumps(job_kwargs))
+            return run_kubernetes_job_and_return_job_result(job_result, json.dumps(job_kwargs))
 
         job_celery_kwargs = {
             "nautobot_job_job_model_id": job_model.id,
@@ -1277,6 +1282,7 @@ class ScheduledJob(ApprovableModelMixin, BaseModel):
 
     documentation_static_path = "docs/user-guide/platform-functionality/jobs/job-scheduling-and-approvals.html"
     is_data_compliance_model = False
+    is_version_controlled = False
 
     def __str__(self):
         return f"{self.name}: {self.interval}"