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

nautobot/core/utils/lookup.py

@@ -1,17 +1,65 @@
 """Utilities for looking up related classes and information."""
 
 import inspect
+from operator import attrgetter
 import re
 
 from django.apps import apps
 from django.conf import settings
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
-from django.db.models import Model
+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):
+    """
+    Resolve nested attributes on a Django model instance using a Django-style
+    double-underscore path (e.g. 'location_type__nestable').
+
+    Args:
+        obj: A Django model instance.
+        dotted_field (str): Dotted path to the attribute using '__' for
+            nested relationships or foreign keys.
+
+    Returns:
+        str | None:
+            - The string representation of the resolved attribute value.
+            - If the attribute is boolean, returns the field label in title case
+              if True, or 'Not <Field Label>' if False.
+            - Returns None if any attribute in the path does not exist or is None.
+
+    Example:
+        >>> resolve_attr(location, "name")
+        'Aisle'
+
+        >>> resolve_attr(location, "location_type__nestable")
+        'Nestable'
+
+        >>> resolve_attr(location, "location_type__nestable")
+        'Not Nestable'
+    """
+    try:
+        val = attrgetter(dotted_field.replace("__", "."))(obj)
+    except (AttributeError, ObjectDoesNotExist):
+        return None
+
+    # to avoid circular import
+    from nautobot.core.templatetags.helpers import bettertitle
+
+    # handle booleans specially
+    if isinstance(val, bool):
+        attrs = dotted_field.split("__")
+        # take last part of dotted_field ("nestable" in "location_type__nestable")
+        field_label = bettertitle(attrs[-1].replace("_", " "))
+        return field_label if val else f"Not {field_label}"
+
+    return str(val) if val else None
+
 
 def get_changes_for_model(model):
     """
@@ -33,12 +81,14 @@ def get_changes_for_model(model):
 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.
 
-    :param model_name: Full dotted name for a model as a string (ex: `dcim.model`)
-    :type model_name: str
+    Args:
+        model_name (str): Full dotted name for a model as a string (ex: `dcim.model`)
 
-    :raises TypeError: If given model name is not found.
+    Raises:
+        TypeError: If given model name is not found.
 
-    :return: Found model.
+    Returns:
+        (Model): Found model.
     """
 
     try:
@@ -132,13 +182,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):
@@ -329,6 +373,34 @@ def get_created_and_last_updated_usernames_for_model(instance):
     return created_by, last_updated_by
 
 
+def get_user_from_instance(instance):
+    """
+    Retrieve the user object from a model instance, regardless of the field name.
+
+    This function inspects the given model instance to find a ForeignKey that points
+    to the current AUTH_USER_MODEL (as defined in Django settings). It does not require
+    the user-related field to have a fixed name (e.g., "user", "creator", "owner").
+
+    Args:
+        instance (models.Model): A Django model instance that may contain a ForeignKey
+            to the configured user model.
+
+    Returns:
+        User instance if a user-related ForeignKey exists and is populated,
+        otherwise None.
+
+    Example:
+        >>> schedule = ScheduledJob.objects.first()
+        >>> user = get_user_from_instance(schedule)
+        >>> print(user.username)
+    """
+    UserModel = settings.AUTH_USER_MODEL
+    for field in instance._meta.get_fields():
+        if isinstance(field, ForeignKey) and field.related_model._meta.label == UserModel:
+            return getattr(instance, field.name, None)
+    return None
+
+
 def get_url_patterns(urlconf=None, patterns_list=None, base_path="/", ignore_redirects=False):
     """
     Recursively yield a list of registered URL patterns.
@@ -427,6 +499,8 @@ def get_url_for_url_pattern(url_pattern):
     # Fixup tokens in path-style "classic" view URLs:
     # "/admin/users/user/<id>/password/"
     url = re.sub(r"<id>", "00000000-0000-0000-0000-000000000000", url)
+    # "/data-validation-engine/data-compliance/<model>/00000000-0000-0000-0000-000000000000/"
+    url = re.sub(r"<model>", "circuits.circuit", url)
     # "/silk/request/<uuid:request_id>/profile/<int:profile_id>/"
     url = re.sub(r"<int:\w+>", "1", url)
     # "/admin/admin/logentry/<path:object_id>/"

nautobot/core/utils/migrations.py

@@ -71,10 +71,12 @@ def migrate_content_type_references_to_new_model(apps, old_ct, new_ct):
 
     This will replace the old content type with the new content type on the following models:
         - ComputedField.content_type
+        - ContactAssociation.associated_object_type
         - CustomLink.content_type
         - ExportTemplate.content_type
         - Note.assigned_object_type
         - ObjectChange.changed_object_type
+        - ObjectMetadata.assigned_object_type
         - Relationship.source_type
         - Relationship.destination_type
         - RelationshipAssociation.source_type
@@ -86,7 +88,9 @@ def migrate_content_type_references_to_new_model(apps, old_ct, new_ct):
         - CustomField.content_types
         - JobButton.content_types
         - JobHook.content_types
+        - MetadataType.content_types
         - ObjectPermission.object_types
+        - Role.content_types
         - Status.content_types
         - Tag.content_types
         - WebHook.content_types
@@ -101,16 +105,20 @@ def migrate_content_type_references_to_new_model(apps, old_ct, new_ct):
 
     """
     ComputedField = apps.get_model("extras", "ComputedField")
+    ContactAssociation = apps.get_model("extras", "ContactAssociation")
     CustomField = apps.get_model("extras", "CustomField")
     CustomLink = apps.get_model("extras", "CustomLink")
     ExportTemplate = apps.get_model("extras", "ExportTemplate")
     JobButton = apps.get_model("extras", "JobButton")
     JobHook = apps.get_model("extras", "JobHook")
+    MetadataType = apps.get_model("extras", "MetadataType")
     Note = apps.get_model("extras", "Note")
     ObjectChange = apps.get_model("extras", "ObjectChange")
+    ObjectMetadata = apps.get_model("extras", "ObjectMetadata")
     ObjectPermission = apps.get_model("users", "ObjectPermission")
     Relationship = apps.get_model("extras", "Relationship")
     RelationshipAssociation = apps.get_model("extras", "RelationshipAssociation")
+    Role = apps.get_model("extras", "Role")
     Status = apps.get_model("extras", "Status")
     Tag = apps.get_model("extras", "Tag")
     TaggedItem = apps.get_model("extras", "TaggedItem")
@@ -119,6 +127,9 @@ def migrate_content_type_references_to_new_model(apps, old_ct, new_ct):
     # Migrate ComputedField content type
     ComputedField.objects.filter(content_type=old_ct).update(content_type=new_ct)
 
+    # Migrate ContactAssociation content type
+    ContactAssociation.objects.filter(associated_object_type=old_ct).update(associated_object_type=new_ct)
+
     # Migrate CustomField content type
     for cf in CustomField.objects.filter(content_types=old_ct):
         cf.content_types.add(new_ct)
@@ -137,12 +148,19 @@ def migrate_content_type_references_to_new_model(apps, old_ct, new_ct):
     for job_hook in JobHook.objects.filter(content_types=old_ct):
         job_hook.content_types.add(new_ct)
 
+    # Migrate MetadataType content type
+    for metadata_type in MetadataType.objects.filter(content_types=old_ct):
+        metadata_type.content_types.add(new_ct)
+
     # Migrate Note content type
     Note.objects.filter(assigned_object_type=old_ct).update(assigned_object_type=new_ct)
 
     # Migrate ObjectChange content type
     ObjectChange.objects.filter(changed_object_type=old_ct).update(changed_object_type=new_ct)
 
+    # Migrate ObjectMetadata content type
+    ObjectMetadata.objects.filter(assigned_object_type=old_ct).update(assigned_object_type=new_ct)
+
     # Migrate ObjectPermission content type
     for object_permission in ObjectPermission.objects.filter(object_types=old_ct):
         object_permission.object_types.add(new_ct)
@@ -155,6 +173,10 @@ def migrate_content_type_references_to_new_model(apps, old_ct, new_ct):
     RelationshipAssociation.objects.filter(source_type=old_ct).update(source_type=new_ct)
     RelationshipAssociation.objects.filter(destination_type=old_ct).update(destination_type=new_ct)
 
+    # Migrate Role content type
+    for role in Role.objects.filter(content_types=old_ct):
+        role.content_types.add(new_ct)
+
     # Migrate Status content type
     for status in Status.objects.filter(content_types=old_ct):
         status.content_types.add(new_ct)

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):
     """
@@ -77,6 +98,8 @@ def import_modules_privately(path, module_path=None, ignore_import_errors=True):
         module_prefix = None
     else:
         module_prefix = ".".join(module_path)
+
+    loaded_modules = []
     with _temporarily_add_to_sys_path(path):
         for finder, discovered_module_name, is_package in pkgutil.walk_packages([path], onerror=logger.error):
             if module_prefix and not (
@@ -114,7 +137,10 @@ def import_modules_privately(path, module_path=None, ignore_import_errors=True):
                 else:
                     module = importlib.import_module(discovered_module_name)
                 importlib.reload(module)
+                loaded_modules.append(module)
             except Exception as exc:
                 logger.error("Unable to load module %s from %s: %s", discovered_module_name, path, exc)
                 if not ignore_import_errors:
                     raise
+
+    return loaded_modules

nautobot/core/utils/permissions.py

@@ -7,8 +7,9 @@ def get_permission_for_model(model, action):
     """
     Resolve the named permission for a given model (or instance) and action (e.g. view or add).
 
-    :param model: A model or instance
-    :param action: View, add, change, or delete (string)
+    Args:
+        model (Any): A model or instance
+        action (str): View, add, change, or delete
     """
     if action not in ("view", "add", "change", "delete"):
         raise ValueError(f"Unsupported action: {action}")
@@ -21,7 +22,8 @@ def resolve_permission(name):
     Given a permission name, return the app_label, action, and model_name components. For example, "dcim.view_location"
     returns ("dcim", "view", "location").
 
-    :param name: Permission name in the format <app_label>.<action>_<model>
+    Args:
+        name (str): Permission name in the format `<app_label>.<action>_<model>`
     """
     try:
         app_label, codename = name.split(".")
@@ -37,7 +39,8 @@ def resolve_permission_ct(name):
     Given a permission name, return the relevant ContentType and action. For example, "dcim.view_location" returns
     (Location, "view").
 
-    :param name: Permission name in the format <app_label>.<action>_<model>
+    Args:
+        name (str): Permission name in the format `<app_label>.<action>_<model>`
     """
     app_label, action, model_name = resolve_permission(name)
     try:
@@ -52,7 +55,8 @@ def permission_is_exempt(name):
     """
     Determine whether a specified permission is exempt from evaluation.
 
-    :param name: Permission name in the format <app_label>.<action>_<model>
+    Args:
+        name (str): Permission name in the format `<app_label>.<action>_<model>`
     """
     app_label, action, model_name = resolve_permission(name)
 

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
@@ -47,11 +49,13 @@ from rest_framework.views import APIView
 
 from nautobot.core.celery import app
 from nautobot.core.constants import SEARCH_MAX_RESULTS
-from nautobot.core.forms import SearchForm
 from nautobot.core.releases import get_latest_release
+from nautobot.core.ui.breadcrumbs import Breadcrumbs, ViewNameBreadcrumbItem
+from nautobot.core.ui.titles import Titles
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
+from nautobot.core.views.mixins import UIComponentsMixin
 from nautobot.core.views.utils import (
     generate_latest_with_cache,
     is_metrics_experimental_caching_enabled,
@@ -59,7 +63,9 @@ 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
 
 logger = logging.getLogger(__name__)
 
@@ -107,7 +113,7 @@ class HomeView(AccessMixin, TemplateView):
         context = self.get_context_data()
         context.update(
             {
-                "search_form": SearchForm(),
+                "title": "Home",
                 "new_release": new_release,
             }
         )
@@ -141,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.
@@ -160,8 +200,9 @@ class MediaView(AccessMixin, View):
         return self.handle_no_permission()
 
 
-class WorkerStatusView(UserPassesTestMixin, TemplateView):
+class WorkerStatusView(UserPassesTestMixin, UIComponentsMixin, TemplateView):
     template_name = "utilities/worker_status.html"
+    view_titles = Titles(titles={"*": "Nautobot Worker Status"})
 
     def test_func(self):
         return self.request.user.is_staff
@@ -272,13 +313,24 @@ class WorkerStatusView(UserPassesTestMixin, TemplateView):
                 "timeout": timeout,
                 "workers": workers,
             },
+            "breadcrumbs": self.get_breadcrumbs(),
+            "view_titles": self.get_view_titles(),
         }
 
         return self.render_to_response(context)
 
 
-class ThemePreviewView(LoginRequiredMixin, TemplateView):
+class ThemePreviewView(LoginRequiredMixin, UIComponentsMixin, TemplateView):
     template_name = "utilities/theme_preview.html"
+    view_titles = Titles(titles={"*": "Nautobot Theme Preview"})
+    breadcrumbs = Breadcrumbs(
+        items={
+            "generic": [
+                ViewNameBreadcrumbItem(view_name="home", label="Nautobot"),
+                ViewNameBreadcrumbItem(view_name="theme_preview", label="Theme Preview"),
+            ],
+        },
+    )
 
     def get_context_data(self, **kwargs):
         return {
@@ -286,6 +338,10 @@ class ThemePreviewView(LoginRequiredMixin, TemplateView):
             "object": Status.objects.first(),
             "verbose_name": Status.objects.all().model._meta.verbose_name,
             "verbose_name_plural": Status.objects.all().model._meta.verbose_name_plural,
+            "table": StatusTable(Status.objects.all()[:3]),
+            "view_titles": self.get_view_titles(),
+            "breadcrumbs": self.get_breadcrumbs(),
+            "view_action": "generic",
         }
 
 
@@ -298,70 +354,57 @@ class SearchView(AccessMixin, View):
 
         # No query
         if "q" not in request.GET:
-            return render(
-                request,
-                "search.html",
-                {
-                    "form": SearchForm(),
-                },
-            )
+            return render(request, "search.html", {})
 
-        form = SearchForm(request.GET)
         results = []
 
-        if form.is_valid():
-            # Build the list of (app_label, modelname) tuples, representing all models included in the global search,
-            # based on the `app_config.searchable_models` list (if any) defined by each app
-            searchable_models = []
-            for app_config in apps.get_app_configs():
-                if hasattr(app_config, "searchable_models"):
-                    searchable_models += [(app_config.label, modelname) for modelname in app_config.searchable_models]
-
-            if form.cleaned_data["obj_type"]:
-                # Searching for a single type of object
-                obj_types = [form.cleaned_data["obj_type"]]
-            else:
-                # Searching all object types
-                obj_types = [model_info[1] for model_info in searchable_models]
-
-            for label, modelname in searchable_models:
-                if modelname not in obj_types:
-                    continue
-                # Based on the label and modelname, reverse-lookup the list URL, then the view or UIViewSet
-                # corresponding to that URL, and finally the queryset, filterset, and table classes needed
-                # to find and display the model search results.
-                url = get_route_for_model(f"{label}.{modelname}", "list")
-                try:
-                    view_func = resolve(reverse(url)).func
-                    # For UIViewSet, view_func.cls gets what we need; for an ObjectListView, view_func.view_class is it.
-                    view_or_viewset = getattr(view_func, "cls", getattr(view_func, "view_class", None))
-                    queryset = view_or_viewset.queryset.restrict(request.user, "view")
-                    # For a UIViewSet, .filterset_class, for an ObjectListView, .filterset.
-                    filterset = getattr(view_or_viewset, "filterset_class", getattr(view_or_viewset, "filterset", None))
-                    # For a UIViewSet, .table_class, for an ObjectListView, .table.
-                    table = getattr(view_or_viewset, "table_class", getattr(view_or_viewset, "table", None))
-
-                    # Construct the results table for this object type
-                    filtered_queryset = filterset({"q": form.cleaned_data["q"]}, queryset=queryset).qs
-                    table = table(filtered_queryset, hide_hierarchy_ui=True, orderable=False)
-                    table.paginate(per_page=SEARCH_MAX_RESULTS)
-
-                    if table.page:
-                        results.append(
-                            {
-                                "name": queryset.model._meta.verbose_name_plural,
-                                "table": table,
-                                "url": f"{reverse(url)}?q={form.cleaned_data.get('q')}",
-                            }
-                        )
-                except NoReverseMatch:
-                    messages.error(request, f'Missing URL "{url}" - unable to show search results for {modelname}.')
+        # Build the list of (app_label, modelname) tuples, representing all models included in the global search,
+        # based on the `app_config.searchable_models` list (if any) defined by each app
+        searchable_models = []
+        for app_config in apps.get_app_configs():
+            if hasattr(app_config, "searchable_models"):
+                searchable_models += [(app_config.label, modelname) for modelname in app_config.searchable_models]
+
+        # Searching all object types
+        obj_types = [model_info[1] for model_info in searchable_models]
+
+        for label, modelname in searchable_models:
+            if modelname not in obj_types:
+                continue
+            # Based on the label and modelname, reverse-lookup the list URL, then the view or UIViewSet
+            # corresponding to that URL, and finally the queryset, filterset, and table classes needed
+            # to find and display the model search results.
+            url = get_route_for_model(f"{label}.{modelname}", "list")
+            try:
+                view_func = resolve(reverse(url)).func
+                # For UIViewSet, view_func.cls gets what we need; for an ObjectListView, view_func.view_class is it.
+                view_or_viewset = getattr(view_func, "cls", getattr(view_func, "view_class", None))
+                queryset = view_or_viewset.queryset.restrict(request.user, "view")
+                # For a UIViewSet, .filterset_class, for an ObjectListView, .filterset.
+                filterset = getattr(view_or_viewset, "filterset_class", getattr(view_or_viewset, "filterset", None))
+                # For a UIViewSet, .table_class, for an ObjectListView, .table.
+                table = getattr(view_or_viewset, "table_class", getattr(view_or_viewset, "table", None))
+
+                # Construct the results table for this object type
+                filtered_queryset = filterset({"q": request.GET.get("q")}, queryset=queryset).qs
+                table = table(filtered_queryset, hide_hierarchy_ui=True, orderable=False)
+                table.paginate(per_page=SEARCH_MAX_RESULTS)
+
+                if table.page:
+                    results.append(
+                        {
+                            "name": queryset.model._meta.verbose_name_plural,
+                            "table": table,
+                            "url": f"{reverse(url)}?q={request.GET.get('q')}",
+                        }
+                    )
+            except NoReverseMatch:
+                messages.error(request, f'Missing URL "{url}" - unable to show search results for {modelname}.')
 
         return render(
             request,
             "search.html",
             {
-                "form": form,
                 "results": results,
             },
         )
@@ -422,7 +465,9 @@ def csrf_failure(request, reason="", template_name="403_csrf_failure.html"):
     return HttpResponseForbidden(t.render(context), content_type="text/html")
 
 
-class CustomGraphQLView(LoginRequiredMixin, GraphQLView):
+class CustomGraphQLView(LoginRequiredMixin, UIComponentsMixin, GraphQLView):
+    view_titles = Titles(titles={"*": "GraphiQL"})
+
     def render_graphiql(self, request, **data):
         query_name = request.GET.get("name")
         if query_name:
@@ -430,6 +475,8 @@ class CustomGraphQLView(LoginRequiredMixin, GraphQLView):
             data["editing"] = True
         data["saved_graphiql_queries"] = GraphQLQuery.objects.all()
         data["form"] = GraphQLQueryForm
+        data["breadcrumbs"] = self.get_breadcrumbs()
+        data["view_titles"] = self.get_view_titles()
         return render(request, self.graphiql_template, data)
 
 
@@ -524,13 +571,14 @@ def get_file_with_authorization(request, *args, **kwargs):
     return get_file(request, *args, **kwargs)
 
 
-class AboutView(AccessMixin, TemplateView):
+class AboutView(AccessMixin, UIComponentsMixin, TemplateView):
     """
     Nautobot About View which displays general information about Nautobot and contact details
     for Network to Code.
     """
 
     template_name = "about.html"
+    view_titles = Titles(titles={"*": "About Nautobot"})
 
     def get(self, request, *args, **kwargs):
         # Redirect user to login page if not authenticated
@@ -558,6 +606,8 @@ class AboutView(AccessMixin, TemplateView):
                 "new_release": new_release,
                 "support_contract_active": support_contract_active,
                 "support_expiration_date": support_expiration_date,
+                "view_titles": self.get_view_titles(),
+                "breadcrumbs": self.get_breadcrumbs(),
             }
         )
 
@@ -568,3 +618,4 @@ class RenderJinjaView(LoginRequiredMixin, TemplateView):
     """Render a Jinja template with context data."""
 
     template_name = "utilities/render_jinja2.html"
+    extra_context = {"view_titles": Titles(titles={"*": "Jinja Template Renderer"})}