nautobot 2.4.4__py3-none-any.whl → 2.4.6__py3-none-any.whl

nautobot/__init__.py

@@ -14,18 +14,34 @@ __initialized = False
 
 def add_success_logger():
     """Add a custom log level for success messages."""
-    SUCCESS = 25
+    SUCCESS = 25  # between INFO and WARNING
     logging.addLevelName(SUCCESS, "SUCCESS")
 
-    def success(self, message, *args, **kws):
+    def success(self, message, *args, **kwargs):
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 1) + 1  # so that funcName is the caller function, not "success"
         if self.isEnabledFor(SUCCESS):
-            self._log(SUCCESS, message, args, **kws)
+            self._log(SUCCESS, message, args, **kwargs)
 
     logging.Logger.success = success
     return success
 
 
+def add_failure_logger():
+    """Add a custom log level for failure messages less severe than an ERROR."""
+    FAILURE = 35  # between WARNING and ERROR
+    logging.addLevelName(FAILURE, "FAILURE")
+
+    def failure(self, message, *args, **kwargs):
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 1) + 1  # so that funcName is the caller function, not "failure"
+        if self.isEnabledFor(FAILURE):
+            self._log(FAILURE, message, args, **kwargs)
+
+    logging.Logger.failure = failure
+    return failure
+
+
 add_success_logger()
+add_failure_logger()
 logger = logging.getLogger(__name__)
 
 

nautobot/core/api/mixins.py

@@ -109,6 +109,16 @@ class WritableSerializerMixin:
             queryset = self.queryset
         else:
             queryset = self.Meta.model.objects
+
+        # Apply user permission on related objects
+        if (
+            "request" in self.context
+            and self.context["request"]
+            and self.context["request"].user
+            and hasattr(queryset, "restrict")
+        ):
+            queryset = queryset.restrict(self.context["request"].user, "view")
+
         if isinstance(data, list):
             return [self.get_object(data=entry, queryset=queryset) for entry in data]
         return self.get_object(data=data, queryset=queryset)

nautobot/core/celery/__init__.py

@@ -14,7 +14,7 @@ from django.utils.module_loading import import_string
 from kombu.serialization import register
 from prometheus_client import CollectorRegistry, multiprocess, start_http_server
 
-from nautobot import add_success_logger
+from nautobot import add_failure_logger, add_success_logger
 from nautobot.core.celery.control import discard_git_repository, refresh_git_repository  # noqa: F401  # unused-import
 from nautobot.core.celery.encoders import NautobotKombuJSONEncoder
 from nautobot.core.celery.log import NautobotDatabaseHandler
@@ -138,14 +138,16 @@ def add_nautobot_log_handler(logger_instance, log_format=None):
 
 @signals.after_setup_logger.connect
 def setup_nautobot_global_logging(logger, **kwargs):  # pylint: disable=redefined-outer-name
-    """Add SUCCESS log to celery global logger."""
+    """Add SUCCESS and FAILURE logs to celery global logger."""
     logger.success = add_success_logger()
+    logger.failure = add_failure_logger()
 
 
 @signals.after_setup_task_logger.connect
 def setup_nautobot_task_logging(logger, **kwargs):  # pylint: disable=redefined-outer-name
-    """Add SUCCESS log to celery task logger."""
+    """Add SUCCESS and FAILURE logs to celery task logger."""
     logger.success = add_success_logger()
+    logger.failure = add_failure_logger()
 
 
 @signals.celeryd_after_setup.connect

nautobot/core/celery/encoders.py

@@ -1,5 +1,6 @@
 import logging
 
+from django.db import models
 from rest_framework.utils.encoders import JSONEncoder
 
 logger = logging.getLogger(__name__)
@@ -26,10 +27,9 @@ class NautobotKombuJSONEncoder(JSONEncoder):
     def default(self, obj):
         # Import here to avoid django.core.exceptions.ImproperlyConfigured Error.
         # Core App is not set up yet if we import this at the top of the file.
-        from nautobot.core.models import BaseModel
         from nautobot.core.models.managers import TagsManager
 
-        if isinstance(obj, BaseModel):
+        if isinstance(obj, models.Model):
             cls = obj.__class__
             module = cls.__module__
             qual_name = ".".join([module, cls.__qualname__])  # fully qualified dotted import path

nautobot/core/forms/fields.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import re
 
 from django import forms as django_forms
@@ -11,6 +12,7 @@ from django.db.models import Q
 from django.forms.fields import BoundField, CallableChoiceIterator, InvalidJSONInput, JSONField as _JSONField
 from django.templatetags.static import static
 from django.urls import reverse
+from django.urls.exceptions import NoReverseMatch
 from django.utils.html import format_html
 import django_filters
 from netaddr import EUI
@@ -21,6 +23,8 @@ from nautobot.core.forms import widgets
 from nautobot.core.models import validators
 from nautobot.core.utils import data as data_utils, lookup
 
+logger = logging.getLogger(__name__)
+
 __all__ = (
     "CSVChoiceField",
     "CSVContentTypeField",
@@ -591,8 +595,16 @@ class DynamicModelChoiceMixin:
         widget = bound_field.field.widget
         if not widget.attrs.get("data-url"):
             route = lookup.get_route_for_model(self.queryset.model, "list", api=True)
-            data_url = reverse(route)
-            widget.attrs["data-url"] = data_url
+            try:
+                data_url = reverse(route)
+                widget.attrs["data-url"] = data_url
+            except NoReverseMatch:
+                logger.error(
+                    'API route lookup "%s" failed for model %s, form field "%s" will not work properly',
+                    route,
+                    self.queryset.model.__name__,
+                    bound_field.name,
+                )
 
         return bound_field
 
@@ -800,9 +812,13 @@ class NumericArrayField(SimpleArrayField):
     def to_python(self, value):
         try:
             if not value:
-                value = ""
-            else:
-                value = ",".join([str(n) for n in forms.parse_numeric_range(value)])
+                return []
+
+            if isinstance(value, list):
+                value = ",".join([str(n) for n in value])
+
+            value = ",".join([str(n) for n in forms.parse_numeric_range(value)])
+
         except (TypeError, ValueError) as error:
             raise ValidationError(error)
         return super().to_python(value)

nautobot/core/forms/utils.py

@@ -41,6 +41,7 @@ def parse_numeric_range(input_string, base=10):
                 raise TypeError("Input value must be a string using a range format.")
         except ValueError:
             begin, end = dash_range, dash_range
+
         begin, end = int(begin.strip(), base=base), int(end.strip(), base=base) + 1
         values.extend(range(begin, end))
     # Remove duplicates and sort

nautobot/core/jobs/__init__.py

@@ -295,8 +295,9 @@ class ImportObjects(Job):
                     validation_failed = True
             else:
                 validation_failed = True
-                for field, err in serializer.errors.items():
-                    self.logger.error("Row %d: `%s`: `%s`", row, field, err[0])
+                for field, errs in serializer.errors.items():
+                    for err in errs:
+                        self.logger.error("Row %d: `%s`: `%s`", row, field, err)
         return new_objs, validation_failed
 
     def run(self, *, content_type, csv_data=None, csv_file=None, roll_back_if_error=False):  # pylint:disable=arguments-differ

nautobot/core/jobs/bulk_actions.py

@@ -108,7 +108,7 @@ class BulkEditObjects(Job):
                         if form.cleaned_data[field_name]:
                             getattr(obj, field_name).set(form.cleaned_data[field_name])
                     # Normal fields
-                    elif form.cleaned_data[field_name] not in (None, ""):
+                    elif form.cleaned_data[field_name] not in (None, "", []):
                         setattr(obj, field_name, form.cleaned_data[field_name])
 
                 # Update custom fields

nautobot/core/management/commands/generate_test_data.py

@@ -213,6 +213,7 @@ class Command(BaseCommand):
         _create_batch(PlatformFactory, 20, description="with Manufacturers", has_manufacturer=True)
         _create_batch(PlatformFactory, 5, description="without Manufacturers", has_manufacturer=False)
         _create_batch(SoftwareVersionFactory, 20, description="to be usable by Devices")
+        _create_batch(ExternalIntegrationFactory, 20)
         _create_batch(SoftwareImageFileFactory, 25, description="to be usable by DeviceTypes")
         _create_batch(ManufacturerFactory, 4, description="without Platforms")  # 4 more hard-coded Manufacturers
         _create_batch(DeviceTypeFactory, 30)
@@ -312,7 +313,6 @@ class Command(BaseCommand):
             has_pp_info=True,
             has_description=True,
         )
-        _create_batch(ExternalIntegrationFactory, 20)
         _create_batch(ControllerFactory, 10, description="with Devices or DeviceRedundancyGroups")
         _create_batch(ControllerManagedDeviceGroupFactory, 5, description="without any Devices")
         _create_batch(SupportedDataRateFactory, 20)

nautobot/core/models/name_color_content_types.py

@@ -1,10 +1,12 @@
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
+from django.utils.html import format_html
 
 from nautobot.core.choices import ColorChoices
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.models import BaseManager, BaseModel, ContentTypeRelatedQuerySet
 from nautobot.core.models.fields import ColorField
+from nautobot.core.templatetags import helpers
 from nautobot.extras.models.change_logging import ChangeLoggedModel
 
 # Importing CustomFieldModel, ChangeLoggedModel, RelationshipModel from  nautobot.extras.models
@@ -54,3 +56,10 @@ class NameColorContentTypesModel(
 
     def get_content_types(self):
         return ",".join(f"{ct.app_label}.{ct.model}" for ct in self.content_types.all())
+
+    def get_color_display(self):
+        if self.color:
+            return format_html(
+                '<span class="label color-block" style="background-color: #{}">&nbsp;</span>', self.color
+            )
+        return helpers.placeholder(self.color)

nautobot/core/models/validators.py

@@ -27,8 +27,15 @@ class EnhancedURLValidator(URLValidator):
         r"\Z",
         re.IGNORECASE,
     )
+
     schemes = settings.ALLOWED_URL_SCHEMES
 
+    def __getattribute__(self, name):
+        """Dynamically fetch schemes each time it's accessed."""
+        if name == "schemes":
+            self.schemes = settings.ALLOWED_URL_SCHEMES  # Always return the latest list
+        return super().__getattribute__(name)
+
 
 class ExclusionValidator(BaseValidator):
     """

nautobot/core/settings.py

@@ -287,20 +287,6 @@ TEST_USE_FACTORIES = is_truthy(os.getenv("NAUTOBOT_TEST_USE_FACTORIES", "False")
 # Pseudo-random number generator seed, for reproducibility of test results.
 TEST_FACTORY_SEED = os.getenv("NAUTOBOT_TEST_FACTORY_SEED", None)
 
-#
-# django-slowtests
-#
-
-# Performance test uses `NautobotPerformanceTestRunner` to run, which is only available once you have `django-slowtests` installed in your dev environment.
-# `invoke performance-test` and adding `--performance-report` or `--performance-snapshot` at the end of the `invoke` command
-# will automatically opt to NautobotPerformanceTestRunner to run the tests.
-
-# The baseline file that the performance test is running against
-# TODO we need to replace the baselines in this file with more consistent results at least for CI
-TEST_PERFORMANCE_BASELINE_FILE = os.getenv(
-    "NAUTOBOT_TEST_PERFORMANCE_BASELINE_FILE", "nautobot/core/tests/performance_baselines.yml"
-)
-
 #
 # Django Prometheus
 #

nautobot/core/settings.yaml

@@ -1926,34 +1926,6 @@ properties:
     version_added: "1.5.0"
     see_also:
       "`TEST_USE_FACTORIES`": "#test_use_factories"
-  TEST_PERFORMANCE_BASELINE_FILE:
-    default: "nautobot/core/tests/performance_baselines.yml"
-    description: "File path of a YAML file providing baseline times for all performance-related tests."
-    details: |-
-      The YAML file should conform to the following format:
-
-      ```yaml
-      tests:
-          - name: >-
-                test_run_job_with_sensitive_variables_and_requires_approval
-                (nautobot.extras.tests.test_views.JobTestCase)
-            execution_time: 4.799533
-          - name: test_run_missing_schedule (nautobot.extras.tests.test_views.JobTestCase)
-            execution_time: 4.367563
-          - name: test_run_now_missing_args (nautobot.extras.tests.test_views.JobTestCase)
-            execution_time: 4.363194
-          - name: >-
-                test_create_object_with_constrained_permission
-                (nautobot.extras.tests.test_views.GraphQLQueriesTestCase)
-            execution_time: 3.474244
-          - name: >-
-                test_run_now_constrained_permissions
-                (nautobot.extras.tests.test_views.JobTestCase)
-            execution_time: 2.727531
-      ```
-    environment_variable: "NAUTOBOT_TEST_PERFORMANCE_BASELINE_FILE"
-    type: "string"
-    version_added: "1.5.0"
   TEST_USE_FACTORIES:
     default: false
     description: >-

nautobot/core/tables.py

@@ -493,6 +493,9 @@ class LinkedCountColumn(django_tables2.Column):
         reverse_lookup (str, optional): The reverse lookup parameter to use to derive the count.
             If not specified, the first key in `url_params` will be implicitly used as the `reverse_lookup` value.
         distinct (bool, optional): Parameter passed through to `count_related()`.
+        display_field (str, optional): Name of the field to use when displaying an object rather than just a count.
+            This will be passed to hyperlinked_object() as the `field` parameter
+            If not specified, it will use the "display" field.
         **kwargs (dict, optional): As the parent Column class.
 
     Examples:
@@ -536,6 +539,7 @@ class LinkedCountColumn(django_tables2.Column):
         reverse_lookup=None,
         distinct=False,
         default=None,
+        display_field="display",
         **kwargs,
     ):
         self.viewname = viewname
@@ -544,6 +548,7 @@ class LinkedCountColumn(django_tables2.Column):
         self.url_params = url_params
         self.reverse_lookup = reverse_lookup or next(iter(url_params.keys()))
         self.distinct = distinct
+        self.display_field = display_field
         self.model = get_model_for_view_name(self.viewname)
         super().__init__(*args, default=default, **kwargs)
 
@@ -565,7 +570,7 @@ class LinkedCountColumn(django_tables2.Column):
         if value > 1:
             return format_html('<a href="{}" class="badge">{}</a>', url, value)
         if related_record is not None:
-            return helpers.hyperlinked_object(related_record)
+            return helpers.hyperlinked_object(related_record, self.display_field)
         if value == 1:
             return format_html('<a href="{}" class="badge">{}</a>', url, value)
         return helpers.placeholder(value)

nautobot/core/templates/generic/object_retrieve.html

@@ -117,7 +117,7 @@
         {% if perms.extras.view_note %}
             {% if active_tab != 'notes' and object.get_notes_url or active_tab == 'notes' %}
                 <li role="presentation"{% if active_tab == 'notes' %} class="active"{% endif %}>
-                    <a href="{{ object.get_notes_url }}">Notes</a>
+                    <a href="{{ object.get_notes_url }}">Notes {% badge object.notes.count %}</a>
                 </li>
             {% endif %}
         {% endif %}

nautobot/core/testing/__init__.py

@@ -68,6 +68,8 @@ def run_job_for_testing(job, username="test-user", profile=False, **kwargs):
         username=username, defaults={"is_superuser": True, "password": "password"}
     )
     # Run the job synchronously in the current thread as if it were being executed by a worker
+    # TODO: in Nautobot core testing, we set `CELERY_TASK_ALWAYS_EAGER = True`, so we *could* use enqueue_job() instead,
+    #       but switching now would be a potentially breaking change for apps...
     job_result = JobResult.execute_job(
         job_model=job,
         user=user_instance,

nautobot/core/testing/api.py

@@ -702,6 +702,9 @@ class APIViewTestCases:
             else:
                 self.assertEqual(obj.key, expected_slug)
 
+        # TODO: The override_settings here is a temporary workaround for not breaking any app tests
+        # long term fix should be using appropriate object permissions instead of the blanket override
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_create_object(self):
             """
             POST a single object with permission.
@@ -738,6 +741,9 @@ class APIViewTestCases:
                     self.assertEqual(len(objectchanges), 1)
                     self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_CREATE)
 
+        # TODO: The override_settings here is a temporary workaround for not breaking any app tests
+        # long term fix should be using appropriate object permissions instead of the blanket override
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_recreate_object_csv(self):
             """CSV export an object, delete it, and recreate it via CSV import."""
             if hasattr(self, "get_deletable_object"):
@@ -801,6 +807,9 @@ class APIViewTestCases:
                         f"{field_name} should have been unchanged on delete/recreate but it differs!",
                     )
 
+        # TODO: The override_settings here is a temporary workaround for not breaking any app tests
+        # long term fix should be using appropriate object permissions instead of the blanket override
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_create_objects(self):
             """
             POST a set of objects in a single request.
@@ -853,6 +862,9 @@ class APIViewTestCases:
                 response = self.client.patch(url, update_data, format="json", **self.header)
                 self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
 
+        # TODO: The override_settings here is a temporary workaround for not breaking any app tests
+        # long term fix should be using appropriate object permissions instead of the blanket override
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_update_object(self):
             """
             PATCH a single object identified by its ID.
@@ -965,6 +977,9 @@ class APIViewTestCases:
             instance.refresh_from_db()
             self.assertInstanceEqual(instance, update_data, exclude=self.validation_excluded_fields, api=True)
 
+        # TODO: The override_settings here is a temporary workaround for not breaking any app tests
+        # long term fix should be using appropriate object permissions instead of the blanket override
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_get_put_round_trip(self):
             """GET and then PUT an object and verify that it's accepted and unchanged."""
             self.maxDiff = None
@@ -995,6 +1010,9 @@ class APIViewTestCases:
             updated_serialized_object.pop("last_updated", None)
             self.assertEqual(initial_serialized_object, updated_serialized_object)
 
+        # TODO: The override_settings here is a temporary workaround for not breaking any app tests
+        # long term fix should be using appropriate object permissions instead of the blanket override
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_update_objects(self):
             """
             PATCH a set of objects in a single request.

nautobot/core/testing/mixins.py

@@ -18,6 +18,7 @@ from nautobot.core.models import fields as core_fields
 from nautobot.core.testing import utils
 from nautobot.core.utils import permissions
 from nautobot.extras import management, models as extras_models
+from nautobot.extras.choices import JobResultStatusChoices
 from nautobot.users import models as users_models
 
 # Use the proper swappable User model
@@ -188,6 +189,14 @@ class NautobotTestCaseMixin:
                 err_message = f"{msg}\n{err_message}"
         self.assertIn(response.status_code, expected_status, err_message)
 
+    def assertJobResultStatus(self, job_result, expected_status=JobResultStatusChoices.STATUS_SUCCESS):
+        """Assert that the given job_result has the expected_status, or print the job logs to aid in debugging."""
+        self.assertEqual(
+            job_result.status,
+            expected_status,
+            (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
+        )
+
     def assertInstanceEqual(self, instance, data, exclude=None, api=False):
         """
         Compare a model instance to a dictionary, checking that its attribute values match those specified

nautobot/core/tests/nautobot_config.py

@@ -44,8 +44,6 @@ CONSTANCE_BACKEND = "constance.backends.memory.MemoryBackend"
 TEST_USE_FACTORIES = True
 # For now, use a constant PRNG seed for consistent results. In the future we can remove this for fuzzier testing.
 TEST_FACTORY_SEED = "Nautobot"
-# File in which all performance-specifc test baselines are stored
-TEST_PERFORMANCE_BASELINE_FILE = "nautobot/core/tests/performance_baselines.yml"
 
 # Make Celery run synchronously (eager), to always store eager results, and run the broker in-memory.
 # NOTE: Celery does not honor the TASK_TRACK_STARTED config when running in eager mode, so the job result is not saved until after the task completes.

nautobot/core/tests/runner.py

@@ -14,7 +14,6 @@ from django.db import connections
 from django.db.migrations.recorder import MigrationRecorder
 from django.test.runner import _init_worker, DiscoverRunner, ParallelTestSuite
 from django.test.utils import get_unique_databases_and_mirrors, NullTimeKeeper, override_settings
-import yaml
 
 from nautobot.core.celery import app, setup_nautobot_job_logging
 from nautobot.core.settings_funcs import parse_redis_connection
@@ -40,21 +39,25 @@ class NautobotParallelTestSuite(ParallelTestSuite):
 
 class NautobotTestRunner(DiscoverRunner):
     """
-    Custom test runner that excludes integration tests by default.
+    Custom test runner that excludes (slow) integration and migration tests by default.
 
     This test runner is aware of our use of the "integration" tag and only runs integration tests if
     explicitly passed in with `nautobot-server test --tag integration`.
+    Similarly, it only runs migration tests if explicitly called with `--tag migration_test`.
 
     By Nautobot convention, integration tests must be tagged with "integration". The base
     `nautobot.core.testing.integration.SeleniumTestCase` has this tag, therefore any test cases
     inheriting from that class do not need to be explicitly tagged.
 
     Only integration tests that DO NOT inherit from `SeleniumTestCase` will need to be explicitly tagged.
+
+    Similarly, the `django-test-migrations` package `MigratorTestCase` base class has the tag `migration_test`, so
+    any subclasses thereof do not need to be explicitly tagged.
     """
 
     parallel_test_suite = NautobotParallelTestSuite
 
-    exclude_tags = ["integration"]
+    exclude_tags = ["integration", "migration_test"]
 
     @classmethod
     def add_arguments(cls, parser):
@@ -75,15 +78,19 @@ class NautobotTestRunner(DiscoverRunner):
         self.cache_test_fixtures = cache_test_fixtures
         self.reusedb = reusedb
 
-        # Assert "integration" hasn't been provided w/ --tag
         incoming_tags = kwargs.get("tags") or []
-        # Assert "exclude_tags" hasn't been provided w/ --exclude-tag; else default to our own.
-        incoming_exclude_tags = kwargs.get("exclude_tags") or []
+        exclude_tags = kwargs.get("exclude_tags") or []
+
+        for default_excluded_tag in self.exclude_tags:
+            if default_excluded_tag not in incoming_tags:
+                exclude_tags.append(default_excluded_tag)
+                # Can't just use self.log() here because we haven't yet called super().__init__()
+                if logger := kwargs.get("logger"):
+                    logger.info("Implicitly excluding tests tagged %r", default_excluded_tag)
+                elif kwargs.get("verbosity", 1) >= 1:
+                    print(f"Implicitly excluding tests tagged {default_excluded_tag!r}")
 
-        # Only include our excluded tags if "integration" isn't provided w/ --tag
-        if "integration" not in incoming_tags:
-            incoming_exclude_tags.extend(self.exclude_tags)
-            kwargs["exclude_tags"] = incoming_exclude_tags
+        kwargs["exclude_tags"] = exclude_tags
 
         super().__init__(**kwargs)
 
@@ -202,133 +209,3 @@ class NautobotTestRunner(DiscoverRunner):
                     print(f"Database {db_name} emptied!")
 
                 connection.creation.destroy_test_db(old_name, self.verbosity, self.keepdb)
-
-
-# Use django_slowtests only when GENERATE_PERFORMANCE_REPORT flag is set to true
-try:
-    from django_slowtests.testrunner import DiscoverSlowestTestsRunner
-
-    print("Using NautobotPerformanceTestRunner to run tests ...")
-
-    class NautobotPerformanceTestRunner(NautobotTestRunner, DiscoverSlowestTestsRunner):
-        """
-        Pre-requisite:
-            Set `GENERATE_PERFORMANCE_REPORT` to True in settings.py
-        This test runner is designated to run performance specific unit tests.
-
-        `ModelViewTestCase` is tagged with `performance` to test the time it will take to retrieve, list, create, bulk_create,
-        delete, bulk_delete, edit, bulk_edit object(s) and various other operations.
-
-        The results are compared to the corresponding entries in `TEST_PERFORMANCE_BASELINE_FILE` and only results that are significantly slower
-        than baseline will be exposed to the user.
-        """
-
-        def generate_report(self, test_results, result):
-            """
-            Generate Performance Report consists of unit tests that are significantly slower than baseline.
-            """
-            test_result_count = len(test_results)
-
-            # Add `--performance-snapshot` to the end of `invoke` commands to generate a report.json file consist of the performance tests result
-            if self.report_path:
-                data = [
-                    {
-                        "tests": [
-                            {
-                                "name": func_name,
-                                "execution_time": float(timing),
-                            }
-                            for func_name, timing in test_results
-                        ],
-                        "test_count": result.testsRun,
-                        "failed_count": len(result.errors + result.failures),
-                        "total_execution_time": result.timeTaken,
-                    }
-                ]
-                with open(self.report_path, "w") as outfile:
-                    yaml.dump(data, outfile, sort_keys=False)
-            # Print the results in the CLI.
-            else:
-                if test_result_count:
-                    print(f"\n{test_result_count} abnormally slower tests:")
-                    for func_name, timing in test_results:
-                        time = float(timing)
-                        baseline = self.baselines.get(func_name, None)
-                        if baseline:
-                            baseline = float(baseline)
-                            print(f"{time:.4f}s {func_name} is significantly slower than the baseline {baseline:.4f}s")
-                        else:
-                            print(
-                                f"Performance baseline for {func_name} is not available. Test took {time:.4f}s to run"
-                            )
-
-                if not test_results:
-                    print("\nNo tests signficantly slower than baseline. Success!")
-
-        def get_baselines(self):
-            """Load the performance_baselines.yml file for result comparison."""
-            baselines = {}
-            input_file = getattr(
-                settings, "TEST_PERFORMANCE_BASELINE_FILE", "nautobot/core/tests/performance_baselines.yml"
-            )
-
-            with open(input_file) as f:
-                data = yaml.safe_load(f)
-                for entry in data["tests"]:
-                    baselines[entry["name"]] = entry["execution_time"]
-            return baselines
-
-        def suite_result(self, suite, result):
-            """Compile the performance test results"""
-            return_value = super(DiscoverSlowestTestsRunner, self).suite_result(suite, result)
-            self.baselines = self.get_baselines()
-
-            # add `--performance_report` to `invoke` commands to generate report.
-            # e.g. `invoke unittest --performance_report`
-            if not self.should_generate_report:
-                self.remove_timing_tmp_files()
-                return return_value
-
-            # Grab slowest tests
-            timings = self.get_timings()
-            # Sort the results by test names x[0]
-            by_name = sorted(timings, key=lambda x: x[0])
-            test_results = by_name
-
-            if self.baselines:
-                # Filter tests by baseline numbers
-                test_results = []
-
-                for entry in by_name:
-                    # Convert test time from seconds to miliseconds for comparison
-                    result_time_ms = entry[1] * 1000
-                    # If self.report_path, that means the user wants to update the performance baselines.
-                    # so we append every result that is available to us.
-                    if self.report_path:
-                        test_results.append(entry)
-                    else:
-                        # If the test is completed under 1.5 times the baseline or the difference between the result and the baseline is less than 3 seconds,
-                        # dont show the test to the user.
-
-                        baseline = self.baselines.get(entry[0], None)
-
-                        # check if baseline is available
-                        if not baseline:
-                            test_results.append(entry)
-                            continue
-
-                        # baseline duration in milliseconds
-                        baseline_ms = baseline * 1000
-                        # Arbitrary criteria to not make performance test fail easily
-                        if result_time_ms <= baseline_ms * 1.5 or result_time_ms - baseline_ms <= 500:
-                            continue
-
-                        test_results.append(entry)
-
-            self.generate_report(test_results, result)
-            return return_value
-
-except ImportError:
-    print(
-        "Unable to import DiscoverSlowestTestsRunner from `django_slowtests`. Is the 'django_slowtests' package installed?"
-    )