nautobot 3.0.0a2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

nautobot/core/utils/lookup.py

@@ -11,9 +11,10 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist
 from django.db.models import ForeignKey, Model
 from django.urls import get_resolver, resolve, reverse, URLPattern, URLResolver
-from django.utils.module_loading import import_string
 from django.views.generic.base import RedirectView
 
+from nautobot.core.utils.module_loading import import_string_optional
+
 
 def resolve_attr(obj, dotted_field):
     """
@@ -60,6 +61,14 @@ def resolve_attr(obj, dotted_field):
     return str(val) if val else None
 
 
+def get_breadcrumbs_for_model(model, view_type: str = "List"):
+    """Get a UI Component Framework 'Breadcrumbs' instance for the given model's related UIViewSet or generic view."""
+    view = get_view_for_model(model)
+    if hasattr(view, "get_breadcrumbs"):
+        return view.get_breadcrumbs(model, view_type=view_type)
+    return None
+
+
 def get_changes_for_model(model):
     """
     Return a queryset of ObjectChanges for a model or instance. The queryset will be filtered
@@ -77,6 +86,30 @@ def get_changes_for_model(model):
     raise TypeError(f"{model!r} is not a Django Model class or instance")
 
 
+def get_detail_view_components_context_for_model(model) -> dict:
+    """Helper method for DistinctViewTabs etc. to retrieve the UI Component Framework context for the base detail view.
+
+    Functionally equivalent to calling `get_breadcrumbs_for_model()`, `get_object_detail_content_for_model()`, and
+    `get_view_titles_for_model()`, but marginally more efficient.
+    """
+    context = {
+        "breadcrumbs": None,
+        "object_detail_content": None,
+        "view_titles": None,
+    }
+
+    view = get_view_for_model(model, view_type="")
+    if view is not None:
+        if hasattr(view, "get_breadcrumbs"):
+            context["breadcrumbs"] = view.get_breadcrumbs(model, view_type="")
+        if hasattr(view, "get_view_titles"):
+            context["view_titles"] = view.get_view_titles(model, view_type="")
+        if hasattr(view, "object_detail_content"):
+            context["object_detail_content"] = view.object_detail_content
+
+    return context
+
+
 def get_model_from_name(model_name):
     """Given a full model name in dotted format (example: `dcim.model`), a model class is returned if valid.
 
@@ -181,13 +214,7 @@ def get_related_class_for_model(model, module_name, object_suffix):
     object_name = f"{model.__name__}{object_suffix}"
     object_path = f"{app_config.name}.{module_name}.{object_name}"
 
-    try:
-        return import_string(object_path)
-    # The name of the module is not correct or unable to find the desired object for this model
-    except (AttributeError, ImportError, ModuleNotFoundError):
-        pass
-
-    return None
+    return import_string_optional(object_path)
 
 
 def get_filterset_for_model(model):
@@ -227,6 +254,12 @@ def get_form_for_model(model, form_prefix=""):
     return get_related_class_for_model(model, module_name="forms", object_suffix=object_suffix)
 
 
+def get_object_detail_content_for_model(model):
+    """Get the UI Component Framework 'object_detail_content' for the given model's related UIViewSet or ObjectView."""
+    view = get_view_for_model(model)
+    return getattr(view, "object_detail_content", None)
+
+
 def get_related_field_for_models(from_model, to_model):
     """
     Find the field on `from_model` that is a relation to `to_model`.
@@ -294,6 +327,14 @@ def get_view_for_model(model, view_type=""):
     return result
 
 
+def get_view_titles_for_model(model, view_type: str = "List"):
+    """Get a UI Component Framework 'Titles' instance for the given model's related UIViewSet or generic view."""
+    view = get_view_for_model(model)
+    if hasattr(view, "get_view_titles"):
+        return view.get_view_titles(model, view_type=view_type)
+    return None
+
+
 def get_model_for_view_name(view_name):
     """
     Return the model class associated with the given view_name e.g. "circuits:circuit_detail", "dcim:device_list" and etc.

nautobot/core/utils/module_loading.py

@@ -7,9 +7,30 @@ import os
 import pkgutil
 import sys
 
+from django.utils.module_loading import import_string
+
 logger = logging.getLogger(__name__)
 
 
+def import_string_optional(dotted_path):
+    """An extension/wrapper of Django's `import_string()` that returns `None` if no such dotted path exists."""
+    try:
+        return import_string(dotted_path)
+    except ModuleNotFoundError as err:
+        # No such module
+        module_name, _ = dotted_path.rsplit(".", 1)
+        if module_name.startswith(err.name):  # tried to import foo.bar.baz but couldn't find foo.bar, etc.
+            return None
+        # Some import *from within* the given module couldn't find what it was looking for?
+        raise
+    except ImportError as err:
+        if "does not define" in str(err):
+            # Exception raised by Django if the module exists but has no such attribute
+            return None
+        # Maybe a legitimate problem with the import?
+        raise
+
+
 @contextmanager
 def _temporarily_add_to_sys_path(path):
     """

nautobot/core/utils/patch_social_django.py

@@ -0,0 +1,128 @@
+from django.core.exceptions import FieldDoesNotExist
+from django.db import router, transaction
+from django.db.utils import IntegrityError
+from social_core.exceptions import AuthAlreadyAssociated
+
+"""
+Social Auth Account Takeover Vulnerability Patch
+=================================================
+
+This module patches CVE-2025-61783, a medium security vulnerability in social_django that allows
+account takeover when using OAuth providers that don't verify email addresses.
+
+VULNERABILITY OVERVIEW
+----------------------
+The vulnerability exists in social_django.storage.DjangoUserMixin.create_user(),
+specifically in how it handles IntegrityError exceptions. When user creation fails due to
+a duplicate email or username, the original code catches the IntegrityError and blindly
+retrieves an existing user via manager.get(), returning that user without verifying that
+a social auth association exists for the provider/UID combination.
+
+PATCHING STRATEGY
+-----------------
+This implementation patches the `create_user` method on the `user` class property of
+DjangoStorage, which is where the vulnerability manifests. The patch changes the behavior
+to raise AuthAlreadyAssociated when an IntegrityError occurs, preventing the silent
+return of an existing user.
+
+By patching at this level, we:
+- Maintain compatibility with custom pipelines
+- Don't require changes to user's social auth configuration
+- Apply the fix exactly where the vulnerability occurs
+- Preserve all other social auth functionality
+
+REMOVAL
+-------
+Remove this patch when upgrading to social-auth-app-django >= 5.6.0
+(version that includes PR #803 merged into the main branch).
+
+To verify if you still need the patch:
+    pip show social-auth-app-django
+    # Check version against PR #803 merge status
+
+REFERENCES
+----------
+- Vulnerability Report: https://github.com/python-social-auth/social-app-django/security/advisories/GHSA-wv4w-6qv2-qqfg
+- Original Issue: https://github.com/python-social-auth/social-app-django/issues/220
+- Official Fix PR: https://github.com/python-social-auth/social-app-django/pull/803
+
+SECURITY NOTICE
+---------------
+This patch addresses a MEDIUM security vulnerability
+
+Disabling this patch without mitigation will expose your application to account
+takeover attacks.
+
+AUTHOR & MAINTENANCE
+--------------------
+Patch implemented as temporary security measure for Nautobot deployment.
+As picking up the latest social_django would require a major version upgrade of Django,
+which itself would require a breaking change to the Nautobot configuration, this patch
+is intended to be a stopgap until such time as Nautobot can upgrade to a version of
+social_django that includes the fix.
+"""
+
+
+def patch_django_storage(original_django_storage):
+    """
+    Apply security patch to DjangoStorage.user.create_user method.
+
+    This patches the vulnerability in python-social-auth where create_user
+    catches IntegrityError and blindly returns an existing user, enabling
+    account takeover via unverified OAuth providers.
+
+    Args:
+        storage_class (DjangoStorage): The original DjangoStorage class to patch.
+
+    Returns:
+        None
+
+    Note:
+        The patch is a nearly verbatim copy of the original create_user method
+        from social_django.storage.DjangoUserMixin from 5.4.3, except that it
+        adopts the fail-closed change described in
+        https://github.com/python-social-auth/social-app-django/pull/803
+
+        The modified lines are called out with "Patched logic" comments below.
+    """
+
+    def patched_create_user(cls, *args, **kwargs):
+        username_field = cls.username_field()
+        if "username" in kwargs:
+            if username_field not in kwargs:
+                kwargs[username_field] = kwargs.pop("username")
+            else:
+                # If username_field is 'email' and there is no field named "username"
+                # then latest should be removed from kwargs.
+                try:
+                    cls.user_model()._meta.get_field("username")
+                except FieldDoesNotExist:
+                    kwargs.pop("username")
+        try:
+            if hasattr(transaction, "atomic"):
+                # In Django versions that have an "atomic" transaction decorator / context
+                # manager, there's a transaction wrapped around this call.
+                # If the create fails below due to an IntegrityError, ensure that the transaction
+                # stays undamaged by wrapping the create in an atomic.
+                using = router.db_for_write(cls.user_model())
+                with transaction.atomic(using=using):
+                    user = cls.user_model()._default_manager.create_user(*args, **kwargs)
+            else:
+                user = cls.user_model()._default_manager.create_user(*args, **kwargs)
+        except IntegrityError as exc:
+            # ORIGINAL CODE BELOW:
+            # # If email comes in as None it won't get found in the get
+            # if kwargs.get("email", True) is None:
+            #     kwargs["email"] = ""
+            # try:
+            #     user = cls.user_model()._default_manager.get(*args, **kwargs)
+            # except cls.user_model().DoesNotExist:
+            #     raise exc
+
+            # BEGIN Patched logic
+            raise AuthAlreadyAssociated(None) from exc
+            # END Patched logic
+        return user
+
+    # Apply the patch to the original DjangoStorage.user.create_user method
+    original_django_storage.user.create_user = classmethod(patched_create_user)

nautobot/core/views/__init__.py

@@ -1,6 +1,8 @@
 import contextlib
 import datetime
+from importlib import resources
 import logging
+import mimetypes
 import os
 import platform
 import posixpath
@@ -16,7 +18,7 @@ from django.contrib.auth.decorators import permission_required
 from django.contrib.auth.mixins import AccessMixin, LoginRequiredMixin, UserPassesTestMixin
 from django.contrib.contenttypes.models import ContentType
 from django.core.cache import cache
-from django.http import HttpResponseForbidden, HttpResponseServerError, JsonResponse
+from django.http import FileResponse, HttpResponseForbidden, HttpResponseServerError, JsonResponse
 from django.shortcuts import get_object_or_404, render
 from django.template import loader, RequestContext, Template
 from django.template.exceptions import TemplateDoesNotExist
@@ -61,6 +63,7 @@ from nautobot.core.views.utils import (
 )
 from nautobot.extras.forms import GraphQLQueryForm
 from nautobot.extras.models import FileProxy, GraphQLQuery, Status
+from nautobot.extras.plugins.urls import BASE_URL_TO_APP_LABEL
 from nautobot.extras.registry import registry
 from nautobot.extras.tables import StatusTable
 
@@ -144,6 +147,40 @@ class HomeView(AccessMixin, TemplateView):
         return self.render_to_response(context)
 
 
+class AppDocsView(LoginRequiredMixin, View):
+    """
+    Serve documentation files for any pip-installed app from inside the package,
+    only for authenticated users.
+    """
+
+    def get(self, request, app_base_url, path="index.html"):
+        app_label = BASE_URL_TO_APP_LABEL.get(app_base_url)
+        if not app_label:
+            return JsonResponse({"detail": f"Unknown base_url '{app_base_url}'."}, status=404)
+        try:
+            base_dir = resources.files(app_label)
+        except ModuleNotFoundError:
+            return JsonResponse({"detail": f"App {app_label} not found."}, status=404)
+
+        # Dir to documentation inside the package
+        docs_dir = base_dir / "docs"
+        # Normalize path to avoid (../) etc.
+        normalized_path = posixpath.normpath(path).lstrip("/")
+        file_path = docs_dir / normalized_path
+
+        # Additional check to ensure the resolved path is still within docs_dir
+        if not file_path.resolve().is_relative_to(docs_dir.resolve()):
+            return JsonResponse({"detail": "Access denied."}, status=403)
+
+        if not file_path.is_file():
+            return JsonResponse({"detail": f"File {file_path} not found."}, status=404)
+
+        # Determine the MIME type based on the file extension and return the file as an HTTP response.
+        # This ensures that browsers interpret the file correctly (e.g., HTML, CSS, JS, images).
+        content_type, _ = mimetypes.guess_type(str(file_path))
+        return FileResponse(open(file_path, "rb"), content_type=content_type)
+
+
 class MediaView(AccessMixin, View):
     """
     Serves media files while enforcing login restrictions.

nautobot/core/views/generic.py

@@ -587,7 +587,7 @@ class ObjectDeleteView(UIComponentsMixin, GetReturnURLMixin, ObjectPermissionReq
     """
 
     queryset: Optional[QuerySet] = None  # TODO: required, declared Optional only to avoid a breaking change
-    template_name = "generic/object_delete.html"
+    template_name = "generic/object_destroy.html"
 
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "delete")
@@ -1044,7 +1044,7 @@ class BulkEditView(
     filterset: Optional[type[FilterSet]] = None
     table: Optional[type[Table]] = None  # TODO: required, declared Optional only to avoid a breaking change
     form: Optional[type[Form]] = None  # TODO: required, declared Optional only to avoid a breaking change
-    template_name = "generic/object_bulk_edit.html"
+    template_name = "generic/object_bulk_update.html"
 
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "change")
@@ -1246,7 +1246,7 @@ class BulkDeleteView(
     filterset: Optional[type[FilterSet]] = None
     table: Optional[type[Table]] = None  # TODO: required, declared Optional only to avoid a breaking change
     form: Optional[type[Form]] = None
-    template_name = "generic/object_bulk_delete.html"
+    template_name = "generic/object_bulk_destroy.html"
 
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "delete")

nautobot/core/views/mixins.py

@@ -73,6 +73,7 @@ PERMISSIONS_ACTION_MAP = {
     "bulk_update": "change",
     "changelog": "view",
     "notes": "view",
+    "data_compliance": "view",
     "approve": "change",
     "deny": "change",
 }
@@ -262,52 +263,57 @@ class UIComponentsMixin:
     breadcrumbs: ClassVar[Optional[Breadcrumbs]] = None
     view_titles: ClassVar[Optional[Titles]] = None
 
-    def get_view_titles(self, model: Union[None, str, Type[Model], Model] = None, view_type: str = "List") -> Titles:
+    @classmethod
+    def get_view_titles(cls, model: Union[None, str, Type[Model], Model] = None, view_type: str = "List") -> Titles:
         """
         Resolve and return the `Titles` component instance.
 
         Resolution order:
-          1) If `self.view_titles` is set on the current view, use it.
-          2) Else, if `model` is provided, copy the `view_titles` from the view
-             class associated with that model via `lookup.get_view_for_model(model, action)`.
+          1) If `.view_titles` is set on the current view, use it.
+          2) Else, if `model` is provided, copy the `view_titles` from the view class associated with that model
+             via `lookup.get_view_for_model(model, action)`.
           3) Else, instantiate and return the default `Titles()`.
 
         Args:
             model: A Django model **class**, **instance**, dotted name string, or `None`.
                 Passed to `lookup.get_view_for_model()` to find the related view class.
                 If `None`, only local/default resolution is used.
-            view_type: Logical view type used by `lookup.get_view_for_model()` (e.g., `"List"` or empty to construct `"DeviceView"` string).
+            view_type: Logical view type used by `lookup.get_view_for_model()`
+                (e.g., `"List"` or empty to construct `"DeviceView"` string).
 
         Returns:
             Titles: A concrete `Titles` component instance ready to use.
         """
-        return self._resolve_component("view_titles", Titles, model, view_type)
+        return cls._resolve_component("view_titles", Titles, model, view_type)
 
+    @classmethod
     def get_breadcrumbs(
-        self, model: Union[None, str, Type[Model], Model] = None, view_type: str = "List"
+        cls, model: Union[None, str, Type[Model], Model] = None, view_type: str = "List"
     ) -> Breadcrumbs:
         """
         Resolve and return the `Breadcrumbs` component instance.
 
         Resolution order mirrors `get_view_titles()`:
-         1) Use `self.breadcrumbs` if set locally.
-         2) Else, if `model` is provided, copy the `breadcrumbs` from the view
-             class associated with that model via `lookup.get_view_for_model(model, action)`.
+         1) Use `.breadcrumbs` if set locally.
+         2) Else, if `model` is provided, copy the `breadcrumbs` from the view class associated with that model
+            via `lookup.get_view_for_model(model, action)`.
          3) Else return a new default `Breadcrumbs()`.
 
         Args:
            model: A Django model **class**, **instance**, dotted name string, or `None`.
                 Passed to `lookup.get_view_for_model()` to find the related view class.
                 If `None`, only local/default resolution is used.
-           view_type: Logical view type used by `lookup.get_view_for_model()` (e.g., `"List"` or empty to construct `"DeviceView"` string).
+           view_type: Logical view type used by `lookup.get_view_for_model()`
+                (e.g., `"List"` or empty to construct `"DeviceView"` string).
 
         Returns:
            Breadcrumbs: A concrete `Breadcrumbs` component instance.
         """
-        return self._resolve_component("breadcrumbs", Breadcrumbs, model, view_type)
+        return cls._resolve_component("breadcrumbs", Breadcrumbs, model, view_type)
 
+    @classmethod
     def _resolve_component(
-        self,
+        cls,
         attr_name: str,
         default_cls: Type[Union[Breadcrumbs, Titles]],
         model: Union[None, str, Type[Model], Model] = None,
@@ -328,14 +334,14 @@ class UIComponentsMixin:
         Returns:
             Breadcrumbs/Title instance.
         """
-        local = getattr(self, attr_name, None)
+        local = getattr(cls, attr_name, None)
         if local is not None:
-            return self._instantiate_if_needed(local, default_cls)
+            return cls._instantiate_if_needed(local, default_cls)
 
         if model is not None:
             view_class = lookup.get_view_for_model(model, view_type)
             view_component = getattr(view_class, attr_name, None)
-            return self._instantiate_if_needed(view_component, default_cls)
+            return cls._instantiate_if_needed(view_component, default_cls)
 
         return default_cls()
 
@@ -532,7 +538,8 @@ class NautobotViewSetMixin(GenericViewSet, UIComponentsMixin, AccessMixin, GetRe
         form.add_error(None, msg)
         return form
 
-    def _handle_not_implemented_error(self):
+    def _handle_not_implemented_error(self, error):
+        self.logger.debug(f"NotImplementedError raised on action {self.action} resulting in error: {error}")
         # Blanket handler for NotImplementedError raised by form helper functions
         msg = "Please provide the appropriate mixin before using this helper function"
         messages.error(self.request, msg)
@@ -567,8 +574,8 @@ class NautobotViewSetMixin(GenericViewSet, UIComponentsMixin, AccessMixin, GetRe
             self._handle_validation_error(e)
         except ObjectDoesNotExist:
             form = self._handle_object_does_not_exist(form)
-        except NotImplementedError:
-            self._handle_not_implemented_error()
+        except NotImplementedError as error:
+            self._handle_not_implemented_error(error)
 
         if not self.has_error:
             self.logger.debug("Form validation was successful")
@@ -730,7 +737,11 @@ class NautobotViewSetMixin(GenericViewSet, UIComponentsMixin, AccessMixin, GetRe
                     except TemplateDoesNotExist:
                         # Try a different detail view template format
                         template_name = f"{app_label}/{model_opts.model_name}.html"
-                        select_template([template_name])
+                        try:
+                            select_template([template_name])
+                        except TemplateDoesNotExist:
+                            # Catch-all fallback to just object_retrieve.html
+                            template_name = "generic/object_retrieve.html"
         return template_name
 
     def get_form(self, *args, **kwargs):
@@ -1498,7 +1509,9 @@ class ObjectChangeLogViewMixin(NautobotViewSetMixin):
 
     base_template: Optional[str] = None
 
-    @drf_action(detail=True)
+    @drf_action(
+        detail=True, custom_view_base_action="view", custom_view_additional_permissions=["extras.view_objectchange"]
+    )
     def changelog(self, request, *args, **kwargs):
         model = self.get_queryset().model
         data = {
@@ -1519,7 +1532,7 @@ class ObjectNotesViewMixin(NautobotViewSetMixin):
 
     base_template: Optional[str] = None
 
-    @drf_action(detail=True)
+    @drf_action(detail=True, custom_view_base_action="view", custom_view_additional_permissions=["extras.view_note"])
     def notes(self, request, *args, **kwargs):
         model = self.get_queryset().model
         data = {
@@ -1527,3 +1540,13 @@ class ObjectNotesViewMixin(NautobotViewSetMixin):
             "active_tab": "notes",
         }
         return Response(data)
+
+
+class ObjectDataComplianceViewMixin(NautobotViewSetMixin):
+    """
+    UI Mixin for a DataCompliance to show up for a given object.
+    """
+
+    @drf_action(detail=True, url_path="data-compliance")
+    def data_compliance(self, request, *args, **kwargs):
+        return Response({})

nautobot/core/views/renderers.py

@@ -15,7 +15,7 @@ from nautobot.core.forms import (
     TableConfigForm,
 )
 from nautobot.core.forms.forms import DynamicFilterFormSet
-from nautobot.core.templatetags.helpers import bettertitle, validated_viewname
+from nautobot.core.templatetags.helpers import validated_viewname
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.utils.requests import (
@@ -227,7 +227,7 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
                     if view.filterset is not None:
                         filterset_filters = view.filterset.filters
                     else:
-                        filterset_filters = view.filterset_class.get_filters()
+                        filterset_filters = view.filterset_class.base_filters
                     display_filter_params = [
                         check_filter_for_display(filterset_filters, field_name, values)
                         for field_name, values in view.filter_params.items()
@@ -324,7 +324,6 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
                     "action_buttons": valid_actions,
                     "list_url": list_url,
                     "saved_views": saved_views,
-                    "title": bettertitle(model._meta.verbose_name_plural),
                 }
             )
         elif view.action in ["create", "update"]:
@@ -365,6 +364,8 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         # See form_valid() for self.action == "bulk_create".
         self.template = data.get("template", view.get_template_name())
 
+        data["request"] = request
+
         return super().render(data, accepted_media_type=accepted_media_type, renderer_context=renderer_context)
 
     @staticmethod

nautobot/core/views/viewsets.py

@@ -11,9 +11,10 @@ class NautobotUIViewSet(
     mixins.ObjectBulkUpdateViewMixin,
     mixins.ObjectChangeLogViewMixin,
     mixins.ObjectNotesViewMixin,
+    mixins.ObjectDataComplianceViewMixin,
 ):
     """
     Nautobot BaseViewSet that is intended for UI use only. It provides default Nautobot functionalities such as
     `create()`, `update()`, `partial_update()`, `bulk_update()`, `destroy()`, `bulk_destroy()`, `retrieve()`
-    `notes()`, `changelog()` and `list()` actions.
+    `notes()`, `changelog()`, `list()`, and `data_compliance()` actions.
     """

nautobot/data_validation/apps.py

@@ -1,5 +1,5 @@
 from nautobot.core.apps import NautobotConfig
-from nautobot.extras.plugins import register_custom_validators, register_template_extensions
+from nautobot.extras.plugins import register_custom_validators
 
 
 class DataValidationEngineConfig(NautobotConfig):
@@ -15,8 +15,4 @@ class DataValidationEngineConfig(NautobotConfig):
 
         register_custom_validators(custom_validators)
 
-        from nautobot.data_validation.template_content import template_extensions
-
-        register_template_extensions(template_extensions)
-
         import nautobot.data_validation.signals  # noqa: F401  # unused-import -- but this import installs the signals

nautobot/data_validation/custom_validators.py

@@ -1,7 +1,7 @@
 """
 This is the meat of this app.
 
-Here we dynamically generate a PluginCustomValidator class
+Here we dynamically generate a CustomValidator class
 for each model currently registered in the extras_features
 query registry 'custom_validators'.
 
@@ -40,7 +40,7 @@ LOGGER = logging.getLogger(__name__)
 
 
 class BaseValidator(CustomValidator):
-    """Base PluginCustomValidator class that implements the core logic for enforcing validation rules defined in this app."""
+    """Base CustomValidator class that implements the core logic for enforcing validation rules defined in this app."""
 
     model = None
 
@@ -314,10 +314,10 @@ class DataComplianceRule(CustomValidator):
 
 
 class CustomValidatorIterator:
-    """Iterator that generates PluginCustomValidator classes for each model registered in the extras feature query registry 'custom_validators'."""
+    """Iterator that generates CustomValidator classes for each model registered in the extras feature query registry 'custom_validators'."""
 
     def __iter__(self):
-        """Return a generator of PluginCustomValidator classes for each registered model."""
+        """Return a generator of CustomValidator classes for each registered model."""
         for app_label, models in registry["model_features"]["custom_validators"].items():
             for model in models:
                 yield type(

nautobot/data_validation/filters.py

@@ -1,6 +1,5 @@
 """Filtering for data_validation."""
 
-from nautobot.apps.filters import NautobotFilterSet
 from nautobot.core.filters import ContentTypeMultipleChoiceFilter, SearchFilter
 from nautobot.data_validation.models import (
     DataCompliance,
@@ -9,6 +8,7 @@ from nautobot.data_validation.models import (
     RequiredValidationRule,
     UniqueValidationRule,
 )
+from nautobot.extras.filters import NautobotFilterSet
 from nautobot.extras.utils import FeatureQuery