nautobot 2.4.17__py3-none-any.whl → 2.4.18__py3-none-any.whl

nautobot/core/tests/test_tables.py

@@ -18,8 +18,18 @@ class TableTestCase(TestCase):
     def _validate_sorted_tree_queryset_same_with_table_queryset(self, queryset, table_class, field_name):
         with self.subTest(f"Assert sorting {table_class.__name__} on '{field_name}'"):
             table = table_class(queryset.with_tree_fields(), order_by=field_name)
-            table_queryset_data = table.data.data.values_list("pk", flat=True)
-            sorted_queryset = queryset.with_tree_fields().extra(order_by=[field_name]).values_list("pk", flat=True)
+            table_queryset_data = table.data.data.values_list(field_name, flat=True)
+            sorted_queryset = (
+                queryset.with_tree_fields().extra(order_by=[field_name]).values_list(field_name, flat=True)
+            )
+            self.assertEqual(list(table_queryset_data), list(sorted_queryset))
+
+        with self.subTest(f"Assert sorting {table_class.__name__} on '-{field_name}'"):
+            table = table_class(queryset.with_tree_fields(), order_by=f"-{field_name}")
+            table_queryset_data = table.data.data.values_list(field_name, flat=True)
+            sorted_queryset = (
+                queryset.with_tree_fields().extra(order_by=[f"-{field_name}"]).values_list(field_name, flat=True)
+            )
             self.assertEqual(list(table_queryset_data), list(sorted_queryset))
 
     def test_tree_model_table_orderable(self):
@@ -61,14 +71,41 @@ class TableTestCase(TestCase):
             table_avail_fields = set(model_field_names) & set(table_class.Meta.fields)
             for table_field_name in table_avail_fields:
                 self._validate_sorted_tree_queryset_same_with_table_queryset(queryset, table_class, table_field_name)
-                self._validate_sorted_tree_queryset_same_with_table_queryset(
-                    queryset, table_class, f"-{table_field_name}"
-                )
 
         # Test for `rack_count`
         queryset = RackGroupTable.Meta.model.objects.annotate(rack_count=count_related(Rack, "rack_group")).all()
         self._validate_sorted_tree_queryset_same_with_table_queryset(queryset, RackGroupTable, "rack_count")
-        self._validate_sorted_tree_queryset_same_with_table_queryset(queryset, RackGroupTable, "-rack_count")
+
+        # https://github.com/nautobot/nautobot/issues/7330 - sorting by custom field
+        l1 = Location.objects.first()
+        l1._custom_field_data["example_app_auto_custom_field"] = "alpha"
+        l1.validated_save()
+        l2 = Location.objects.last()
+        l2._custom_field_data["example_app_auto_custom_field"] = "omega"
+        l2.validated_save()
+        table = LocationTable(
+            Location.objects.exclude(_custom_field_data__example_app_auto_custom_field="Default value")
+        )
+
+        table.order_by = ["cf_example_app_auto_custom_field"]
+        table_queryset_data = table.data.data.values_list("pk", flat=True)
+        sorted_queryset = (
+            Location.objects.with_tree_fields()
+            .exclude(_custom_field_data__example_app_auto_custom_field="Default value")
+            .extra(order_by=["_custom_field_data__example_app_auto_custom_field"])
+            .values_list("pk", flat=True)
+        )
+        self.assertEqual(list(table_queryset_data), list(sorted_queryset))
+
+        table.order_by = ["-cf_example_app_auto_custom_field"]
+        table_queryset_data = table.data.data.values_list("pk", flat=True)
+        sorted_queryset = (
+            Location.objects.with_tree_fields()
+            .exclude(_custom_field_data__example_app_auto_custom_field="Default value")
+            .extra(order_by=["-_custom_field_data__example_app_auto_custom_field"])
+            .values_list("pk", flat=True)
+        )
+        self.assertEqual(list(table_queryset_data), list(sorted_queryset))
 
     def test_base_table_apis(self):
         """

nautobot/core/tests/test_templatetags_ui_framework.py

@@ -0,0 +1,146 @@
+from django.template import Context
+
+from nautobot.core.templatetags import ui_framework
+from nautobot.core.testing import TestCase
+from nautobot.core.ui.breadcrumbs import Breadcrumbs
+from nautobot.core.ui.titles import Titles
+
+
+class NautobotTemplatetagsUIComponentsTest(TestCase):
+    """Tests template tags from ui_framework module."""
+
+    # ---------------------------
+    # render_title
+    # ---------------------------
+
+    def test_render_title_with_legacy_title_present(self):
+        context = Context(
+            {
+                "title": "Custom Title",
+                "view_titles": Titles(),
+                "verbose_name_plural": "Default Title",
+            }
+        )
+        output = ui_framework.render_title(context)
+
+        self.assertEqual(output, "Custom Title")
+
+    def test_render_title_with_view_titles_only(self):
+        context = Context(
+            {
+                "view_titles": Titles(),
+                "verbose_name_plural": "Default Title",
+            }
+        )
+        output = ui_framework.render_title(context)
+
+        self.assertEqual(output, "Default Title")
+
+    def test_render_title_with_invalid_view_titles(self):
+        class MyStuff:
+            pass
+
+        context = Context(
+            {
+                "view_titles": MyStuff(),
+                "verbose_name_plural": "Default Title",
+            }
+        )
+        output = ui_framework.render_title(context)
+
+        self.assertEqual(output, "")
+
+    def test_render_title_with_empty_context(self):
+        context = Context({})
+        output = ui_framework.render_title(context)
+
+        self.assertEqual(output, "")
+
+    # ---------------------------
+    # render_breadcrumbs
+    # ---------------------------
+
+    def test_render_breadcrumbs(self):
+        context = Context(
+            {
+                "list_url": "home",
+                "title": "New Home",
+                "view_action": "list",
+                "breadcrumbs": Breadcrumbs(),
+            }
+        )
+        output = ui_framework.render_breadcrumbs(context)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">New Home</a></li></ol>')
+
+    def test_render_breadcrumbs_empty_context(self):
+        context = Context({})
+        output = ui_framework.render_breadcrumbs(context)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"></ol>')
+
+    def test_render_breadcrumbs_with_legacy_breadcrumbs(self):
+        legacy_breadcrumbs = '<li><a href="/">Home</a></li>'
+        context = Context({})
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">Home</a></li></ol>')
+
+    def test_render_breadcrumbs_with_legacy_and_block_breadcrumbs_the_same_with_breadcrumbs_class(self):
+        legacy_breadcrumbs = block_breadcrumbs = '<li><a href="/">Home</a></li>'
+        context = Context(
+            {
+                "list_url": "home",
+                "title": "New Home",
+                "view_action": "list",
+                "breadcrumbs": Breadcrumbs(),
+            }
+        )
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs, block_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">New Home</a></li></ol>')
+
+    def test_render_breadcrumbs_with_legacy_and_block_breadcrumbs_the_same_and_no_breadcrumbs_class(self):
+        legacy_breadcrumbs = block_breadcrumbs = '<li><a href="/">Home</a></li>'
+        context = Context({})
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs, block_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">Home</a></li></ol>')
+
+    def test_render_breadcrumbs_with_legacy_breadcrumbs_override(self):
+        legacy_breadcrumbs = '<li><a href="/">Home</a></li>'
+        block_breadcrumbs = '<li><a href="/">Override</a></li>'
+        context = Context(
+            {
+                "list_url": "home",
+                "title": "New Home",
+                "view_action": "list",
+                "breadcrumbs": Breadcrumbs(),
+            }
+        )
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs, block_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">Override</a></li></ol>')
+
+    def test_render_breadcrumbs_strips_tags(self):
+        legacy_breadcrumbs = """
+        <li>
+            <a href="/">Home</a>
+        </li>"""
+
+        block_breadcrumbs = """<li>
+
+            <a href="/">Home</a></li>
+        """
+
+        context = Context(
+            {
+                "list_url": "home",
+                "title": "New Home",
+                "view_action": "list",
+                "breadcrumbs": Breadcrumbs(),
+            }
+        )
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs, block_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">New Home</a></li></ol>')

nautobot/core/tests/test_titles.py

@@ -163,7 +163,7 @@ class TitlesTestCase(TestCase):
         """Test rendering when no view_action is provided."""
         context = Context({"verbose_name_plural": "devices"})
         result = self.titles.render(context)
-        self.assertEqual(result, "Devices")  # Should use list_action as default
+        self.assertEqual(result, "Devices")  # Should use * action as default
 
     def test_get_extra_context(self):
         """Test that get_extra_context returns empty dict by default."""
@@ -173,7 +173,7 @@ class TitlesTestCase(TestCase):
 
     def test_get_extra_context_is_used_during_render(self):
         """Test that get_extra_context is being used to extend the context."""
-        context = Context({})
+        context = Context({"view_action": "list"})
 
         class TitlesSubClass(Titles):
             def get_extra_context(self, context: Context) -> dict:

nautobot/core/tests/test_ui.py

@@ -7,7 +7,7 @@ from django.test import RequestFactory
 
 from nautobot.core.templatetags.helpers import HTML_NONE
 from nautobot.core.testing import TestCase
-from nautobot.core.ui.object_detail import BaseTextPanel, DataTablePanel, ObjectsTablePanel, Panel
+from nautobot.core.ui.object_detail import BaseTextPanel, DataTablePanel, ObjectFieldsPanel, ObjectsTablePanel, Panel
 from nautobot.dcim.models import DeviceRedundancyGroup
 from nautobot.dcim.tables.devices import DeviceTable
 
@@ -68,6 +68,19 @@ class DataTablePanelTest(TestCase):
         )
 
 
+class ObjectFieldsPanelTest(TestCase):
+    def test_get_data_ignore_nonexistent_fields(self):
+        panel = ObjectFieldsPanel(weight=100, fields=["name", "foo", "bar"], ignore_nonexistent_fields=True)
+        redundancy_group = DeviceRedundancyGroup.objects.first()
+        context = Context({"object": redundancy_group})
+        data = panel.get_data(context)
+        self.assertEqual(data, {"name": redundancy_group.name})  # no keys for nonexistent fields
+
+        panel = ObjectFieldsPanel(weight=100, fields=["name", "foo", "bar"], ignore_nonexistent_fields=False)
+        with self.assertRaises(AttributeError):
+            data = panel.get_data(context)
+
+
 class BaseTextPanelTest(TestCase):
     def test_init_set_object_params(self):
         # Test default settings

nautobot/core/tests/test_views.py

@@ -8,6 +8,7 @@ import urllib.parse
 from django.apps import apps
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
+from django.core.cache import cache
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.test import override_settings, RequestFactory
 from django.test.utils import override_script_prefix
@@ -23,6 +24,7 @@ from nautobot.core.testing.utils import extract_page_body
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.views import NautobotMetricsView
 from nautobot.core.views.mixins import GetReturnURLMixin
+from nautobot.core.views.utils import METRICS_CACHE_KEY
 from nautobot.dcim.models.locations import Location
 from nautobot.extras.choices import CustomFieldTypeChoices
 from nautobot.extras.models import FileProxy, Status
@@ -566,6 +568,49 @@ class MetricsViewTestCase(TestCase):
         metric_names_with_app.remove(test_metric_name)
         self.assertSetEqual(metric_names_with_app, metric_names_without_app)
 
+    def test_enabled_metrics_cache_disabled(self):
+        """Assert that when cache is disabled the cache enabled function doesn't get called."""
+        with mock.patch("nautobot.core.views.utils.generate_latest_with_cache") as mock_generate_latest_with_cache:
+            self.query_and_parse_metrics()
+            self.assertTrue(mock_generate_latest_with_cache.call_count == 0)
+
+    @override_settings(METRICS_EXPERIMENTAL_CACHING_DURATION=30)
+    def test_enabled_metrics_cache_enabled(self):
+        """Assert that multiple calls to metrics with caching returns expected response."""
+        test_metric_name = "nautobot_example_metric_count"
+        metrics_with_app = self.query_and_parse_metrics()
+        metrics_with_app_cached = self.query_and_parse_metrics()
+        metric_names_with_app = {metric.name for metric in metrics_with_app}
+        metric_names_with_app_cached = {metric.name for metric in metrics_with_app_cached}
+        self.assertIn(test_metric_name, metric_names_with_app)
+        self.assertIn(test_metric_name, metric_names_with_app_cached)
+
+        # In some circumstances (e.g. if this test is run first) metrics_with_app may not have
+        # metrics from Django like total view counts. Since metrics_with_app_cached is called
+        # second, it should have everything that metrics_with_app has (plus potentially more).
+        # We at least want to ensure the cached version has everything the non-cached version has.
+        self.assertTrue(
+            metric_names_with_app.issubset(metric_names_with_app_cached),
+            msg="Cached metrics should be a superset of non-cached metrics.",
+        )
+        with mock.patch("nautobot.core.views.generate_latest_with_cache") as mock_generate_latest_with_cache:
+            self.query_and_parse_metrics()
+            self.query_and_parse_metrics()
+            self.assertEqual(mock_generate_latest_with_cache.call_count, 2)
+
+        from example_app.metrics import metric_example
+
+        cache.delete(METRICS_CACHE_KEY)  # Ensure we start with a clean cache for the next part of the test
+        # Assert that the metric function only gets called once even though we scrape metrics twice
+
+        mock_metric_function = mock.Mock(name="mock_metric_function", side_effect=metric_example)
+        with mock.patch.dict("nautobot.core.views.registry", app_metrics=[mock_metric_function]):
+            self.query_and_parse_metrics()
+            first_call_count = mock_metric_function.call_count
+            self.query_and_parse_metrics()
+            second_call_count = mock_metric_function.call_count
+            self.assertEqual(first_call_count, second_call_count)
+
 
 class AuthenticateMetricsTestCase(APITestCase):
     def test_metrics_authentication(self):

nautobot/core/ui/breadcrumbs.py

@@ -192,9 +192,14 @@ class ViewNameBreadcrumbItem(BaseBreadcrumbItem):
 
     def get_label(self, context: Context) -> str:
         if self.label_from_view_name:
-            model = get_model_for_view_name(self.get_view_name(context))
-            if model is not None:
-                return model._meta.verbose_name_plural
+            try:
+                model = get_model_for_view_name(self.get_view_name(context))
+                if model is not None:
+                    return model._meta.verbose_name_plural
+            except ValueError:
+                # `get_model_for_view_name` is not working properly with some proper paths like "home"
+                # and because by default we're trying to resolve label by using `list_url` this error may occur in some apps
+                pass
         return super().get_label(context)
 
     def get_view_name(self, context: Context) -> Optional[str]:
@@ -401,6 +406,7 @@ class Breadcrumbs:
         # Default breadcrumb if view defines `list_url` in the Context
         ViewNameBreadcrumbItem(
             view_name_key="list_url",
+            label_key="title",
             label_from_view_name=True,
             should_render=lambda context: context.get("list_url") is not None,
         ),
@@ -411,7 +417,7 @@ class Breadcrumbs:
     def __init__(
         self,
         items: BreadcrumbItemsType = None,
-        template: str = "inc/breadcrumbs.html",
+        template: str = "components/breadcrumbs.html",
     ):
         """
         Initialize the Breadcrumbs configuration.
@@ -447,7 +453,7 @@ class Breadcrumbs:
         Returns:
             (list[tuple[str, str]]): A list of (url, label) tuples representing breadcrumb entries.
         """
-        action = context.get("view_action", "list")
+        action = context.get("view_action", "")
         detail = context.get("detail", False)
         items = self.get_items_for_action(self.items, action, detail)
         return [item.as_pair(context) for item in items if item.should_render(context)]
@@ -457,7 +463,7 @@ class Breadcrumbs:
         Filters out all items that both label and url are None or empty str.
 
         Args:
-            items (list[tuple[str, str]]): breadcrumb items pair.s
+            items (list[tuple[str, str]]): breadcrumb items pairs.
             context (Context): The view or template context.
 
         Returns:
@@ -481,8 +487,7 @@ class Breadcrumbs:
     @staticmethod
     def get_items_for_action(items: BreadcrumbItemsType, action: str, detail: bool) -> list[BaseBreadcrumbItem]:
         """
-        Get the breadcrumb items for a specific action, with fallback to 'detail' if not found
-        and to asterisk (*) if present.
+        Get the breadcrumb items for a specific action, 'detail' or to asterisk (*) if present.
 
         Args:
             items (BreadcrumbItemsType): Dictionary mapping action names to breadcrumb item lists.

nautobot/core/ui/object_detail.py

@@ -9,6 +9,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import FieldDoesNotExist, ObjectDoesNotExist
 from django.db import models
 from django.db.models import CharField, JSONField, Q, URLField
+from django.db.models.constants import LOOKUP_SEP
 from django.db.models.fields.related import ManyToManyField
 from django.template import Context
 from django.template.defaultfilters import truncatechars
@@ -971,6 +972,7 @@ class KeyValueTablePanel(Panel):
         context_data_key=None,
         hide_if_unset=(),
         value_transforms=None,
+        key_transforms=None,
         body_wrapper_template_path="components/panel/body_wrapper_key_value_table.html",
         **kwargs,
     ):
@@ -989,6 +991,8 @@ class KeyValueTablePanel(Panel):
 
                 - `[render_markdown, placeholder]` - render the given text as Markdown, or render a placeholder if blank
                 - `[humanize_speed, placeholder]` - convert the given kbps value to Mbps or Gbps for display
+            key_transforms (dict, optional): A mapping of original field names to custom display names to be used when rendering keys
+                For example: {'content_types': 'Content Type'}.
         """
         if data and context_data_key:
             raise ValueError("The data and context_data_key parameters are mutually exclusive")
@@ -996,6 +1000,7 @@ class KeyValueTablePanel(Panel):
         self.context_data_key = context_data_key or "data"
         self.hide_if_unset = hide_if_unset
         self.value_transforms = value_transforms or {}
+        self.key_transforms = key_transforms or {}
         super().__init__(body_wrapper_template_path=body_wrapper_template_path, **kwargs)
 
     def should_render(self, context: Context):
@@ -1176,6 +1181,7 @@ class ObjectFieldsPanel(KeyValueTablePanel):
         self,
         *,
         fields="__all__",
+        additional_fields=(),
         exclude_fields=(),
         context_object_key=None,
         ignore_nonexistent_fields=False,
@@ -1189,6 +1195,11 @@ class ObjectFieldsPanel(KeyValueTablePanel):
             fields (str, list): The ordered list of fields to display, or `"__all__"` to display fields automatically.
                 Note that ManyToMany fields and reverse relations are **not** included in `"__all__"` at this time, nor
                 are any hidden fields, nor the specially handled `id`, `created`, `last_updated` fields on most models.
+                When a list is specified, it may include model `@property` attributes and nested lookups (if desired) in
+                addition to concrete model fields; when using `fields="__all__"`, such additional attributes and lookups
+                may be specified with the `additional_fields` parameter.
+            additional_fields (list): Only relevant if `fields == "__all__"`, in which case it can specify additional
+                non-default fields to include such as reverse relations, `@property` attributes, nested lookups, etc.
             exclude_fields (list): Only relevant if `fields == "__all__"`, in which case it excludes the given fields.
             context_object_key (str): The key in the render context that will contain the object to derive fields from.
             ignore_nonexistent_fields (bool): If True, `fields` is permitted to include field names that don't actually
@@ -1197,6 +1208,11 @@ class ObjectFieldsPanel(KeyValueTablePanel):
                 (see `render_label()`).
         """
         self.fields = fields
+        if additional_fields and fields != "__all__":
+            raise ValueError("additional_fields may only be used in combination with fields='__all__'")
+        self.additional_fields = additional_fields
+        if exclude_fields and fields != "__all__":
+            raise ValueError("exclude_fields may only be used in combination with fields='__all__'")
         self.exclude_fields = exclude_fields
         self.context_object_key = context_object_key
         self.ignore_nonexistent_fields = ignore_nonexistent_fields
@@ -1210,6 +1226,7 @@ class ObjectFieldsPanel(KeyValueTablePanel):
 
     def render_value(self, key, value, context: Context):
         obj = get_obj_from_context(context, self.context_object_key)
+        # TODO: handle nested keys, e.g. device_type__device_family
         try:
             field_instance = obj._meta.get_field(key)
         except FieldDoesNotExist:
@@ -1230,8 +1247,18 @@ class ObjectFieldsPanel(KeyValueTablePanel):
         if isinstance(field_instance, JSONField):
             return format_html("<pre>{}</pre>", render_json(value))
 
-        if isinstance(field_instance, ManyToManyField) and field_instance.related_model == ContentType:
-            return render_content_types(value)
+        if isinstance(field_instance, ManyToManyField):
+            if field_instance.related_model == ContentType:
+                return render_content_types(value)
+            # TODO: this would be nice but it's probably too error-prone in general:
+            # return render_m2m(
+            #     value.all(),
+            #     (
+            #         reverse(get_route_for_model(field_instance.related_model, "list")) + "?" +
+            #         obj._meta.verbose_name_plural.lower().replace(" ", "_") + "=" + str(obj.pk)
+            #     ),
+            #     key,
+            # )
 
         if isinstance(field_instance, CharField) and hasattr(obj, f"get_{key}_display"):
             # For example, Secret.provider -> Secret.get_provider_display()
@@ -1273,6 +1300,8 @@ class ObjectFieldsPanel(KeyValueTablePanel):
             # TODO: apply a default ordering "smarter" than declaration order? Alphabetical? By field type?
             # TODO: allow model to specify an alternative field ordering?
 
+        fields += self.additional_fields
+
         data = {}
 
         if isinstance(instance, TreeModel) and (self.fields == "__all__" or "_hierarchy" in self.fields):
@@ -1283,9 +1312,14 @@ class ObjectFieldsPanel(KeyValueTablePanel):
             if field_name in self.exclude_fields:
                 continue
             try:
-                field_value = getattr(instance, field_name)
-            except ObjectDoesNotExist:
-                field_value = None
+                field_value = instance
+                # Handle nested lookups, e.g. device_type__device_family
+                for token in field_name.split(LOOKUP_SEP):
+                    try:
+                        field_value = getattr(field_value, token)
+                    except ObjectDoesNotExist:
+                        field_value = None
+                        break
             except AttributeError:
                 if self.ignore_nonexistent_fields:
                     continue
@@ -1301,6 +1335,10 @@ class ObjectFieldsPanel(KeyValueTablePanel):
 
     def render_key(self, key, value, context: Context):
         """Render the `verbose_name` of the model field whose name corresponds to the given key, if applicable."""
+
+        if key in self.key_transforms:
+            return self.key_transforms[key]
+
         instance = get_obj_from_context(context, self.context_object_key)
 
         if instance is not None:

nautobot/core/ui/titles.py

@@ -1,9 +1,10 @@
-from typing import Literal, Optional
+from typing import Literal, Optional, Union
 
 from django.template import Context, Template
 from django.utils.html import strip_tags
 
 DEFAULT_TITLES: dict[str, str] = {
+    "*": "{{ verbose_name_plural|bettertitle }}",
     "list": "{{ verbose_name_plural|bettertitle }}",
     "detail": "{{ object.display|default:object }}",
     "retrieve": "{{ object.display|default:object }}",
@@ -59,7 +60,7 @@ class Titles:
         if template_plugins:
             self.template_plugins.extend(template_plugins)
 
-    def render(self, context: Context, mode: ModeType = "html") -> str:
+    def render(self, context: Union[dict, Context], mode: ModeType = "html") -> str:
         """
         Renders the title based on given context and current action.
 
@@ -68,12 +69,15 @@ class Titles:
         Make sure that needed context variables are in context and needed plugins are loaded.
 
         Args:
-            context (Context): Render context.
+            context (Union[dict, Context]): Render context.
             mode (ModeType): Rendering mode: "html" or "plain".
 
         Returns:
             (str): HTML fragment or plain text, depending on `mode`.
         """
+        if isinstance(context, dict):
+            context = Context(context)
+
         with context.update(self.get_extra_context(context)):
             template_str = self.get_template_str(context)
             template = Template(self.template_plugins_str + template_str)
@@ -92,7 +96,7 @@ class Titles:
         Returns:
             str: The template string for the current action, or an empty string if not found.
         """
-        action = context.get("view_action", "list")
+        action = context.get("view_action", "")
 
         template_str = self.titles.get(action)
         if template_str:
@@ -102,7 +106,7 @@ class Titles:
         if detail:
             return self.titles.get("detail", "")
 
-        return ""
+        return self.titles.get("*", "")
 
     @property
     def template_plugins_str(self) -> str:

nautobot/core/views/__init__.py

@@ -15,6 +15,7 @@ from django.contrib import messages
 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.shortcuts import get_object_or_404, render
 from django.template import loader, RequestContext, Template
@@ -51,6 +52,11 @@ from nautobot.core.releases import get_latest_release
 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.utils import (
+    generate_latest_with_cache,
+    is_metrics_experimental_caching_enabled,
+    METRICS_CACHE_KEY,
+)
 from nautobot.extras.forms import GraphQLQueryForm
 from nautobot.extras.models import FileProxy, GraphQLQuery, Status
 from nautobot.extras.registry import registry
@@ -435,8 +441,17 @@ class NautobotAppMetricsCollector(Collector):
     def collect(self):
         """Collect metrics from plugins."""
         start = time.time()
-        for metric_generator in registry["app_metrics"]:
-            yield from metric_generator()
+        cached_lines = cache.get(METRICS_CACHE_KEY)
+        if not is_metrics_experimental_caching_enabled() or not cached_lines:
+            # If caching is disabled or no cache is found, generate metrics
+            for metric_generator in registry["app_metrics"]:
+                yield from metric_generator()
+        else:
+            # We stash the cached lines on the instance of the collector so that we can
+            # avoid a potential race condition where the cache expires between
+            # the time we check for it and the time we go to use it
+            # in generate_latest_with_cache()
+            self.local_cache = cached_lines
         gauge = GaugeMetricFamily("nautobot_app_metrics_processing_ms", "Time in ms to generate the app metrics")
         duration = time.time() - start
         gauge.add_metric([], format(duration * 1000, ".5f"))
@@ -485,7 +500,13 @@ class NautobotMetricsView(APIView):
         except ValueError:
             # Collector already registered, we are running without multiprocessing
             pass
-        metrics_page = generate_latest(prometheus_registry)
+
+        if is_metrics_experimental_caching_enabled():
+            # Use the vendored version of generate_latest with Caching support
+            metrics_page = generate_latest_with_cache(prometheus_registry)
+        else:
+            # Use the original version of generate_latest to generate the metrics
+            metrics_page = generate_latest(prometheus_registry)
         return Response(metrics_page, content_type=CONTENT_TYPE_LATEST)