nautobot 2.4.11__py3-none-any.whl → 2.4.13__py3-none-any.whl

nautobot/dcim/views.py

@@ -59,6 +59,7 @@ from nautobot.core.views.viewsets import NautobotUIViewSet
 from nautobot.dcim.choices import LocationDataToContactActionChoices
 from nautobot.dcim.forms import LocationMigrateDataToContactForm
 from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Team
+from nautobot.extras.tables import DynamicGroupTable
 from nautobot.extras.views import ObjectChangeLogView, ObjectConfigContextView, ObjectDynamicGroupsView
 from nautobot.ipam.models import IPAddress, Prefix, Service, VLAN
 from nautobot.ipam.tables import InterfaceIPAddressTable, InterfaceVLANTable, VRFDeviceAssignmentTable, VRFTable
@@ -70,8 +71,8 @@ from nautobot.wireless.models import (
     ControllerManagedDeviceGroupWirelessNetworkAssignment,
 )
 from nautobot.wireless.tables import (
+    BaseControllerManagedDeviceGroupWirelessNetworkAssignmentTable,
     ControllerManagedDeviceGroupRadioProfileAssignmentTable,
-    ControllerManagedDeviceGroupWirelessNetworkAssignmentTable,
     DeviceGroupWirelessNetworkTable,
     RadioProfileTable,
 )
@@ -1701,7 +1702,39 @@ class DeviceView(generic.ObjectView):
         "tenant__tenant_group",
     ).prefetch_related("images", "software_image_files")
 
-    object_detail_content = object_detail.ObjectDetailContent(
+    class DeviceDetailContent(object_detail.ObjectDetailContent):
+        """
+        Override base ObjectDetailContent to render dynamic-groups table as a separate view/tab instead of inline.
+        """
+
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            # Remove inline tab definition
+            for tab in list(self._tabs):
+                if isinstance(tab, object_detail._ObjectDetailGroupsTab):
+                    self._tabs.remove(tab)
+            # Add distinct-view tab definition
+            self._tabs.append(
+                object_detail.DistinctViewTab(
+                    weight=object_detail.Tab.WEIGHT_GROUPS_TAB,
+                    tab_id="dynamic_groups",
+                    label="Dynamic Groups",
+                    url_name="dcim:device_dynamicgroups",
+                    related_object_attribute="dynamic_groups",
+                    panels=(
+                        object_detail.ObjectsTablePanel(
+                            weight=100,
+                            table_class=DynamicGroupTable,
+                            table_attribute="dynamic_groups",
+                            exclude_columns=["content_type"],
+                            add_button_route=None,
+                            related_field_name="member_id",
+                        ),
+                    ),
+                )
+            )
+
+    object_detail_content = DeviceDetailContent(
         extra_buttons=(
             object_detail.DropdownButton(
                 weight=100,
@@ -2188,7 +2221,7 @@ class DeviceChangeLogView(ObjectChangeLogView):
     base_template = "dcim/device/base.html"
 
 
-class DeviceDynamicGroupsView(ObjectDynamicGroupsView):  # 3.0 TODO: remove, deprecated in 2.3
+class DeviceDynamicGroupsView(ObjectDynamicGroupsView):
     base_template = "dcim/device/base.html"
 
 
@@ -2238,7 +2271,7 @@ class DeviceWirelessView(generic.ObjectView):
         wireless_networks = ControllerManagedDeviceGroupWirelessNetworkAssignment.objects.filter(
             controller_managed_device_group=controller_managed_device_group
         ).select_related("wireless_network", "controller_managed_device_group", "vlan")
-        wireless_networks_table = ControllerManagedDeviceGroupWirelessNetworkAssignmentTable(
+        wireless_networks_table = BaseControllerManagedDeviceGroupWirelessNetworkAssignmentTable(
             data=wireless_networks, user=request.user, orderable=False
         )
         wireless_networks_table.columns.hide("controller_managed_device_group")
@@ -3907,151 +3940,102 @@ class InterfaceConnectionsListView(ConnectionsListView):
 #
 
 
-class VirtualChassisListView(generic.ObjectListView):
-    queryset = VirtualChassis.objects.all()
-    table = tables.VirtualChassisTable
-    filterset = filters.VirtualChassisFilterSet
-    filterset_form = forms.VirtualChassisFilterForm
-
-
-class VirtualChassisView(generic.ObjectView):
+class VirtualChassisUIViewSet(NautobotUIViewSet):
+    bulk_update_form_class = forms.VirtualChassisBulkEditForm
+    filterset_class = filters.VirtualChassisFilterSet
+    filterset_form_class = forms.VirtualChassisFilterForm
+    form_class = forms.VirtualChassisCreateForm
+    serializer_class = serializers.VirtualChassisSerializer
+    table_class = tables.VirtualChassisTable
     queryset = VirtualChassis.objects.all()
 
     def get_extra_context(self, request, instance):
-        members = Device.objects.restrict(request.user).filter(virtual_chassis=instance)
-
-        return {"members": members, **super().get_extra_context(request, instance)}
-
-
-class VirtualChassisCreateView(generic.ObjectEditView):
-    queryset = VirtualChassis.objects.all()
-    model_form = forms.VirtualChassisCreateForm
-    template_name = "dcim/virtualchassis_add.html"
-
-
-class VirtualChassisEditView(ObjectPermissionRequiredMixin, GetReturnURLMixin, View):
-    queryset = VirtualChassis.objects.all()
-
-    def get_required_permission(self):
-        return "dcim.change_virtualchassis"
-
-    def get(self, request, pk):
-        virtual_chassis = get_object_or_404(self.queryset, pk=pk)
-        VCMemberFormSet = modelformset_factory(
-            model=Device,
-            form=forms.DeviceVCMembershipForm,
-            formset=forms.BaseVCMemberFormSet,
-            extra=0,
-        )
-        members_queryset = virtual_chassis.members.select_related("rack").order_by("vc_position")
-
-        vc_form = forms.VirtualChassisForm(instance=virtual_chassis)
-        vc_form.fields["master"].queryset = members_queryset
-        formset = VCMemberFormSet(queryset=members_queryset)
-
-        return render(
-            request,
-            "dcim/virtualchassis_edit.html",
-            {
-                "vc_form": vc_form,
-                "formset": formset,
-                "return_url": self.get_return_url(request, virtual_chassis),
-            },
-        )
-
-    def post(self, request, pk):
-        virtual_chassis = get_object_or_404(self.queryset, pk=pk)
-        VCMemberFormSet = modelformset_factory(
-            model=Device,
-            form=forms.DeviceVCMembershipForm,
-            formset=forms.BaseVCMemberFormSet,
-            extra=0,
-        )
-        members_queryset = virtual_chassis.members.select_related("rack").order_by("vc_position")
-
-        vc_form = forms.VirtualChassisForm(request.POST, instance=virtual_chassis)
-        vc_form.fields["master"].queryset = members_queryset
-        formset = VCMemberFormSet(request.POST, queryset=members_queryset)
-
-        if vc_form.is_valid() and formset.is_valid():
-            with transaction.atomic():
-                # Save the VirtualChassis
-                vc_form.save()
-
-                # Nullify the vc_position of each member first to allow reordering without raising an IntegrityError on
-                # duplicate positions. Then save each member instance.
-                members = formset.save(commit=False)
-                devices = Device.objects.filter(pk__in=[m.pk for m in members])
-                for device in devices:
-                    device.vc_position = None
-                    device.save()
-                for member in members:
-                    member.save()
-
-            return redirect(virtual_chassis.get_absolute_url())
-
-        return render(
-            request,
-            "dcim/virtualchassis_edit.html",
-            {
-                "vc_form": vc_form,
-                "formset": formset,
-                "return_url": self.get_return_url(request, virtual_chassis),
-            },
-        )
-
+        context = super().get_extra_context(request, instance)
 
-class VirtualChassisDeleteView(generic.ObjectDeleteView):
-    queryset = VirtualChassis.objects.all()
+        if self.action == "update":
+            VCMemberFormSet = modelformset_factory(
+                model=Device,
+                form=forms.DeviceVCMembershipForm,
+                formset=forms.BaseVCMemberFormSet,
+                extra=0,
+            )
+            members_queryset = instance.members.select_related("rack").order_by("vc_position")
 
+            if request.method == "POST":
+                formset = VCMemberFormSet(request.POST, queryset=members_queryset)
+            else:
+                formset = VCMemberFormSet(queryset=members_queryset)
 
-class VirtualChassisAddMemberView(ObjectPermissionRequiredMixin, GetReturnURLMixin, View):
-    queryset = VirtualChassis.objects.all()
+            vc_form = forms.VirtualChassisForm(instance=instance)
+            vc_form.fields["master"].queryset = members_queryset
 
-    def get_required_permission(self):
-        return "dcim.change_virtualchassis"
-
-    def get(self, request, pk):
-        virtual_chassis = get_object_or_404(self.queryset, pk=pk)
+            context.update(
+                {
+                    "formset": formset,
+                    "vc_form": vc_form,
+                    "return_url": self.get_return_url(request, instance),
+                }
+            )
 
-        initial_data = {k: request.GET[k] for k in request.GET}
-        member_select_form = forms.VCMemberSelectForm(initial=initial_data)
-        membership_form = forms.DeviceVCMembershipForm(initial=initial_data)
+        elif self.action == "retrieve":
+            members = Device.objects.restrict(request.user).filter(virtual_chassis=instance)
+            context.update({"members": members})
 
-        return render(
-            request,
-            "dcim/virtualchassis_add_member.html",
-            {
-                "virtual_chassis": virtual_chassis,
-                "member_select_form": member_select_form,
-                "membership_form": membership_form,
-                "return_url": self.get_return_url(request, virtual_chassis),
-            },
-        )
+        return context
 
-    def post(self, request, pk):
-        virtual_chassis = get_object_or_404(self.queryset, pk=pk)
+    def form_save(self, form, **kwargs):
+        obj = super().form_save(form, **kwargs)
 
-        member_select_form = forms.VCMemberSelectForm(request.POST)
+        if self.action == "update":
+            context = self.get_extra_context(self.request, obj)
+            formset = context.get("formset")
 
-        if member_select_form.is_valid():
-            device = member_select_form.cleaned_data["device"]
-            device.virtual_chassis = virtual_chassis
-            data = {k: request.POST[k] for k in ["vc_position", "vc_priority"]}
-            membership_form = forms.DeviceVCMembershipForm(data=data, validate_vc_position=True, instance=device)
+            if formset.is_valid():
+                with transaction.atomic():
+                    members = formset.save(commit=False)
+                    # Nullify the vc_position of each member first to allow reordering without raising an IntegrityError on
+                    # duplicate positions. Then save each member instance.
+                    Device.objects.filter(pk__in=[m.pk for m in members]).update(vc_position=None)
+                    for member in members:
+                        member.save()
+            else:
+                raise ValidationError(formset.errors)
 
-            if membership_form.is_valid():
-                membership_form.save()
-                msg = format_html('Added member <a href="{}">{}</a>', device.get_absolute_url(), device)
-                messages.success(request, msg)
+        return obj
 
-                if "_addanother" in request.POST:
-                    return redirect(request.get_full_path())
+    @action(
+        detail=True,
+        methods=["get", "post"],
+        url_path="add-member",
+        url_name="add_member",
+        custom_view_base_action="change",
+        custom_view_additional_permissions=["dcim.change_virtualchassis"],
+    )
+    def add_member(self, request, pk=None):
+        virtual_chassis = self.get_object()
 
-                return redirect(self.get_return_url(request, device))
+        if request.method == "POST":
+            member_select_form = forms.VCMemberSelectForm(request.POST)
+            if member_select_form.is_valid():
+                device = member_select_form.cleaned_data["device"]
+                device.virtual_chassis = virtual_chassis
+                data = {k: request.POST[k] for k in ["vc_position", "vc_priority"]}
+                membership_form = forms.DeviceVCMembershipForm(data=data, validate_vc_position=True, instance=device)
+
+                if membership_form.is_valid():
+                    membership_form.save()
+                    msg = format_html('Added member <a href="{}">{}</a>', device.get_absolute_url(), device)
+                    messages.success(request, msg)
 
+                    if "_addanother" in request.POST:
+                        return redirect(request.get_full_path())
+                    return redirect(self.get_return_url(request, device))
+            else:
+                membership_form = forms.DeviceVCMembershipForm(data=request.POST)
         else:
-            membership_form = forms.DeviceVCMembershipForm(data=request.POST)
+            initial_data = {k: request.GET[k] for k in request.GET}
+            member_select_form = forms.VCMemberSelectForm(initial=initial_data)
+            membership_form = forms.DeviceVCMembershipForm(initial=initial_data)
 
         return render(
             request,
@@ -4120,24 +4104,6 @@ class VirtualChassisRemoveMemberView(ObjectPermissionRequiredMixin, GetReturnURL
         )
 
 
-class VirtualChassisBulkImportView(generic.BulkImportView):  # 3.0 TODO: remove, unused
-    queryset = VirtualChassis.objects.all()
-    table = tables.VirtualChassisTable
-
-
-class VirtualChassisBulkEditView(generic.BulkEditView):
-    queryset = VirtualChassis.objects.all()
-    filterset = filters.VirtualChassisFilterSet
-    table = tables.VirtualChassisTable
-    form = forms.VirtualChassisBulkEditForm
-
-
-class VirtualChassisBulkDeleteView(generic.BulkDeleteView):
-    queryset = VirtualChassis.objects.all()
-    filterset = filters.VirtualChassisFilterSet
-    table = tables.VirtualChassisTable
-
-
 #
 # Power panels
 #
@@ -4687,25 +4653,69 @@ class ControllerUIViewSet(NautobotUIViewSet):
     table_class = tables.ControllerTable
     template_name = "dcim/controller_create.html"
 
-    def get_extra_context(self, request, instance):
-        context = super().get_extra_context(request, instance)
-
-        if self.action == "retrieve" and instance:
-            devices = Device.objects.restrict(request.user).filter(controller_managed_device_group__controller=instance)
-            devices_table = tables.DeviceTable(devices)
-            devices_table.columns.show("controller_managed_device_group")
-            devices_table.columns.show("capabilities")
-            devices_table.sequence = ("name", "controller_managed_device_group", "capabilities", "...")
-
-            paginate = {
-                "paginator_class": EnhancedPaginator,
-                "per_page": get_paginate_count(request),
-            }
-            RequestConfig(request, paginate).configure(devices_table)
-
-            context["devices_table"] = devices_table
-
-        return context
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            object_detail.ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+                value_transforms={
+                    "capabilities": [helpers.label_list],
+                },
+                exclude_fields=[
+                    "external_integration",
+                    "controller_device",
+                    "controller_device_redundancy_group",
+                ],
+            ),
+            object_detail.ObjectFieldsPanel(
+                section=SectionChoices.RIGHT_HALF,
+                weight=200,
+                label="Integration",
+                fields=[
+                    "external_integration",
+                    "controller_device",
+                    "controller_device_redundancy_group",
+                ],
+            ),
+            object_detail.ObjectsTablePanel(
+                section=SectionChoices.FULL_WIDTH,
+                weight=100,
+                table_class=tables.DeviceTable,
+                table_title="Managed Devices",
+                table_filter="controller_managed_device_group__controller",
+                include_columns=[
+                    "capabilities",
+                    "controller_managed_device_group",
+                    "manufacturer",
+                ],
+                related_field_name="controller",
+                add_button_route=None,
+            ),
+        ),
+        extra_tabs=(
+            object_detail.DistinctViewTab(
+                weight=700,
+                tab_id="wireless_networks",
+                url_name="dcim:controller_wirelessnetworks",
+                label="Wireless Networks",
+                related_object_attribute="wireless_network_assignments",
+                panels=(
+                    object_detail.ObjectsTablePanel(
+                        section=SectionChoices.FULL_WIDTH,
+                        weight=100,
+                        table_title="Wireless Networks",
+                        table_class=BaseControllerManagedDeviceGroupWirelessNetworkAssignmentTable,
+                        table_filter="controller_managed_device_group__controller",
+                        tab_id="wireless_networks",
+                        add_button_route=None,
+                        select_related_fields=["wireless_network"],
+                        exclude_columns=["controller"],
+                    ),
+                ),
+            ),
+        ),
+    )
 
     @action(
         detail=True,
@@ -4716,28 +4726,7 @@ class ControllerUIViewSet(NautobotUIViewSet):
         custom_view_additional_permissions=["wireless.view_controllermanageddevicegroupwirelessnetworkassignment"],
     )
     def wirelessnetworks(self, request, *args, **kwargs):
-        instance = self.get_object()
-        controller_managed_device_groups = instance.controller_managed_device_groups.restrict(
-            request.user, "view"
-        ).values_list("pk", flat=True)
-        wireless_networks = ControllerManagedDeviceGroupWirelessNetworkAssignment.objects.filter(
-            controller_managed_device_group__in=list(controller_managed_device_groups)
-        ).select_related("wireless_network")
-        wireless_networks_table = ControllerManagedDeviceGroupWirelessNetworkAssignmentTable(
-            data=wireless_networks, user=request.user, orderable=False
-        )
-        wireless_networks_table.columns.hide("controller")
-
-        RequestConfig(
-            request, paginate={"paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request)}
-        ).configure(wireless_networks_table)
-
-        return Response(
-            {
-                "wireless_networks_table": wireless_networks_table,
-                "active_tab": "wireless-networks",
-            }
-        )
+        return Response({})
 
 
 class ControllerManagedDeviceGroupUIViewSet(NautobotUIViewSet):

nautobot/extras/datasources/git.py

@@ -720,8 +720,8 @@ def refresh_job_code_from_repository(repository_slug, skip_reimport=False, ignor
     After cloning/updating/deleting a GitRepository on disk, call this function to reload and reregister its Python.
 
     Args:
-        repository_slug (str): Repository slug (directory in GIT_ROOT) that was populated, updated, or deleted.
-        skip_reimport (bool): If True, unload existing jobs from this repository but do not re-import them.
+        repository_slug (str): Repository directory in GIT_ROOT that was updated or deleted.
+        skip_reimport (bool): If True, unload existing code from this repository but do not re-import it.
         ignore_import_errors (bool): If True, any exceptions raised in the import will be caught and logged.
             If False, exceptions will be re-raised after logging.
     """

nautobot/extras/jobs_ui.py

@@ -0,0 +1,208 @@
+from django.template import Context
+from django.template.loader import render_to_string
+from django.utils.html import format_html, format_html_join
+from django.utils.safestring import mark_safe
+
+from nautobot.core.templatetags import helpers
+from nautobot.core.ui.object_detail import Button, KeyValueTablePanel, ObjectFieldsPanel
+from nautobot.core.views.utils import get_obj_from_context
+
+
+class JobRunScheduleButton(Button):
+    """
+    A custom button for running or scheduling a job.
+
+    This button is rendered only if the user has the 'extras.run_job' permission.
+    It also disables itself (via HTML 'disabled' attribute) if the related object is not
+    installed or not enabled.
+    """
+
+    def get_extra_context(self, context):
+        """Inject dynamic attributes (e.g. 'disabled') based on object state into the rendering context."""
+        extra_context = super().get_extra_context(context)
+        obj = context.get("object")
+        if not obj.installed or not obj.enabled:
+            if extra_context["attributes"] is None:
+                extra_context["attributes"] = {}
+            extra_context["attributes"]["disabled"] = "disabled"
+        return extra_context
+
+
+class JobKeyValueOverrideValueTablePanel(KeyValueTablePanel):
+    """A table panel for displaying key-value pairs of job-related attributes, along with any override values defined on the job object."""
+
+    def _render_overridden_text(self, text):
+        """
+        Render a simple overridden value inside a muted <span>, with a customizable prefix.
+
+        Args:
+            value (str): The content to display.
+            prefix (str): The label shown before the value (default: 'default is').
+        """
+        return format_html('<span class="text-muted">overridden; default is {}</span>', mark_safe(text))  # noqa: S308
+
+    def _render_overridden_block(self, content):
+        """
+        Render a more complex block of HTML content (like rendered markdown or JSON)
+        in a div with a muted label indicating it's an overridden value.
+        """
+        return format_html('<div class="text-muted">overridden; default is:<br>{}</div>', content)
+
+    def render_description_default(self, default_value):
+        """
+        Render a description field's default value as markdown.
+
+        If the default value is a string, it is rendered as markdown;
+        otherwise, a placeholder is shown.
+        """
+        rendered = (
+            helpers.render_markdown(default_value)
+            if isinstance(default_value, str)
+            else helpers.placeholder(default_value)
+        )
+        return self._render_overridden_block(rendered)
+
+    def render_time_limit_default(self, default_value, system_default_value, override=True):
+        """
+        Render a time limit value, falling back to the system default if needed.
+        """
+        message = "{} seconds" if default_value > 0 else "{} seconds (system default)"
+        value = default_value if default_value > 0 else system_default_value
+        if not override:
+            return message.format(value)
+        return self._render_overridden_text(message.format(value))
+
+    def render_job_queues_default(self, obj):
+        """
+        Render the job's default task queues as JSON.
+
+        Attempts to retrieve the `task_queues` from the job's class and render
+        it using a JSON template. Falls back to a placeholder on error.
+        """
+        try:
+            data = obj.job_class.task_queues
+            rendered = render_to_string("extras/inc/json_data.html", {"data": data, "format": "json"})
+        except Exception:
+            rendered = helpers.placeholder(None)
+        return self._render_overridden_block(rendered)
+
+    def render_default_job_queue_default(self, obj):
+        """
+        Render the default job queue name from the job class.
+
+        Retrieves the first queue from `task_queues` if available.
+        Falls back to a placeholder if no queues are present.
+        """
+        try:
+            queue = obj.job_class.task_queues[0]
+        except (AttributeError, IndexError, TypeError):
+            queue = helpers.placeholder("not specified")
+        return self._render_overridden_text(queue)
+
+    def render_boolean_default(self, default_value):
+        """Render a boolean default value using a standardized visual format."""
+        return self._render_overridden_text(helpers.render_boolean(default_value))
+
+    def render_override_value(self, key, obj):
+        """Render the override value for a given key on a job object."""
+        override_attr = f"{key}_override"
+
+        if not getattr(obj, override_attr, None):
+            return ""
+
+        if not obj.installed:
+            return self._render_overridden_text("default is unknown (not currently installed)")
+
+        try:
+            default_value = getattr(obj.job_class, key)
+        except Exception:
+            default_value = "unknown"
+
+        renderers = {
+            "description": self.render_description_default,
+            "soft_time_limit": lambda v: self.render_time_limit_default(
+                v, helpers.settings_or_config("CELERY_TASK_SOFT_TIME_LIMIT")
+            ),
+            "time_limit": lambda v: self.render_time_limit_default(
+                v, helpers.settings_or_config("CELERY_TASK_TIME_LIMIT")
+            ),
+            "job_queues": lambda _: self.render_job_queues_default(obj),
+            "default_job_queue": lambda _: self.render_default_job_queue_default(obj),
+        }
+
+        if key in renderers:
+            return renderers[key](default_value)
+
+        if isinstance(default_value, bool):
+            return self.render_boolean_default(default_value)
+
+        return self._render_overridden_text(f'"{default_value}"')
+
+    def render_job_queues_list(self, value):
+        """Renders a <ul> HTML list of job queues with hyperlinks, or a placeholder if none exist."""
+        if not value or not value.exists():
+            return helpers.placeholder(None)
+
+        items = format_html_join("\n", "<li>{}</li>", ((helpers.hyperlinked_object(q),) for q in value.all()))
+        return format_html("<ul>{}</ul>", items)
+
+    def render_body_content(self, context: Context):
+        """Render the body content of the panel as a table of key-value rows, including any override information."""
+        data = self.get_data(context)
+        obj = get_obj_from_context(context)
+
+        if not data:
+            return format_html('<tr><td colspan="2">{}</td></tr>', helpers.placeholder(data))
+
+        result = format_html("")
+        panel_label = helpers.slugify(self.label or "")
+        for key, value in data.items():
+            key_display = self.render_key(key, value, context)
+            override_value_display = self.render_override_value(key, obj)
+            if value_display := self.render_value(key, value, context):
+                if value_display is helpers.HTML_NONE:
+                    value_tag = value_display
+                else:
+                    value_tag = format_html(
+                        """
+                            <span class="hover_copy">
+                                <span id="{unique_id}_value_{key}">{value}</span>
+                                <button class="btn btn-inline btn-default hover_copy_button" data-clipboard-target="#{unique_id}_value_{key}">
+                                    <span class="mdi mdi-content-copy"></span>
+                                </button>
+                            </span>
+                        """,
+                        # key might not be globally unique in a page, but is unique to a panel;
+                        # Hence we add the panel label to make it globally unique to the page
+                        unique_id=panel_label,
+                        key=helpers.slugify(key),
+                        value=value_display,
+                    )
+                result += format_html(
+                    "<tr><td>{}</td><td>{}</td><td>{}</td></tr>",
+                    key_display,
+                    value_tag,
+                    override_value_display,
+                )
+
+        return result
+
+
+class JobObjectFieldsPanel(ObjectFieldsPanel, JobKeyValueOverrideValueTablePanel):
+    """
+    ObjectFieldsPanel that renders its fields in a 3-column layout.
+    Inherits behavior from ObjectFieldsPanel but overrides rendering with JobKeyValueOverrideValueTablePanel.
+    """
+
+    def render_value(self, key, value, context: Context):
+        if key == "job_queues":
+            return self.render_job_queues_list(value)
+        if key == "soft_time_limit":
+            value = self.render_time_limit_default(
+                value, helpers.settings_or_config("CELERY_TASK_SOFT_TIME_LIMIT"), override=False
+            )
+        if key == "time_limit":
+            value = self.render_time_limit_default(
+                value, helpers.settings_or_config("CELERY_TASK_TIME_LIMIT"), override=False
+            )
+        return super().render_value(key, value, context)