nautobot 2.4.13__py3-none-any.whl → 2.4.15__py3-none-any.whl

nautobot/apps/choices.py

@@ -18,11 +18,15 @@ from nautobot.dcim.choices import (
     InterfaceRedundancyGroupProtocolChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
+    PowerFeedBreakerPoleChoices,
     PowerFeedPhaseChoices,
+    PowerFeedStatusChoices,
     PowerFeedSupplyChoices,
     PowerFeedTypeChoices,
     PowerOutletFeedLegChoices,
     PowerOutletTypeChoices,
+    PowerPanelTypeChoices,
+    PowerPathChoices,
     PowerPortTypeChoices,
     RackDimensionUnitChoices,
     RackElevationDetailRenderChoices,
@@ -89,11 +93,15 @@ __all__ = (
     "ObjectChangeActionChoices",
     "ObjectChangeEventContextChoices",
     "PortTypeChoices",
+    "PowerFeedBreakerPoleChoices",
     "PowerFeedPhaseChoices",
+    "PowerFeedStatusChoices",
     "PowerFeedSupplyChoices",
     "PowerFeedTypeChoices",
     "PowerOutletFeedLegChoices",
     "PowerOutletTypeChoices",
+    "PowerPanelTypeChoices",
+    "PowerPathChoices",
     "PowerPortTypeChoices",
     "PrefixTypeChoices",
     "RackDimensionUnitChoices",

nautobot/apps/ui.py

@@ -2,6 +2,13 @@
 
 from nautobot.core.choices import ButtonColorChoices
 from nautobot.core.ui.base import PermissionsMixin
+from nautobot.core.ui.breadcrumbs import (
+    BaseBreadcrumbItem,
+    Breadcrumbs,
+    InstanceBreadcrumbItem,
+    ModelBreadcrumbItem,
+    ViewNameBreadcrumbItem,
+)
 from nautobot.core.ui.choices import LayoutChoices, SectionChoices
 from nautobot.core.ui.homepage import (
     HomePageBase,
@@ -36,6 +43,7 @@ from nautobot.core.ui.object_detail import (
     Tab,
     TextPanel,
 )
+from nautobot.core.ui.titles import Titles
 from nautobot.core.ui.utils import render_component_template
 from nautobot.extras.choices import BannerClassChoices
 from nautobot.extras.plugins import Banner, TemplateExtension
@@ -43,7 +51,9 @@ from nautobot.extras.plugins import Banner, TemplateExtension
 __all__ = (
     "Banner",
     "BannerClassChoices",
+    "BaseBreadcrumbItem",
     "BaseTextPanel",
+    "Breadcrumbs",
     "Button",
     "ButtonColorChoices",
     "Component",
@@ -55,8 +65,10 @@ __all__ = (
     "HomePageGroup",
     "HomePageItem",
     "HomePagePanel",
+    "InstanceBreadcrumbItem",
     "KeyValueTablePanel",
     "LayoutChoices",
+    "ModelBreadcrumbItem",
     "NavMenuAddButton",
     "NavMenuBase",
     "NavMenuButton",
@@ -75,5 +87,7 @@ __all__ = (
     "Tab",
     "TemplateExtension",
     "TextPanel",
+    "Titles",
+    "ViewNameBreadcrumbItem",
     "render_component_template",
 )

nautobot/core/api/views.py

@@ -519,6 +519,8 @@ class StatusView(NautobotAPIVersionMixin, APIView):
             if version:
                 if isinstance(version, tuple):
                     version = ".".join(str(n) for n in version)
+                else:
+                    version = str(version)
             installed_apps[app_config.name] = version
         installed_apps = dict(sorted(installed_apps.items()))
 

nautobot/core/choices.py

@@ -194,6 +194,7 @@ class ButtonActionColorChoices(ChoiceSet):
     EXPORT = "success"
     IMPORT = "primary"
     INFO = "info"
+    RENAME = "warning"
     SUBMIT = "primary"
     SWAP = "primary"
 
@@ -210,6 +211,7 @@ class ButtonActionColorChoices(ChoiceSet):
         (EXPORT, "Export"),
         (IMPORT, "Import"),
         (INFO, "Info"),
+        (RENAME, "Rename"),
         (SUBMIT, "Submit"),
         (SWAP, "Swap"),
     )
@@ -236,6 +238,7 @@ class ButtonActionIconChoices(ChoiceSet):
     LOCK = "mdi-lock"
     MAGNIFY = "mdi-magnify"
     NOTE = "mdi-note-text"
+    RENAME = "mdi-pencil"
     SWAP = "mdi-swap-vertical"
     TRASH = "mdi-trash-can-outline"
 
@@ -256,6 +259,7 @@ class ButtonActionIconChoices(ChoiceSet):
         (LOCK, "Lock"),
         (MAGNIFY, "Magnify"),
         (NOTE, "Note"),
+        (RENAME, "Rename"),
         (SWAP, "Swap"),
         (TRASH, "Trash"),
     )

nautobot/core/filters.py

@@ -209,14 +209,12 @@ class ContentTypeFilterMixin:
             return qs
 
         if value.isdigit():
-            return qs.filter(**{f"{self.field_name}__pk": value})
-
+            return self.get_method(qs)(**{f"{self.field_name}__pk": value})
         try:
             app_label, model = value.lower().split(".")
         except ValueError:
             return qs.none()
-
-        return qs.filter(
+        return self.get_method(qs)(
             **{
                 f"{self.field_name}__app_label": app_label,
                 f"{self.field_name}__model": model,
@@ -244,6 +242,8 @@ class ContentTypeChoiceFilter(ContentTypeFilterMixin, django_filters.ChoiceFilte
         content_type = ContentTypeChoiceFilter(
             choices=FeatureQuery("dynamic_groups").get_choices,
         )
+
+    In most cases you should use `ContentTypeMultipleChoiceFilter` instead.
     """
 
 
@@ -251,6 +251,9 @@ class ContentTypeMultipleChoiceFilter(django_filters.MultipleChoiceFilter):
     """
     Allows multiple-choice ContentType filtering by <app_label>.<model> (e.g. "dcim.location").
 
+    Does NOT allow filtering by PK at this time; it would need to be reimplemented similar to
+    NaturalKeyOrPKMultipleChoiceFilter as a breaking change.
+
     Defaults to joining multiple options with "AND". Pass `conjoined=False` to
     override this behavior to join with "OR" instead.
 
@@ -265,43 +268,14 @@ class ContentTypeMultipleChoiceFilter(django_filters.MultipleChoiceFilter):
         kwargs.setdefault("conjoined", True)
         super().__init__(*args, **kwargs)
 
-    def filter(self, qs, value):
-        """Filter on value, which should be list of content-type names.
-
-        e.g. `['dcim.device', 'dcim.rack']`
-        """
-        if not self.conjoined:
-            q = models.Q()
-
-        for v in value:
-            if self.conjoined:
-                qs = ContentTypeFilter.filter(self, qs, v)
-            else:
-                if v.isdigit():
-                    q |= models.Q(**{f"{self.field_name}__pk": value})
-                    continue
-                # Similar to the ContentTypeFilter.filter() call above, but instead of narrowing the query each time
-                # (a AND b AND c ...) we broaden the query each time (a OR b OR c ...).
-                # Specifically, we're mapping a value like ['dcim.device', 'ipam.vlan'] to a query like
-                # Q((field__app_label="dcim" AND field__model="device") OR (field__app_label="ipam" AND field__model="VLAN"))
-                try:
-                    app_label, model = v.lower().split(".")
-                except ValueError:
-                    continue
-                q |= models.Q(
-                    **{
-                        f"{self.field_name}__app_label": app_label,
-                        f"{self.field_name}__model": model,
-                    }
-                )
-
-        if not self.conjoined:
-            qs = qs.filter(q)
-
-        if self.distinct:
-            qs = qs.distinct()
-
-        return qs
+    def get_filter_predicate(self, v):
+        if v.isdigit():
+            return {f"{self.field_name}__pk": v}
+        try:
+            app_label, model = v.lower().split(".")
+        except ValueError:
+            return {f"{self.field_name}__pk": v}
+        return {f"{self.field_name}__app_label": app_label, f"{self.field_name}__model": model}
 
 
 class MappedPredicatesFilterMixin:
@@ -642,6 +616,9 @@ class BaseFilterSet(django_filters.FilterSet):
             (
                 django_filters.ModelChoiceFilter,
                 django_filters.ModelMultipleChoiceFilter,
+                ContentTypeFilter,
+                ContentTypeChoiceFilter,
+                ContentTypeMultipleChoiceFilter,
                 MultiValueUUIDFilter,
                 TagFilter,
                 TreeNodeMultipleChoiceFilter,
@@ -820,6 +797,7 @@ class BaseFilterSet(django_filters.FilterSet):
                     to_field_name="name",
                     label="Contacts (name or ID)",
                 )
+                cls.declared_filters["contacts"] = filters["contacts"]  # pylint: disable=no-member
 
             if "teams" not in filters:
                 filters["teams"] = NaturalKeyOrPKMultipleChoiceFilter(
@@ -828,6 +806,7 @@ class BaseFilterSet(django_filters.FilterSet):
                     to_field_name="name",
                     label="Teams (name or ID)",
                 )
+                cls.declared_filters["teams"] = filters["teams"]  # pylint: disable=no-member
 
         if "dynamic_groups" not in filters and getattr(cls._meta.model, "is_dynamic_group_associable_model", False):  # pylint: disable=no-member
             if not hasattr(cls._meta.model, "static_group_association_set"):  # pylint: disable=no-member
@@ -848,6 +827,7 @@ class BaseFilterSet(django_filters.FilterSet):
                     query_params={"content_type": cls._meta.model._meta.label_lower},  # pylint: disable=no-member
                     label="Dynamic groups (name or ID)",
                 )
+                cls.declared_filters["dynamic_groups"] = filters["dynamic_groups"]  # pylint: disable=no-member
 
         # django-filters has no concept of "abstract" filtersets, so we have to fake it
         if cls._meta.model is not None:  # pylint: disable=no-member

nautobot/core/graphql/generators.py

@@ -16,6 +16,9 @@ logger = logging.getLogger(__name__)
 RESOLVER_PREFIX = "resolve_"
 
 
+LIST_SEARCH_PARAMS_BY_SCHEMA_TYPE = {}
+
+
 def generate_restricted_queryset():
     """
     Generate a function to return a restricted queryset compatible with the internal permissions system.
@@ -248,6 +251,9 @@ def generate_schema_type(app_name: str, model: object) -> OptimizedNautobotObjec
 def generate_list_search_parameters(schema_type):
     """Generate list of query parameters for the list resolver based on a filterset."""
 
+    if schema_type in LIST_SEARCH_PARAMS_BY_SCHEMA_TYPE:
+        return LIST_SEARCH_PARAMS_BY_SCHEMA_TYPE[schema_type]
+
     search_params = {
         "limit": graphene.Int(),
         "offset": graphene.Int(),
@@ -259,6 +265,8 @@ def generate_list_search_parameters(schema_type):
             )
         )
 
+    LIST_SEARCH_PARAMS_BY_SCHEMA_TYPE[schema_type] = search_params
+
     return search_params
 
 

nautobot/core/graphql/schema.py

@@ -243,12 +243,12 @@ def extend_schema_type_custom_field(schema_type, model):
         (DjangoObjectType): The extended schema_type object
     """
 
-    cfs = CustomField.objects.get_for_model(model)
+    custom_fields = CustomField.objects.get_for_model(model, get_queryset=False)
     prefix = ""
     if settings.GRAPHQL_CUSTOM_FIELD_PREFIX and isinstance(settings.GRAPHQL_CUSTOM_FIELD_PREFIX, str):
         prefix = f"{settings.GRAPHQL_CUSTOM_FIELD_PREFIX}_"
 
-    for field in cfs:
+    for field in custom_fields:
         # Since we guaranteed cf.key's uniqueness in CustomField data migration
         # We can safely field_key this in our GraphQL without duplication
         # For new CustomField instances, we also make sure that duplicate key does not exist.
@@ -281,6 +281,7 @@ def extend_schema_type_custom_field(schema_type, model):
 
 def extend_schema_type_computed_field(schema_type, model):
     """Extend schema_type object to had attribute and resolver around computed_fields.
+
     Each computed field will be defined as a first level attribute.
 
     Args:
@@ -291,12 +292,12 @@ def extend_schema_type_computed_field(schema_type, model):
         (DjangoObjectType): The extended schema_type object
     """
 
-    cfs = ComputedField.objects.get_for_model(model)
+    computed_fields = ComputedField.objects.get_for_model(model, get_queryset=False)
     prefix = ""
     if settings.GRAPHQL_COMPUTED_FIELD_PREFIX and isinstance(settings.GRAPHQL_COMPUTED_FIELD_PREFIX, str):
         prefix = f"{settings.GRAPHQL_COMPUTED_FIELD_PREFIX}_"
 
-    for field in cfs:
+    for field in computed_fields:
         field_name = f"{prefix}{field.key}"
         try:
             check_if_key_is_graphql_safe("Computed Field", field.key)
@@ -396,12 +397,16 @@ def extend_schema_type_global_features(schema_type, model):
 
 
 def extend_schema_type_relationships(schema_type, model):
-    """Extend the schema type with attributes and resolvers corresponding
-    to the relationships associated with this model."""
+    """
+    Extend the schema type with attributes and resolvers for the relationships associated with this model.
 
+    Args:
+        schema_type (DjangoObjectType): GraphQL Object type for a given model
+        model (Model): Django model
+    """
     relationships_by_side = {
-        "source": Relationship.objects.get_for_model_source(model),
-        "destination": Relationship.objects.get_for_model_destination(model),
+        "source": Relationship.objects.get_for_model_source(model, get_queryset=False),
+        "destination": Relationship.objects.get_for_model_destination(model, get_queryset=False),
     }
 
     prefix = ""
@@ -499,30 +504,16 @@ def generate_query_mixin():
 
     logger.debug("Generating dynamic schemas for all models in the models_features graphql registry")
     #  - Ensure an attribute/schematype with the same name doesn't already exist
-    registered_models = registry.get("model_features", {}).get("graphql", {})
-    for app_name, models in registered_models.items():
-        for model_name in models:
-            try:
-                # Find the model class based on the content type
-                ct = ContentType.objects.get(app_label=app_name, model=model_name)
-                model = ct.model_class()
-            except ContentType.DoesNotExist:
-                logger.warning(
-                    'Unable to generate a schema type for the model "%s.%s" in GraphQL, '
-                    "as this model doesn't have an associated ContentType. Please create the Object manually.",
-                    app_name,
-                    model_name,
-                )
-                continue
+    registered_models = registry.get("feature_models", {}).get("graphql", [])
+    for model in registered_models:
+        type_identifier = model._meta.label_lower
 
-            type_identifier = f"{app_name}.{model_name}"
-
-            if type_identifier in registry["graphql_types"].keys():
-                # Skip models that have been added statically
-                continue
+        if type_identifier in registry["graphql_types"].keys():
+            # Skip models that have been added statically
+            continue
 
-            schema_type = generate_schema_type(app_name=app_name, model=model)
-            registry["graphql_types"][type_identifier] = schema_type
+        schema_type = generate_schema_type(app_name=model._meta.app_label, model=model)
+        registry["graphql_types"][type_identifier] = schema_type
 
     logger.debug("Adding plugins' statically defined graphql schema types")
     # After checking for conflict
@@ -542,6 +533,15 @@ def generate_query_mixin():
             registry["graphql_types"][type_identifier] = schema_type
 
     logger.debug("Extending all registered schema types with dynamic attributes")
+
+    # Precache all content-types as we'll need them for filtering and the like
+    for content_type in ContentType.objects.all():
+        ContentType.objects._add_to_cache(ContentType.objects.db, content_type)
+
+    CustomField.objects.populate_list_caches()
+    ComputedField.objects.populate_list_caches()
+    Relationship.objects.populate_list_caches()
+
     for schema_type in registry["graphql_types"].values():
         if already_present(schema_type._meta.model):
             continue

nautobot/core/management/commands/check_job_approval_status.py

@@ -0,0 +1,47 @@
+from django.core.exceptions import ValidationError
+from django.core.management.base import BaseCommand
+
+from nautobot.extras.models import Job, ScheduledJob
+
+
+class ApprovalRequiredScheduledJobsError(ValidationError):
+    """Raised when scheduled jobs requiring approval are found during managment command."""
+
+    def __init__(self, message_lines):
+        self.message_lines = message_lines
+        super().__init__(message_lines)
+
+    def __str__(self):
+        return "\n".join(self.message_lines)
+
+
+class Command(BaseCommand):
+    help = "Checks for scheduled jobs and jobs that require approval."
+
+    def handle(self, *args, **options):
+        approval_required_scheduled_jobs = ScheduledJob.objects.filter(approval_required=True).values_list("id", "name")
+
+        if approval_required_scheduled_jobs:
+            message_lines = [
+                "These need to be approved (and run) or denied before upgrading to Nautobot v3, as the introduction of the approval workflows feature means that future scheduled-job approvals will be handled differently.",
+                "Refer to the documentation: https://docs.nautobot.com/projects/core/en/v2.4.14/user-guide/platform-functionality/jobs/job-scheduling-and-approvals/#approval-via-the-ui",
+                "Below is a list of affected scheduled jobs:",
+            ]
+            for schedule_job_id, scheduled_job_name in approval_required_scheduled_jobs:
+                message_lines.append(f"    - ID: {schedule_job_id}, Name: {scheduled_job_name}")
+            raise ApprovalRequiredScheduledJobsError(message_lines)
+
+        approval_required_jobs = Job.objects.filter(approval_required=True).values_list("name", flat=True)
+        if approval_required_jobs:
+            message_lines = [
+                "Following jobs still have `approval_required=True`.",
+                "These jobs will no longer trigger approval automatically.",
+                "After upgrading to Nautobot 3.x, you should add an approval workflow definition(s) covering these jobs.",
+                "Refer to the documentation: https://docs.nautobot.com/projects/core/en/v3.0.0/user-guide/platform-functionality/approval-workflow/",
+                "Affected jobs (Names):",
+            ]
+            for job_name in approval_required_jobs:
+                message_lines.append(f"    - {job_name}")
+        else:
+            message_lines = ["No approval_required jobs or scheduled jobs found."]
+        self.stdout.write("\n".join(message_lines))

nautobot/core/management/commands/generate_test_data.py

@@ -375,7 +375,7 @@ class Command(BaseCommand):
                 confirm = input(
                     f"""\
 You have requested a flush of the database before generating new data.
-This will IRREVERSIBLY DESTROY all data in the "{connections[options['database']].settings_dict['NAME']}" database,
+This will IRREVERSIBLY DESTROY all data in the "{connections[options["database"]].settings_dict["NAME"]}" database,
 including all user accounts, and return each table to an empty state.
 Are you SURE you want to do this?
 

nautobot/core/management/commands/migrate.py

@@ -1,8 +1,97 @@
 # noinspection PyUnresolvedReferences
-from django.core.management.commands.migrate import Command  # noqa: F401  # unused-import
+import contextlib
+import time
+
+from django.apps import apps
+from django.core.management.commands.migrate import Command as _Command
 from django.db import models
+from django.db.migrations.operations.fields import FieldOperation
+from django.db.migrations.operations.models import ModelOperation
 
 from nautobot.core.management import commands
 
 # Overload deconstruct with our own.
 models.Field.deconstruct = commands.custom_deconstruct
+
+
+class Command(_Command):
+    def migration_progress_callback(self, action, migration=None, fake=False):
+        """
+        Enhanced version of Django's built-in callback.
+
+        Differences in behavior:
+            - Measures and reports elapsed time whenever verbosity >= 1 (default value)
+            - Measures and reports affected record counts and elapsed time per record where applicable at verbosity >= 2.
+            - Aligns output to 80-character terminal width in most cases
+
+        Examples:
+            # nautobot-server migrate
+            Running migrations:
+              Applying dcim.0065_controller_capabilities_and_more...         OK        0.10s
+              Applying wireless.0001_initial...                              OK        0.31s
+              Applying dcim.0066_controllermanageddevicegroup_radio_profi... OK        0.12s
+
+            # nautobot-server migrate -v=2 extras 0100
+            Operations to perform:
+              Target specific migration: 0100_fileproxy_job_result, from extras
+            Running migrations:
+              Rendering model states...                                      DONE     19.10s
+              Unapplying ipam.0052_alter_ipaddress_index_together_and_mor... OK        0.10s
+                Affected ipam.ipaddress                               75 rows  0.001s/record
+                Affected ipam.prefix                                 184 rows  0.000s/record
+                Affected ipam.vrf                                     20 rows  0.004s/record
+              Unapplying ipam.0051_added_optional_vrf_relationship_to_vdc... OK        0.10s
+                Affected ipam.vrf                                     20 rows  0.006s/record
+                Affected ipam.vrfdeviceassignment                    140 rows  0.001s/record
+              Unapplying virtualization.0030_alter_virtualmachine_local_c... OK        0.30s
+                Affected virtualization.virtualmachine                 0 rows
+                Affected virtualization.vminterface                    0 rows
+              Unapplying virtualization.0029_add_role_field_to_interface_... OK        0.10s
+                Affected virtualization.vminterface                    0 rows
+        """
+        if self.verbosity < 1:
+            return
+
+        if action in ["apply_start", "render_start", "unapply_start"]:
+            self.start = time.monotonic()
+            self.affected_models = set()
+            self.affected_models_count = {}
+            self.migration = migration
+            if self.verbosity >= 2 and self.migration is not None:
+                for operation in self.migration.operations:
+                    if isinstance(operation, FieldOperation):
+                        self.affected_models.add((self.migration.app_label, operation.model_name.lower()))
+                    elif isinstance(operation, ModelOperation):
+                        self.affected_models.add((self.migration.app_label, operation.name.lower()))
+
+                for app_label, model_name in sorted(self.affected_models):
+                    self.affected_models_count[f"{app_label}.{model_name}"] = 0
+                    with contextlib.suppress(Exception):
+                        model = apps.get_model(app_label, model_name)
+                        self.affected_models_count[model._meta.label_lower] = model.objects.count()
+
+            if action == "apply_start":
+                msg = f"  Applying {str(migration)[:50]}..."
+            elif action == "render_start":
+                msg = "  Rendering model states..."
+            else:
+                msg = f"  Unapplying {str(migration)[:48]}..."
+            self.stdout.write(f"{msg:<64}", ending="")
+            self.stdout.flush()
+
+        elif action in ["apply_success", "render_success", "unapply_success"]:
+            elapsed = time.monotonic() - self.start
+            outcome = "DONE" if action == "render_success" else "FAKED" if fake else "OK"
+            self.stdout.write(self.style.SUCCESS(f" {outcome:<5} {elapsed: 8.2f}s"))
+            if self.verbosity >= 2 and self.migration is not None:
+                for app_label, model_name in sorted(self.affected_models):
+                    if self.affected_models_count[f"{app_label}.{model_name}"] == 0:
+                        with contextlib.suppress(Exception):
+                            model = apps.get_model(app_label, model_name)
+                            self.affected_models_count[model._meta.label_lower] = model.objects.count()
+
+                for key, value in self.affected_models_count.items():
+                    if value:
+                        self.stdout.write(f"    Affected {key:<38} {value: 8} rows {elapsed / value:6.3f}s/record")
+                    else:
+                        self.stdout.write(f"    Affected {key:<38} {value: 8} rows")

nautobot/core/models/tree_queries.py

@@ -1,6 +1,7 @@
 from django.core.cache import cache
 from django.db.models import Case, When
 from django.db.models.signals import post_delete, post_save
+from tree_queries.compiler import TreeQuery
 from tree_queries.models import TreeNode
 from tree_queries.query import TreeManager as TreeManager_, TreeQuerySet as TreeQuerySet_
 
@@ -61,6 +62,22 @@ class TreeQuerySet(TreeQuerySet_, querysets.RestrictedQuerySet):
             return deepest.tree_depth
         return 0
 
+    def count(self):
+        """Custom count method for optimization purposes.
+
+        TreeQuerySet instances in Nautobot are by default with tree fields. So if somewhere tree fields aren't
+        explicitly removed from the queryset and count is called, the whole tree is calculated. Since this is not
+        needed, this implementation calls `without_tree_fields` before issuing the count query and `with_tree_fields`
+        afterwards when applicable.
+        """
+        should_have_tree_fields = isinstance(self.query, TreeQuery)
+        if should_have_tree_fields:
+            self.without_tree_fields()
+        count = super().count()
+        if should_have_tree_fields:
+            self.with_tree_fields()
+        return count
+
 
 class TreeManager(TreeManager_, BaseManager.from_queryset(TreeQuerySet)):
     """

nautobot/core/settings.py

@@ -765,7 +765,7 @@ CONSTANCE_CONFIG = {
     ),
     "JOB_CREATE_FILE_MAX_SIZE": ConstanceConfigItem(
         default=10 << 20,
-        help_text=mark_safe(  # noqa: S308  # suspicious-mark-safe-usage, but this is a static string so it's safe
+        help_text=mark_safe(
             "Maximum size (in bytes) of any single file generated by a <code>Job.create_file()</code> call."
         ),
         field_type=int,
@@ -798,7 +798,7 @@ CONSTANCE_CONFIG = {
     ),
     "NETWORK_DRIVERS": ConstanceConfigItem(
         default={},
-        help_text=mark_safe(  # noqa: S308  # suspicious-mark-safe-usage, but this is a static string so it's safe
+        help_text=mark_safe(
             "Extend or override default Platform.network_driver translations provided by "
             '<a href="https://netutils.readthedocs.io/en/latest/user/lib_use_cases_lib_mapper/">netutils</a>. '
             "Enter a dictionary in JSON format, for example:\n"

nautobot/core/settings.yaml

@@ -1487,9 +1487,9 @@ properties:
       }
       ```
 
-      The default top-level keys are `ansible`, `hier_config`, `napalm`, `netmiko`, `netutils_parser`,
-      `ntc_templates`, `pyats`, `pyntc`, and `scrapli`, but you can also add additional keys if you have
-      an alternative network driver that you want your Nautobot instance to include.
+      The default top-level keys consists of `ansible`, `hier_config`, `napalm`, etc, and comes from netutils, but
+      you can also add additional keys if you have an alternative network driver that you want your Nautobot instance
+      to include.
     is_constance_config: true
     type: "object"
     version_added: "1.6.0"