nautobot 2.4.21__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/core/graphql/utils.py

@@ -9,7 +9,6 @@ from nautobot.core.filters import (
     MultiValueFloatFilter,
     MultiValueNumberFilter,
 )
-from nautobot.core.graphql import BigInteger
 from nautobot.core.models.fields import slugify_dashes_to_underscores
 
 logger = logging.getLogger(__name__)
@@ -41,7 +40,7 @@ def get_filtering_args_from_filterset(filterset_class):
         (dict[graphene.Argument]): Filter Arguments organized in a dictionary
     """
 
-    args = {}
+    args = {"args": {}}
     instance = filterset_class()
 
     for filter_name, filter_field in instance.filters.items():
@@ -60,7 +59,7 @@ def get_filtering_args_from_filterset(filterset_class):
         filter_field_class = type(filter_field)
 
         if issubclass(filter_field_class, MultiValueBigNumberFilter):
-            field_type = graphene.List(BigInteger)
+            field_type = graphene.List(graphene.types.scalars.BigInt)
         elif issubclass(filter_field_class, (MultiValueFloatFilter, MultiValueDecimalFilter)):
             field_type = graphene.List(graphene.Float)
         elif issubclass(filter_field_class, MultiValueNumberFilter):
@@ -82,13 +81,12 @@ def get_filtering_args_from_filterset(filterset_class):
             required=False,
         )
 
-    # Hack to swap `type` fields to `_type` since they will conflict with
-    # `graphene.types.fields.Field.type` in Graphene 2.x.
-    # 2.0 TODO(jathan): Once we upgrade to Graphene 3.x we can remove this, but we
-    # will still need to do an API migration to deprecate it. This argument was
-    # validated to be safe to keep even in Graphene 3.
+    # Hack to avoid conflict with `graphene.types.field.Field.description`.
+    if "description" in args:
+        args["args"].update({"description": args.pop("description")})
     if "type" in args:
-        args["_type"] = args.pop("type")
+        # for backwards compatibility with our filters in graphene v2 where `type` was a reserved keyword
+        args["args"].update({"_type": args["type"]})
 
     return args
 

nautobot/core/jobs/__init__.py

@@ -2,13 +2,16 @@ import codecs
 import contextlib
 from io import BytesIO
 
+from django.apps import apps as global_apps
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import (
     PermissionDenied,
 )
 from django.db import transaction
+from django.db.models import Q
 from django.http import QueryDict
+from django.urls import reverse
 from rest_framework import exceptions as drf_exceptions
 
 from nautobot.core.api.exceptions import SerializerNotFound
@@ -22,6 +25,12 @@ from nautobot.core.jobs.cleanup import LogsCleanup
 from nautobot.core.jobs.groups import RefreshDynamicGroupCacheJobButtonReceiver, RefreshDynamicGroupCaches
 from nautobot.core.utils.lookup import get_filterset_for_model
 from nautobot.core.utils.requests import get_filterable_params_from_filter_params
+from nautobot.data_validation import models
+from nautobot.data_validation.custom_validators import (
+    BaseValidator,
+    get_data_compliance_classes_from_git_repo,
+    get_data_compliance_rules_map,
+)
 from nautobot.extras.datasources import (
     ensure_git_repository,
     git_repository_dry_run,
@@ -33,12 +42,15 @@ from nautobot.extras.jobs import (
     ChoiceVar,
     FileVar,
     Job,
+    MultiChoiceVar,
     ObjectVar,
     RunJobTaskFailed,
     StringVar,
     TextVar,
 )
 from nautobot.extras.models import ExportTemplate, GitRepository, SavedView
+from nautobot.extras.plugins import CustomValidator, ValidationError
+from nautobot.extras.registry import registry
 
 name = "System Jobs"
 
@@ -372,6 +384,151 @@ class ImportObjects(Job):
             raise RunJobTaskFailed("CSV import not fully successful, see logs")
 
 
+def get_data_compliance_rules():
+    """Generate a list of Audit Ruleset classes that exist from the registry as well as from any Git Repositories."""
+    validators = []
+    for rule_sets in get_data_compliance_rules_map().values():
+        validators.extend(rule_sets)
+
+    # Get rules from Git Repositories
+    for repo in GitRepository.objects.get_for_provided_contents("data_validation.data_compliance_rule"):
+        validators.extend(get_data_compliance_classes_from_git_repo(repo))
+    return validators
+
+
+def get_data_compliance_choices():
+    """Get data compliance choices from registry as well as from any Git Repositories."""
+    choices = []
+    for ruleset_class in get_data_compliance_rules():
+        choices.append((ruleset_class.__name__, ruleset_class.__name__))
+
+    choices.sort()
+    return choices
+
+
+def clean_compliance_rules_results_for_instance(instance, excluded_pks):
+    """
+    Delete data compliance results generated from runs of RunRegisteredDataComplianceRules job,
+    which validates object against user-created rules.
+    e.g. UniqueValidationRules, RegularExpressionValidationRules, MinMaxValidationRules, and RequiredValidationRules.
+
+    The usage is that:
+    If the instance is valid against all user-created rules, then the previous data compliance results of the instance are deleted.
+    If the instance is invalid against any user-created rules, then this method deletes the existing data compliance results of the instance,
+    and preserves only the data compliance result from the most recent job run by including the pk of the result in the `excluded_pks` list.
+
+    Args:
+        instance: The validated object to clean compliance results for.
+        excluded_pks: List of primary keys of compliance results to exclude from deletion.
+    """
+    model_class = instance.__class__
+    model_custom_validators = registry["plugin_custom_validators"][model_class._meta.label_lower]
+    # Prep for compliance names to be deleted.
+    compliance_class_names_to_be_deleted = []
+    for cv in model_custom_validators:
+        if issubclass(cv, BaseValidator):
+            compliance_class_names_to_be_deleted.append(cv.__name__)
+
+    excluded_pks = excluded_pks or []
+    models.DataCompliance.objects.filter(
+        object_id=instance.id,
+        content_type=ContentType.objects.get_for_model(instance),
+        compliance_class_name__in=compliance_class_names_to_be_deleted,
+    ).exclude(pk__in=excluded_pks).delete()
+
+
+class RunRegisteredDataComplianceRules(Job):
+    """Run the validate function on all registered DataComplianceRule classes and, optionally, the built-in data validation rules."""
+
+    class Meta:
+        name = "Run Registered Data Compliance Rules"
+        description = "Runs selected Data Compliance rule classes."
+        has_sensitive_variables = False
+
+    selected_data_compliance_rules = MultiChoiceVar(
+        choices=get_data_compliance_choices,
+        label="Select Data Compliance Rules",
+        required=False,
+        description="Not selecting any rules will run all rules listed.",
+    )
+
+    run_user_created_rules_in_report = BooleanVar(
+        label="Run user created validation rules?", description="Include user created data validation rules in report."
+    )
+
+    def run(self, *args, **kwargs):
+        """Run the validate function on all given DataComplianceRule classes."""
+        selected_data_compliance_rules = kwargs.get("selected_data_compliance_rules", None)
+
+        compliance_classes = get_data_compliance_rules()
+
+        for compliance_class in sorted(
+            compliance_classes, key=lambda x: x.model.split(".")
+        ):  # sort by model.app_label and model.model_name
+            if selected_data_compliance_rules and compliance_class.__name__ not in selected_data_compliance_rules:
+                continue
+            self.logger.info(f"Running {compliance_class.__name__}")
+            app_label, model = compliance_class.model.split(".")
+            for obj in global_apps.get_model(app_label, model).objects.iterator():
+                ins = compliance_class(obj)
+                ins.enforce = False
+                ins.clean()
+
+        run_user_created_rules_in_report = kwargs.get("run_user_created_rules_in_report", False)
+        if run_user_created_rules_in_report:
+            self.logger.info("Running user created data validation rules")
+            self.report_for_validation_rules()
+
+        result_url = reverse("data_validation:datacompliance_list")
+        self.logger.info(f"View Data Compliance results [here]({result_url})")
+
+    @staticmethod
+    def report_for_validation_rules():
+        """Run built-in data validation rules and add to report."""
+        query = (
+            Q(uniquevalidationrule__isnull=False)  # pylint: disable=unsupported-binary-operation
+            | Q(regularexpressionvalidationrule__isnull=False)
+            | Q(minmaxvalidationrule__isnull=False)
+            | Q(requiredvalidationrule__isnull=False)
+        )
+
+        # Gather model classes that have any of the user created rules:
+        # UniqueValidationRules, RegularExpressionValidationRules, MinMaxValidationRules, and RequiredValidationRules.
+        model_classes = [ct.model_class() for ct in ContentType.objects.filter(query).distinct()]
+
+        # Gather custom validators of user created rules
+        validator_dicts = []
+        for model_class in model_classes:
+            model_custom_validators = registry["plugin_custom_validators"][model_class._meta.label_lower]
+            # Get only subclasses of BaseValidator
+            # BaseValidator is the validator that enforces the user created rules:
+            # UniqueValidationRules, RegularExpressionValidationRules, MinMaxValidationRules, and RequiredValidationRules.
+            # otherwise, we would get all validators (more than those dynamically created)
+            validator_dicts.extend(
+                [{cv: model_class} for cv in model_custom_validators if issubclass(cv, BaseValidator)]
+            )
+
+        # Run validation on existing objects and add to report
+        for validator_dict in validator_dicts:
+            for validator, class_name in validator_dict.items():
+                if validator.clean == CustomValidator.clean:
+                    continue
+
+                for validated_object in class_name.objects.iterator():
+                    try:
+                        validator(validated_object).clean(exclude_disabled_rules=False)
+                        clean_compliance_rules_results_for_instance(instance=validated_object, excluded_pks=[])
+                    except ValidationError as error:
+                        result = validator.get_compliance_result(
+                            validator,
+                            instance=validated_object,
+                            message=error.messages[0],
+                            attribute=next(iter(error.message_dict.keys())),
+                            valid=False,
+                        )
+                        clean_compliance_rules_results_for_instance(instance=validated_object, excluded_pks=[result.pk])
+
+
 jobs = [
     BulkDeleteObjects,
     BulkEditObjects,
@@ -382,5 +539,6 @@ jobs = [
     LogsCleanup,
     RefreshDynamicGroupCaches,
     RefreshDynamicGroupCacheJobButtonReceiver,
+    RunRegisteredDataComplianceRules,
 ]
 register_jobs(*jobs)

nautobot/core/management/commands/generate_test_data.py

@@ -133,6 +133,14 @@ class Command(BaseCommand):
             )
             from nautobot.tenancy.factory import TenantFactory, TenantGroupFactory
             from nautobot.users.factory import UserFactory
+            from nautobot.vpn.factory import (
+                VPNFactory,
+                VPNPhase1PolicyFactory,
+                VPNPhase2PolicyFactory,
+                VPNProfileFactory,
+                VPNTunnelEndpointFactory,
+                VPNTunnelFactory,
+            )
             from nautobot.wireless.factory import (
                 ControllerManagedDeviceGroupWithMembersFactory,
                 RadioProfileFactory,
@@ -171,14 +179,12 @@ class Command(BaseCommand):
         )
         # ...and some tags that apply to a random subset of content-types
         _create_batch(TagFactory, 15, description="on some content-types")
-        _create_batch(UserFactory, 5)
+        _create_batch(UserFactory, 10)
         _create_batch(SavedViewFactory, 20)
         _create_batch(ContactFactory, 20)
         _create_batch(TeamFactory, 20)
-        _create_batch(TenantGroupFactory, 10, description="without parents", has_parent=False)
-        _create_batch(TenantGroupFactory, 10, description="with parents", has_parent=True)
-        _create_batch(TenantFactory, 10, description="without a parent group", has_tenant_group=False)
-        _create_batch(TenantFactory, 10, description="with a parent group", has_tenant_group=True)
+        _create_batch(TenantGroupFactory, 30)
+        _create_batch(TenantFactory, 30)
         _create_batch(LocationTypeFactory, 7)  # only 7 unique LocationTypes are hard-coded presently
         # First 7 locations must be created in specific order so subsequent objects have valid parents to reference
         _create_batch(LocationFactory, 7, description="as structure", has_parent=True)
@@ -192,7 +198,7 @@ class Command(BaseCommand):
         _create_batch(VRFFactory, 20)
         _create_batch(VLANGroupFactory, 20)
         _create_batch(VLANFactory, 20)
-        for i in range(30):
+        for i in range(50):
             _create_batch(
                 PrefixFactory,
                 1,
@@ -207,7 +213,15 @@ class Command(BaseCommand):
                 prefix=f"2001:db8:0:{i}::/64",
                 type=PrefixTypeChoices.TYPE_CONTAINER,
             )
-        _create_batch(NamespaceFactory, 5, description="without any Prefixes or IPAddresses")
+        _create_batch(
+            NamespaceFactory, 5, description="with a Tenant and without any Prefixes or IPAddresses", has_tenant=True
+        )
+        _create_batch(
+            NamespaceFactory,
+            5,
+            description="without a Tenant and without any Prefixes or IPAddresses",
+            has_tenant=False,
+        )
         _create_batch(DeviceFamilyFactory, 20)
         _create_batch(ManufacturerFactory, 8)  # First 8 hard-coded Manufacturers
         _create_batch(PlatformFactory, 20, description="with Manufacturers", has_manufacturer=True)
@@ -222,7 +236,7 @@ class Command(BaseCommand):
         _create_batch(ConsoleServerPortTemplateFactory, 30)
         _create_batch(RearPortTemplateFactory, 30)
         _create_batch(FrontPortTemplateFactory, 30)
-        _create_batch(InterfaceTemplateFactory, 30)
+        _create_batch(InterfaceTemplateFactory, 50)
         _create_batch(PowerPortTemplateFactory, 30)
         _create_batch(PowerOutletTemplateFactory, 30)
         _create_batch(ModuleBayTemplateFactory, 60, description="without module families", has_module_family=False)
@@ -324,11 +338,16 @@ class Command(BaseCommand):
         _create_batch(WirelessNetworksWithMembersFactory, 5, description="with members")
         # make sure we have some supported data rates that have null relationships to make filter tests happy
         _create_batch(SupportedDataRateFactory, 10, description="without any associated objects")
+        _create_batch(VPNPhase1PolicyFactory, 10)
+        _create_batch(VPNPhase2PolicyFactory, 10)
+        _create_batch(VPNProfileFactory, 20)
+        _create_batch(VPNFactory, 10)
+        _create_batch(VPNTunnelEndpointFactory, 20)
+        _create_batch(VPNTunnelFactory, 10)
         _create_batch(JobQueueFactory, 10)
         # make sure we have some tenants that have null relationships to make filter tests happy
         _create_batch(TenantFactory, 10, description="without any associated objects")
         # TODO: nautobot.tenancy.tests.test_filters currently calls the following additional factories:
-        # _create_batch(UserFactory, 10)
         # _create_batch(RackFactory, 10)
         # _create_batch(RackReservationFactory, 10)
         # _create_batch(ClusterTypeFactory, 10)

nautobot/core/models/__init__.py

@@ -11,15 +11,23 @@ from django.utils.encoding import is_protected_type
 from django.utils.functional import classproperty
 
 from nautobot.core.models.managers import BaseManager
-from nautobot.core.models.querysets import CompositeKeyQuerySetMixin, RestrictedQuerySet
+from nautobot.core.models.querysets import (
+    ClusterToClustersQuerySetMixin,
+    CompositeKeyQuerySetMixin,
+    LocationToLocationsQuerySetMixin,
+    RestrictedQuerySet,
+)
 from nautobot.core.models.utils import construct_composite_key, construct_natural_slug, deconstruct_composite_key
+from nautobot.core.utils.cache import construct_cache_key
 from nautobot.core.utils.lookup import get_route_for_model
 
 __all__ = (
     "BaseManager",
     "BaseModel",
+    "ClusterToClustersQuerySetMixin",
     "CompositeKeyQuerySetMixin",
     "ContentTypeRelatedQuerySet",
+    "LocationToLocationsQuerySetMixin",
     "RestrictedQuerySet",
     "construct_composite_key",
     "construct_natural_slug",
@@ -53,6 +61,7 @@ class BaseModel(models.Model):
     is_metadata_associable_model = True
     is_saved_view_model = False  # SavedViewMixin overrides this to default True
     is_cloud_resource_type_model = False  # CloudResourceTypeMixin overrides this to default True
+    is_approval_workflow_model = False  # ApprovableModelMixin overrides this to default True
 
     associated_object_metadata = GenericRelation(
         "extras.ObjectMetadata",
@@ -60,6 +69,12 @@ class BaseModel(models.Model):
         object_id_field="assigned_object_id",
         related_query_name="associated_object_metadata_%(app_label)s_%(class)s",  # e.g. 'associated_object_metadata_dcim_device'
     )
+    associated_data_compliance = GenericRelation(
+        "data_validation.DataCompliance",
+        content_type_field="content_type",
+        object_id_field="object_id",
+        related_query_name="associated_data_compliance_%(app_label)s_%(class)s",  # e.g. 'associated_data_compliance_dcim_device'
+    )
 
     class Meta:
         abstract = True
@@ -108,7 +123,7 @@ class BaseModel(models.Model):
 
         Necessary for use with _content_type_cached and management commands.
         """
-        return f"nautobot.{cls._meta.label_lower}._content_type"
+        return construct_cache_key(cls, method_name="_content_type")
 
     @classproperty  # https://github.com/PyCQA/pylint-django/issues/240
     def _content_type_cached(cls):  # pylint: disable=no-self-argument

nautobot/core/models/fields.py

@@ -244,8 +244,9 @@ class NaturalOrderingField(models.CharField):
     """
     A field which stores a naturalized representation of its target field, to be used for ordering its parent model.
 
-    :param target_field: Name of the field of the parent model to be naturalized
-    :param naturalize_function: The function used to generate a naturalized value (optional)
+    Args:
+        target_field (str): Name of the field of the parent model to be naturalized
+        naturalize_function (function): The function used to generate a naturalized value (optional)
     """
 
     description = "Stores a representation of its target field suitable for natural ordering"

nautobot/core/models/generics.py

@@ -4,13 +4,20 @@ from nautobot.core.models import BaseModel
 from nautobot.core.models.fields import TagsField
 from nautobot.extras.models.change_logging import ChangeLoggedModel
 from nautobot.extras.models.customfields import CustomFieldModel
-from nautobot.extras.models.mixins import ContactMixin, DynamicGroupsModelMixin, NotesMixin, SavedViewMixin
+from nautobot.extras.models.mixins import (
+    ContactMixin,
+    DataComplianceModelMixin,
+    DynamicGroupsModelMixin,
+    NotesMixin,
+    SavedViewMixin,
+)
 from nautobot.extras.models.relationships import RelationshipModel
 
 logger = logging.getLogger(__name__)
 
 
 class OrganizationalModel(
+    DataComplianceModelMixin,
     ChangeLoggedModel,
     ContactMixin,
     CustomFieldModel,
@@ -35,6 +42,7 @@ class OrganizationalModel(
 
 
 class PrimaryModel(
+    DataComplianceModelMixin,
     ChangeLoggedModel,
     ContactMixin,
     CustomFieldModel,

nautobot/core/models/name_color_content_types.py

@@ -60,6 +60,6 @@ class NameColorContentTypesModel(
     def get_color_display(self):
         if self.color:
             return format_html(
-                '<span class="label color-block" style="background-color: #{}">&nbsp;</span>', self.color
+                '<span class="label nb-color-block" style="background-color: #{}">&nbsp;</span>', self.color
             )
         return helpers.placeholder(self.color)

nautobot/core/models/ordering.py

@@ -28,9 +28,10 @@ def naturalize(value, max_length, integer_places=8):
         location00000010router00000004
         location00000010router00000019
 
-    :param value: The value to be naturalized
-    :param max_length: The maximum length of the returned string. Characters beyond this length will be stripped.
-    :param integer_places: The number of places to which each integer will be expanded. (Default: 8)
+    Args:
+        value (str): The value to be naturalized
+        max_length (int): The maximum length of the returned string. Characters beyond this length will be stripped.
+        integer_places (int): The number of places to which each integer will be expanded. (Default: 8)
     """
     if not value:
         return value
@@ -50,8 +51,9 @@ def naturalize_interface(value, max_length):
     Similar in nature to naturalize(), but takes into account a particular naming format adapted from the old
     InterfaceManager.
 
-    :param value: The value to be naturalized
-    :param max_length: The maximum length of the returned string. Characters beyond this length will be stripped.
+    Args:
+        value (str): The value to be naturalized
+        max_length (int): The maximum length of the returned string. Characters beyond this length will be stripped.
     """
     output = ""
     match = re.search(INTERFACE_NAME_REGEX, value)

nautobot/core/models/querysets.py

@@ -1,3 +1,5 @@
+from typing import ClassVar
+
 from django.db.models import Count, OuterRef, Q, QuerySet, Subquery
 from django.db.models.functions import Coalesce
 
@@ -112,8 +114,9 @@ class RestrictedQuerySet(CompositeKeyQuerySetMixin, QuerySet):
         Filter the QuerySet to return only objects on which the specified user has been granted the specified
         permission.
 
-        :param user: User instance
-        :param action: The action which must be permitted (e.g. "view" for "dcim.view_location"); default is 'view'
+        Args:
+            user (User): User instance
+            action (str): The action which must be permitted (e.g. "view" for "dcim.view_location"); default is 'view'
         """
         # Resolve the full name of the required permission
         app_label = self.model._meta.app_label
@@ -185,3 +188,75 @@ class RestrictedQuerySet(CompositeKeyQuerySetMixin, QuerySet):
 
         """
         return self.order_by().values_list(*fields, flat=flat, named=named).distinct()
+
+
+class BaseManyToManyQuerySetMixin:
+    """
+    Base mixin to provide backward compatibility for fields that have been changed from ForeignKey to ManyToManyField.
+
+    Subclasses should define FIELD_MAP as a dictionary of field mappings, where the key is the old field name
+    and the value is the new field name.
+    """
+
+    FIELD_MAP: ClassVar[dict[str, str]] = {}
+
+    def __init_subclass__(cls, **kwargs):
+        """Combine FIELD_MAP from all parent classes into a single dictionary."""
+        super().__init_subclass__(**kwargs)
+        combined_field_map = {}
+        for base in reversed(cls.__mro__):
+            if hasattr(base, "FIELD_MAP") and isinstance(getattr(base, "FIELD_MAP"), dict):
+                combined_field_map.update(base.FIELD_MAP)
+        cls.FIELD_MAP = combined_field_map
+
+    def _convert_to_m2m_field(self, kwargs):
+        field_mappings = self.FIELD_MAP
+        if not field_mappings:
+            return kwargs
+
+        updated_kwargs = {}
+
+        for field, value in kwargs.items():
+            converted = False
+
+            # Check each field mapping
+            for old_field, new_field in field_mappings.items():
+                if field == old_field:
+                    # Direct field query becomes __in for ManyToMany
+                    updated_kwargs[f"{new_field}__in"] = [value]
+                    converted = True
+                    break
+                elif field.startswith(f"{old_field}__"):
+                    # Replace old field prefix with new field prefix
+                    updated_kwargs[field.replace(old_field, new_field, 1)] = value
+                    converted = True
+                    break
+
+            if not converted:
+                updated_kwargs[field] = value
+
+        return updated_kwargs
+
+    def filter(self, *args, **kwargs):
+        kwargs = self._convert_to_m2m_field(kwargs)
+        return super().filter(*args, **kwargs)
+
+    def exclude(self, *args, **kwargs):
+        kwargs = self._convert_to_m2m_field(kwargs)
+        return super().exclude(*args, **kwargs)
+
+
+class LocationToLocationsQuerySetMixin(BaseManyToManyQuerySetMixin):
+    """
+    Mixin to convert 'location' to 'locations' in queryset parameters.
+    """
+
+    FIELD_MAP = {"location": "locations"}
+
+
+class ClusterToClustersQuerySetMixin(BaseManyToManyQuerySetMixin):
+    """
+    Mixin to convert 'cluster' to 'clusters' in queryset parameters.
+    """
+
+    FIELD_MAP = {"cluster": "clusters"}

nautobot/core/models/tree_queries.py

@@ -9,6 +9,7 @@ from tree_queries.query import TreeManager as TreeManager_, TreeQuerySet as Tree
 
 from nautobot.core.models import BaseManager, querysets
 from nautobot.core.signals import invalidate_max_depth_cache
+from nautobot.core.utils.cache import construct_cache_key
 
 
 class TreeQuerySet(TreeQuerySet_, querysets.RestrictedQuerySet):
@@ -94,7 +95,7 @@ class TreeManager(TreeManager_, BaseManager.from_queryset(TreeQuerySet)):
 
     @property
     def max_depth_cache_key(self):
-        return f"nautobot.{self.model._meta.concrete_model._meta.label_lower}.max_depth"
+        return construct_cache_key(self, method_name="max_depth", branch_aware=True)
 
     @property
     def max_depth(self):
@@ -102,10 +103,11 @@ class TreeManager(TreeManager_, BaseManager.from_queryset(TreeQuerySet)):
 
         Generally TreeManagers are persistent objects while TreeQuerySets are not, hence the difference in behavior.
         """
-        max_depth = cache.get(self.max_depth_cache_key)
+        cache_key = self.max_depth_cache_key
+        max_depth = cache.get(cache_key)
         if max_depth is None:
             max_depth = self.max_tree_depth()
-            cache.set(self.max_depth_cache_key, max_depth)
+            cache.set(cache_key, max_depth)
         return max_depth
 
 
@@ -128,7 +130,7 @@ class TreeModel(TreeNode):
         """
         if not hasattr(self, "name"):
             raise NotImplementedError("default TreeModel.display implementation requires a `name` attribute!")
-        cache_key = f"nautobot.{self._meta.concrete_model._meta.label_lower}.{self.id}.display"
+        cache_key = construct_cache_key(self, method_name="display", branch_aware=True)
         display_str = cache.get(cache_key, "")
         if display_str:
             return display_str