nautobot 2.1.7__py3-none-any.whl → 2.1.9__py3-none-any.whl

nautobot/dcim/tests/test_filters.py

@@ -1268,39 +1268,11 @@ class PlatformTestCase(FilterTestCases.NameOnlyFilterTestCase):
         params = {"devices": [devices[0].pk, devices[1].pk]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), len(devices))
 
-    def test_has_devices(self):
-        with self.subTest():
-            params = {"has_devices": True}
-            self.assertQuerysetEqual(
-                self.filterset(params, self.queryset).qs,
-                self.queryset.exclude(devices__isnull=True),
-            )
-        with self.subTest():
-            params = {"has_devices": False}
-            self.assertQuerysetEqual(
-                self.filterset(params, self.queryset).qs,
-                self.queryset.exclude(devices__isnull=False),
-            )
-
     def test_virtual_machines(self):
         virtual_machines = [VirtualMachine.objects.first(), VirtualMachine.objects.last()]
         params = {"virtual_machines": [virtual_machines[0].pk, virtual_machines[1].pk]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), len(virtual_machines))
 
-    def test_has_virtual_machines(self):
-        with self.subTest():
-            params = {"has_virtual_machines": True}
-            self.assertQuerysetEqual(
-                self.filterset(params, self.queryset).qs,
-                self.queryset.exclude(virtual_machines__isnull=True),
-            )
-        with self.subTest():
-            params = {"has_virtual_machines": False}
-            self.assertQuerysetEqual(
-                self.filterset(params, self.queryset).qs,
-                self.queryset.exclude(virtual_machines__isnull=False),
-            )
-
 
 class DeviceTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = Device.objects.all()

nautobot/dcim/views.py

@@ -11,7 +11,7 @@ from django.forms import (
     ModelMultipleChoiceField,
     MultipleHiddenInput,
 )
-from django.shortcuts import get_object_or_404, redirect, render
+from django.shortcuts import get_object_or_404, HttpResponse, redirect, render
 from django.utils.functional import cached_property
 from django.utils.html import format_html
 from django.views.generic import View
@@ -2316,7 +2316,7 @@ class CableCreateView(generic.ObjectEditView):
             "rear-port": forms.ConnectCableToRearPortForm,
             "power-feed": forms.ConnectCableToPowerFeedForm,
             "circuit-termination": forms.ConnectCableToCircuitTerminationForm,
-        }[kwargs.get("termination_b_type")]
+        }.get(kwargs.get("termination_b_type"), None)
 
         return super().dispatch(request, *args, **kwargs)
 
@@ -2333,6 +2333,9 @@ class CableCreateView(generic.ObjectEditView):
         return obj
 
     def get(self, request, *args, **kwargs):
+        if self.model_form is None:
+            return HttpResponse(status_code=400)
+
         obj = self.alter_obj(self.get_object(kwargs), request, args, kwargs)
 
         # Parse initial data manually to avoid setting field values as lists

nautobot/extras/api/urls.py

@@ -2,8 +2,7 @@ from nautobot.core.api.routers import OrderedDefaultRouter
 
 from . import views
 
-router = OrderedDefaultRouter()
-router.APIRootView = views.ExtrasRootView
+router = OrderedDefaultRouter(view_name="Extras")
 
 # Computed Fields
 router.register("computed-fields", views.ComputedFieldViewSet)

nautobot/extras/api/views.py

@@ -16,7 +16,6 @@ from rest_framework.exceptions import MethodNotAllowed, PermissionDenied, Valida
 from rest_framework.parsers import JSONParser, MultiPartParser
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
-from rest_framework.routers import APIRootView
 
 from nautobot.core.api.authentication import TokenPermissions
 from nautobot.core.api.utils import get_serializer_for_model
@@ -74,15 +73,6 @@ from nautobot.extras.utils import get_worker_count
 from . import serializers
 
 
-class ExtrasRootView(APIRootView):
-    """
-    Extras API root view
-    """
-
-    def get_view_name(self):
-        return "Extras"
-
-
 class NotesViewSetMixin:
     def restrict_queryset(self, request, *args, **kwargs):
         """

nautobot/extras/choices.py

@@ -64,11 +64,25 @@ class CustomFieldTypeChoices(ChoiceSet):
         (TYPE_MARKDOWN, "Markdown"),
     )
 
+    # Types that support validation_minimum/validation_maximum
+    MIN_MAX_TYPES = (
+        TYPE_TEXT,
+        TYPE_INTEGER,
+        TYPE_URL,
+        TYPE_SELECT,
+        TYPE_MULTISELECT,
+        TYPE_JSON,
+        TYPE_MARKDOWN,
+    )
+
+    # Types that support validation_regex
     REGEX_TYPES = (
         TYPE_TEXT,
         TYPE_URL,
         TYPE_SELECT,
         TYPE_MULTISELECT,
+        TYPE_JSON,
+        TYPE_MARKDOWN,
     )
 
 

nautobot/extras/models/customfields.py

@@ -1,11 +1,12 @@
 from collections import OrderedDict
 from datetime import date, datetime
-from functools import lru_cache
+import json
 import logging
 import re
 
 from django import forms
 from django.contrib.contenttypes.models import ContentType
+from django.core.cache import cache
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.serializers.json import DjangoJSONEncoder
 from django.core.validators import RegexValidator, ValidationError
@@ -46,13 +47,20 @@ logger = logging.getLogger(__name__)
 class ComputedFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
     use_in_migrations = True
 
-    @lru_cache(maxsize=128)
     def get_for_model(self, model):
         """
         Return all ComputedFields assigned to the given model.
         """
-        content_type = ContentType.objects.get_for_model(model._meta.concrete_model)
-        return self.get_queryset().filter(content_type=content_type)
+        concrete_model = model._meta.concrete_model
+        cache_key = f"{self.get_for_model.cache_key_prefix}.{concrete_model._meta.label_lower}"
+        queryset = cache.get(cache_key)
+        if queryset is None:
+            content_type = ContentType.objects.get_for_model(concrete_model)
+            queryset = self.get_queryset().filter(content_type=content_type)
+            cache.set(cache_key, queryset)
+        return queryset
+
+    get_for_model.cache_key_prefix = "nautobot.extras.computedfield.get_for_model"
 
 
 @extras_features("graphql")
@@ -298,7 +306,6 @@ class CustomFieldModel(models.Model):
 class CustomFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
     use_in_migrations = True
 
-    @lru_cache(maxsize=128)
     def get_for_model(self, model, exclude_filter_disabled=False):
         """
         Return all CustomFields assigned to the given model.
@@ -307,11 +314,20 @@ class CustomFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
             model: The django model to which custom fields are registered
             exclude_filter_disabled: Exclude any custom fields which have filter logic disabled
         """
-        content_type = ContentType.objects.get_for_model(model._meta.concrete_model)
-        qs = self.get_queryset().filter(content_types=content_type)
-        if exclude_filter_disabled:
-            qs = qs.exclude(filter_logic=CustomFieldFilterLogicChoices.FILTER_DISABLED)
-        return qs
+        concrete_model = model._meta.concrete_model
+        cache_key = (
+            f"{self.get_for_model.cache_key_prefix}.{concrete_model._meta.label_lower}.{exclude_filter_disabled}"
+        )
+        queryset = cache.get(cache_key)
+        if queryset is None:
+            content_type = ContentType.objects.get_for_model(concrete_model)
+            queryset = self.get_queryset().filter(content_types=content_type)
+            if exclude_filter_disabled:
+                queryset = queryset.exclude(filter_logic=CustomFieldFilterLogicChoices.FILTER_DISABLED)
+            cache.set(cache_key, queryset)
+        return queryset
+
+    get_for_model.cache_key_prefix = "nautobot.extras.customfield.get_for_model"
 
 
 @extras_features("webhooks")
@@ -375,13 +391,13 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
         blank=True,
         null=True,
         verbose_name="Minimum value",
-        help_text="Minimum allowed value (for numeric fields).",
+        help_text="Minimum allowed value (for numeric fields) or length (for text fields).",
     )
     validation_maximum = models.BigIntegerField(
         blank=True,
         null=True,
         verbose_name="Maximum value",
-        help_text="Maximum allowed value (for numeric fields).",
+        help_text="Maximum allowed value (for numeric fields) or length (for text fields).",
     )
     validation_regex = models.CharField(
         blank=True,
@@ -449,16 +465,16 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
             except ValidationError as err:
                 raise ValidationError({"default": f'Invalid default value "{self.default}": {err.message}'})
 
-        # Minimum/maximum values can be set only for numeric fields
-        if self.validation_minimum is not None and self.type != CustomFieldTypeChoices.TYPE_INTEGER:
-            raise ValidationError({"validation_minimum": "A minimum value may be set only for numeric fields"})
-        if self.validation_maximum is not None and self.type != CustomFieldTypeChoices.TYPE_INTEGER:
-            raise ValidationError({"validation_maximum": "A maximum value may be set only for numeric fields"})
+        # Minimum/maximum values can be set only for fields that support them
+        if self.validation_minimum is not None and self.type not in CustomFieldTypeChoices.MIN_MAX_TYPES:
+            raise ValidationError({"validation_minimum": "A minimum value may not be set for fields of this type"})
+        if self.validation_maximum is not None and self.type not in CustomFieldTypeChoices.MIN_MAX_TYPES:
+            raise ValidationError({"validation_maximum": "A maximum value may not be set for fields of this type"})
 
         # Regex validation can be set only for text, url, select and multi-select fields
         if self.validation_regex and self.type not in CustomFieldTypeChoices.REGEX_TYPES:
             raise ValidationError(
-                {"validation_regex": "Regular expression validation is supported only for text, URL and select fields"}
+                {"validation_regex": "Regular expression validation is not supported for fields of this type"}
             )
 
         # Choices can be set only on selection fields
@@ -525,13 +541,35 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
                 widget=DatePicker(),
             )
 
-        # Text and URL
-        elif self.type in (CustomFieldTypeChoices.TYPE_URL, CustomFieldTypeChoices.TYPE_TEXT):
+        # Text-like fields
+        elif self.type in (
+            CustomFieldTypeChoices.TYPE_URL,
+            CustomFieldTypeChoices.TYPE_TEXT,
+            CustomFieldTypeChoices.TYPE_MARKDOWN,
+        ):
             if self.type == CustomFieldTypeChoices.TYPE_URL:
-                field = LaxURLField(required=required, initial=initial)
+                field = LaxURLField(
+                    required=required,
+                    initial=initial,
+                    min_length=self.validation_minimum,
+                    max_length=self.validation_maximum,
+                )
             elif self.type == CustomFieldTypeChoices.TYPE_TEXT:
-                field = forms.CharField(max_length=255, required=required, initial=initial)
-
+                field = forms.CharField(
+                    required=required,
+                    initial=initial,
+                    min_length=self.validation_minimum,
+                    max_length=self.validation_maximum,
+                )
+            elif self.type == CustomFieldTypeChoices.TYPE_MARKDOWN:
+                field = CommentField(
+                    required=required,
+                    initial=initial,
+                    widget=SmallTextarea,
+                    label=None,
+                    min_length=self.validation_minimum,
+                    max_length=self.validation_maximum,
+                )
             if self.validation_regex:
                 field.validators = [
                     RegexValidator(
@@ -540,12 +578,10 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
                     )
                 ]
 
-        # Markdown
-        elif self.type == CustomFieldTypeChoices.TYPE_MARKDOWN:
-            field = CommentField(widget=SmallTextarea, label=None)
-
         # JSON
         elif self.type == CustomFieldTypeChoices.TYPE_JSON:
+            # Unlike the above cases, we don't apply min_length/max_length to the field,
+            # nor do we add a RegexValidator to the field, as these all apply after parsing and validating the JSON
             if simple_json_filter:
                 field = JSONField(encoder=DjangoJSONEncoder, required=required, initial=None, widget=TextInput)
             else:
@@ -606,15 +642,33 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
         """
         if value not in [None, "", []]:
             # Validate text field
-            if self.type in (CustomFieldTypeChoices.TYPE_TEXT, CustomFieldTypeChoices.TYPE_URL):
+            if self.type in (
+                CustomFieldTypeChoices.TYPE_TEXT,
+                CustomFieldTypeChoices.TYPE_URL,
+                CustomFieldTypeChoices.TYPE_MARKDOWN,
+            ):
                 if not isinstance(value, str):
                     raise ValidationError("Value must be a string")
-
+                if self.validation_minimum is not None and len(value) < self.validation_minimum:
+                    raise ValidationError(f"Value must be at least {self.validation_minimum} characters in length")
+                if self.validation_maximum is not None and len(value) > self.validation_maximum:
+                    raise ValidationError(f"Value must not exceed {self.validation_maximum} characters in length")
                 if self.validation_regex and not re.search(self.validation_regex, value):
                     raise ValidationError(f"Value must match regex '{self.validation_regex}'")
 
+            # Validate JSON
+            elif self.type == CustomFieldTypeChoices.TYPE_JSON:
+                if self.validation_regex or self.validation_minimum is not None or self.validation_maximum is not None:
+                    json_value = json.dumps(value)
+                    if self.validation_minimum is not None and len(json_value) < self.validation_minimum:
+                        raise ValidationError(f"Value must be at least {self.validation_minimum} characters in length")
+                    if self.validation_maximum is not None and len(json_value) > self.validation_maximum:
+                        raise ValidationError(f"Value must not exceed {self.validation_maximum} characters in length")
+                    if self.validation_regex and not re.search(self.validation_regex, json_value):
+                        raise ValidationError(f"Value must match regex '{self.validation_regex}'")
+
             # Validate integer
-            if self.type == CustomFieldTypeChoices.TYPE_INTEGER:
+            elif self.type == CustomFieldTypeChoices.TYPE_INTEGER:
                 try:
                     value = int(value)
                 except ValueError:
@@ -625,14 +679,14 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
                     raise ValidationError(f"Value must not exceed {self.validation_maximum}")
 
             # Validate boolean
-            if self.type == CustomFieldTypeChoices.TYPE_BOOLEAN:
+            elif self.type == CustomFieldTypeChoices.TYPE_BOOLEAN:
                 try:
                     value = is_truthy(value)
                 except ValueError as exc:
                     raise ValidationError("Value must be true or false.") from exc
 
             # Validate date
-            if self.type == CustomFieldTypeChoices.TYPE_DATE:
+            elif self.type == CustomFieldTypeChoices.TYPE_DATE:
                 if not isinstance(value, date):
                     try:
                         datetime.strptime(value, "%Y-%m-%d")
@@ -640,13 +694,13 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
                         raise ValidationError("Date values must be in the format YYYY-MM-DD.")
 
             # Validate selected choice
-            if self.type == CustomFieldTypeChoices.TYPE_SELECT:
+            elif self.type == CustomFieldTypeChoices.TYPE_SELECT:
                 if value not in self.custom_field_choices.values_list("value", flat=True):
                     raise ValidationError(
                         f"Invalid choice ({value}). Available choices are: {', '.join(self.custom_field_choices.values_list('value', flat=True))}"
                     )
 
-            if self.type == CustomFieldTypeChoices.TYPE_MULTISELECT:
+            elif self.type == CustomFieldTypeChoices.TYPE_MULTISELECT:
                 if isinstance(value, str):
                     value = value.split(",")
                 if not set(value).issubset(self.custom_field_choices.values_list("value", flat=True)):
@@ -706,6 +760,11 @@ class CustomFieldChoice(BaseModel, ChangeLoggedModel):
         if self.custom_field.type not in (CustomFieldTypeChoices.TYPE_SELECT, CustomFieldTypeChoices.TYPE_MULTISELECT):
             raise ValidationError("Custom field choices can only be assigned to selection fields.")
 
+        if self.custom_field.validation_minimum is not None and len(self.value) < self.custom_field.validation_minimum:
+            raise ValidationError(f"Value must be at least {self.custom_field.validation_minimum} characters long.")
+        if self.custom_field.validation_maximum is not None and len(self.value) > self.custom_field.validation_maximum:
+            raise ValidationError(f"Value must not exceed {self.custom_field.validation_maximum} characters long.")
+
         if not re.search(self.custom_field.validation_regex, self.value):
             raise ValidationError(f"Value must match regex {self.custom_field.validation_regex} got {self.value}.")
 

nautobot/extras/models/groups.py

@@ -325,7 +325,7 @@ class DynamicGroup(OrganizationalModel):
     @property
     def members_cache_key(self):
         """Return the cache key for this group's members."""
-        return f"{self.__class__.__name__}.{self.id}.members_cached"
+        return f"nautobot.extras.dynamicgroup.{self.id}.members_cached"
 
     @property
     def members_cached(self):

nautobot/extras/models/relationships.py

@@ -1,9 +1,9 @@
-from functools import lru_cache
 import logging
 
 from django import forms
 from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
 from django.contrib.contenttypes.models import ContentType
+from django.core.cache import cache
 from django.core.exceptions import ValidationError
 from django.core.serializers.json import DjangoJSONEncoder
 from django.db import models
@@ -329,7 +329,6 @@ class RelationshipModel(models.Model):
 class RelationshipManager(BaseManager.from_queryset(RestrictedQuerySet)):
     use_in_migrations = True
 
-    @lru_cache(maxsize=128)
     def get_for_model(self, model, hidden=None):
         """
         Return all Relationships assigned to the given model.
@@ -345,7 +344,6 @@ class RelationshipManager(BaseManager.from_queryset(RestrictedQuerySet)):
             self.get_for_model_destination(model, hidden=hidden),
         )
 
-    @lru_cache(maxsize=128)
     def get_for_model_source(self, model, hidden=None):
         """
         Return all Relationships assigned to the given model for the source side only.
@@ -354,15 +352,21 @@ class RelationshipManager(BaseManager.from_queryset(RestrictedQuerySet)):
             model (Model): The django model to which relationships are registered
             hidden (bool): Filter based on the value of the hidden flag, or None to not apply this filter
         """
-        content_type = ContentType.objects.get_for_model(model._meta.concrete_model)
-        result = (
-            self.get_queryset().filter(source_type=content_type).select_related("source_type", "destination_type")
-        )  # You almost always will want access to the source_type/destination_type
-        if hidden is not None:
-            result = result.filter(source_hidden=hidden)
-        return result
-
-    @lru_cache(maxsize=128)
+        concrete_model = model._meta.concrete_model
+        cache_key = f"{self.get_for_model_source.cache_key_prefix}.{concrete_model._meta.label_lower}.{hidden}"
+        queryset = cache.get(cache_key)
+        if queryset is None:
+            content_type = ContentType.objects.get_for_model(concrete_model)
+            queryset = (
+                self.get_queryset().filter(source_type=content_type).select_related("source_type", "destination_type")
+            )  # You almost always will want access to the source_type/destination_type
+            if hidden is not None:
+                queryset = queryset.filter(source_hidden=hidden)
+            cache.set(cache_key, queryset)
+        return queryset
+
+    get_for_model_source.cache_key_prefix = "nautobot.extras.relationship.get_for_model_source"
+
     def get_for_model_destination(self, model, hidden=None):
         """
         Return all Relationships assigned to the given model for the destination side only.
@@ -371,13 +375,22 @@ class RelationshipManager(BaseManager.from_queryset(RestrictedQuerySet)):
             model (Model): The django model to which relationships are registered
             hidden (bool): Filter based on the value of the hidden flag, or None to not apply this filter
         """
-        content_type = ContentType.objects.get_for_model(model._meta.concrete_model)
-        result = (
-            self.get_queryset().filter(destination_type=content_type).select_related("source_type", "destination_type")
-        )  # You almost always will want access to the source_type/destination_type
-        if hidden is not None:
-            result = result.filter(destination_hidden=hidden)
-        return result
+        concrete_model = model._meta.concrete_model
+        cache_key = f"{self.get_for_model_destination.cache_key_prefix}.{concrete_model._meta.label_lower}.{hidden}"
+        queryset = cache.get(cache_key)
+        if queryset is None:
+            content_type = ContentType.objects.get_for_model(concrete_model)
+            queryset = (
+                self.get_queryset()
+                .filter(destination_type=content_type)
+                .select_related("source_type", "destination_type")
+            )  # You almost always will want access to the source_type/destination_type
+            if hidden is not None:
+                queryset = queryset.filter(destination_hidden=hidden)
+            cache.set(cache_key, queryset)
+        return queryset
+
+    get_for_model_destination.cache_key_prefix = "nautobot.extras.relationship.get_for_model_destination"
 
     def get_required_for_model(self, model):
         """

nautobot/extras/navigation.py

@@ -66,7 +66,7 @@ menu_items = (
                         name="Roles",
                         weight=100,
                         permissions=[
-                            "extras.view_status",
+                            "extras.view_role",
                         ],
                         buttons=(
                             NavMenuAddButton(
@@ -120,7 +120,7 @@ menu_items = (
                     ),
                     NavMenuItem(
                         link="extras:secretsgroup_list",
-                        name="Secret Groups",
+                        name="Secrets Groups",
                         weight=200,
                         permissions=["extras.view_secretsgroup"],
                         buttons=(
@@ -154,6 +154,7 @@ menu_items = (
                         weight=200,
                         permissions=[
                             "extras.view_job",
+                            "extras.view_scheduledjob",
                         ],
                         buttons=(),
                     ),

nautobot/extras/plugins/__init__.py

@@ -331,6 +331,14 @@ class TemplateExtension:
         """
         raise NotImplementedError
 
+    def list_buttons(self):
+        """
+        Buttons that will be rendered and added to the existing list of buttons on the list page view. Content
+        should be returned as an HTML string. Note that content does not need to be marked as safe because this is
+        automatically handled.
+        """
+        raise NotImplementedError
+
     def detail_tabs(self):
         """
         Tabs that will be rendered and added to the existing list of tabs on the detail page view.

nautobot/extras/plugins/views.py

@@ -2,7 +2,6 @@ from collections import OrderedDict
 
 from django.apps import apps
 from django.conf import settings
-from django.contrib.auth.mixins import LoginRequiredMixin
 from django.http import Http404
 from django.shortcuts import render
 from django.urls.exceptions import NoReverseMatch
@@ -14,8 +13,9 @@ from rest_framework.response import Response
 from rest_framework.reverse import reverse
 from rest_framework.views import APIView
 
-from nautobot.core.api.views import NautobotAPIVersionMixin
+from nautobot.core.api.views import AuthenticatedAPIRootView, NautobotAPIVersionMixin
 from nautobot.core.forms import TableConfigForm
+from nautobot.core.views.generic import GenericView
 from nautobot.core.views.mixins import AdminRequiredMixin
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.extras.plugins.tables import InstalledPluginsTable
@@ -67,7 +67,7 @@ class InstalledPluginsView(AdminRequiredMixin, View):
         )
 
 
-class InstalledPluginDetailView(LoginRequiredMixin, View):
+class InstalledPluginDetailView(GenericView):
     """
     View for showing details of an installed plugin.
     """
@@ -92,7 +92,6 @@ class InstalledPluginsAPIView(NautobotAPIVersionMixin, APIView):
     """
 
     permission_classes = [permissions.IsAdminUser]
-    _ignore_model_permissions = True
 
     def get_view_name(self):
         return "Installed Plugins"
@@ -128,11 +127,9 @@ class InstalledPluginsAPIView(NautobotAPIVersionMixin, APIView):
         return Response([self._get_plugin_data(apps.get_app_config(plugin)) for plugin in settings.PLUGINS])
 
 
-class PluginsAPIRootView(NautobotAPIVersionMixin, APIView):
-    _ignore_model_permissions = True
-
-    def get_view_name(self):
-        return "Plugins"
+class PluginsAPIRootView(AuthenticatedAPIRootView):
+    name = "Apps"
+    description = "API extension point for installed Nautobot Apps"
 
     @staticmethod
     def _get_plugin_entry(plugin, app_config, request, format_):

nautobot/extras/querysets.py

@@ -210,7 +210,7 @@ class DynamicGroupQuerySet(RestrictedQuerySet):
         Return the cache key for the queryset of `DynamicGroup` objects that are eligible to potentially contain the
         given object.
         """
-        return f"{obj._meta.label_lower}._get_eligible_dynamic_groups"
+        return f"nautobot.{obj._meta.label_lower}._get_eligible_dynamic_groups"
 
     def _get_eligible_dynamic_groups(self, obj, use_cache=False):
         """

nautobot/extras/signals.py

@@ -1,3 +1,4 @@
+import contextlib
 import contextvars
 from datetime import timedelta
 import logging
@@ -18,6 +19,7 @@ from django.db.models.signals import m2m_changed, post_delete, post_save, pre_de
 from django.dispatch import receiver
 from django.utils import timezone
 from django_prometheus.models import model_deletes, model_inserts, model_updates
+import redis.exceptions
 
 from nautobot.core.celery import app, import_jobs_as_celery_tasks
 from nautobot.core.utils.config import get_settings_or_config
@@ -65,8 +67,8 @@ def _get_user_if_authenticated(user, instance):
 @receiver(post_save)
 @receiver(m2m_changed)
 @receiver(post_delete)
-def invalidate_lru_cache(sender, **kwargs):
-    """Invalidate the LRU cache for ComputedFields, CustomFields and Relationships."""
+def invalidate_models_cache(sender, **kwargs):
+    """Invalidate the related-models cache for ComputedFields, CustomFields and Relationships."""
     if sender is CustomField.content_types.through:
         manager = CustomField.objects
     elif sender in (ComputedField, CustomField, Relationship):
@@ -80,9 +82,13 @@ def invalidate_lru_cache(sender, **kwargs):
         "get_for_model_destination",
     )
 
-    for method in cached_methods:
-        if hasattr(manager, method):
-            getattr(manager, method).cache_clear()
+    for method_name in cached_methods:
+        if hasattr(manager, method_name):
+            method = getattr(manager, method_name)
+            if hasattr(method, "cache_key_prefix"):
+                with contextlib.suppress(redis.exceptions.ConnectionError):
+                    # TODO: *maybe* target more narrowly, e.g. only clear the cache for specific related content-types?
+                    cache.delete_pattern(f"{method.cache_key_prefix}.*")
 
 
 @receiver(post_save)
@@ -343,7 +349,7 @@ def dynamic_group_eligible_groups_changed(sender, instance, **kwargs):
         return
 
     content_type = instance.content_type
-    cache_key = f"{content_type.app_label}.{content_type.model}._get_eligible_dynamic_groups"
+    cache_key = f"nautobot.{content_type.app_label}.{content_type.model}._get_eligible_dynamic_groups"
     cache.set(
         cache_key,
         DynamicGroup.objects.filter(content_type_id=instance.content_type_id),