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

nautobot/core/views/utils.py

@@ -1,25 +1,44 @@
 import datetime
 from io import BytesIO
+import logging
 import urllib.parse
 
+from django.conf import settings
 from django.contrib import messages
+from django.core.cache import cache
 from django.core.exceptions import FieldError, ValidationError
 from django.db.models import ForeignKey
 from django.utils.html import format_html, format_html_join
 from django.utils.safestring import mark_safe
 from django_tables2 import RequestConfig
+from prometheus_client import REGISTRY
+from prometheus_client.utils import floatToGoString
 from rest_framework import exceptions, serializers
 
 from nautobot.core.api.fields import ChoiceField, ContentTypeField, TimeZoneSerializerField
 from nautobot.core.api.parsers import NautobotCSVParser
 from nautobot.core.models.utils import is_taggable
+from nautobot.core.utils import lookup
 from nautobot.core.utils.data import is_uuid
 from nautobot.core.utils.filtering import get_filter_field_label
-from nautobot.core.utils.lookup import get_created_and_last_updated_usernames_for_model, get_form_for_model
+from nautobot.core.utils.lookup import (
+    get_created_and_last_updated_usernames_for_model,
+    get_filterset_for_model,
+    get_form_for_model,
+    get_view_for_model,
+)
+from nautobot.core.utils.requests import normalize_querydict
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.extras.models import SavedView
 from nautobot.extras.tables import AssociatedContactsTable, DynamicGroupTable, ObjectMetadataTable
 
+logger = logging.getLogger(__name__)
+
+METRICS_CACHE_KEY = "nautobot_app_metrics_cache"
+always_generated_metrics = [
+    "nautobot_app_metrics_processing_ms"  # Always generate this metric to track the processing time of Nautobot App metrics, improved with caching.
+]
+
 
 def check_filter_for_display(filters, field_name, values):
     """
@@ -399,3 +418,253 @@ def get_saved_views_for_user(user, list_url):
         return shared_saved_views | user_owned_saved_views
 
     return shared_saved_views
+
+
+def is_metrics_experimental_caching_enabled():
+    """Return True if METRICS_EXPERIMENTAL_CACHING_DURATION is set to a positive integer."""
+    return settings.METRICS_EXPERIMENTAL_CACHING_DURATION > 0
+
+
+def generate_latest_with_cache(registry=REGISTRY):
+    """A vendored version of prometheus_client.generate_latest that caches Nautobot App metrics."""
+
+    def sample_line(line):
+        if line.labels:
+            labelstr = "{{{0}}}".format(
+                ",".join(
+                    [
+                        '{}="{}"'.format(k, v.replace("\\", r"\\").replace("\n", r"\n").replace('"', r"\""))
+                        for k, v in sorted(line.labels.items())
+                    ]
+                )
+            )
+        else:
+            labelstr = ""
+        timestamp = ""
+        if line.timestamp is not None:
+            # Convert to milliseconds.
+            timestamp = f" {int(float(line.timestamp) * 1000):d}"
+        return f"{line.name}{labelstr} {floatToGoString(line.value)}{timestamp}\n"
+
+    cached_lines = []
+    output = []
+    # NOTE: In the original prometheus_client code the lines are written to output directly,
+    # here we are going to cache some lines so we need to build each metric's output separately.
+    # So instead of `output.append(line)` we do
+    # `this_metric_output.append(line)` and then `output.extend(this_metric_output)`
+    for metric in registry.collect():
+        this_metric_output = []
+        try:
+            mname = metric.name
+            mtype = metric.type
+            # Munging from OpenMetrics into Prometheus format.
+            if mtype == "counter":
+                mname = mname + "_total"
+            elif mtype == "info":
+                mname = mname + "_info"
+                mtype = "gauge"
+            elif mtype == "stateset":
+                mtype = "gauge"
+            elif mtype == "gaugehistogram":
+                # A gauge histogram is really a gauge,
+                # but this captures the structure better.
+                mtype = "histogram"
+            elif mtype == "unknown":
+                mtype = "untyped"
+
+            this_metric_output.append(
+                "# HELP {} {}\n".format(mname, metric.documentation.replace("\\", r"\\").replace("\n", r"\n"))
+            )
+            this_metric_output.append(f"# TYPE {mname} {mtype}\n")
+
+            om_samples = {}
+            for s in metric.samples:
+                for suffix in ["_created", "_gsum", "_gcount"]:
+                    if s.name == metric.name + suffix:
+                        # OpenMetrics specific sample, put in a gauge at the end.
+                        om_samples.setdefault(suffix, []).append(sample_line(s))
+                        break
+                else:
+                    this_metric_output.append(sample_line(s))
+        except Exception as exception:
+            exception.args = (exception.args or ("",)) + (metric,)
+            raise
+
+        for suffix, lines in sorted(om_samples.items()):
+            this_metric_output.append(
+                "# HELP {}{} {}\n".format(
+                    metric.name, suffix, metric.documentation.replace("\\", r"\\").replace("\n", r"\n")
+                )
+            )
+            this_metric_output.append(f"# TYPE {metric.name}{suffix} gauge\n")
+            this_metric_output.extend(lines)
+
+        # BEGIN Nautobot-specific logic
+        # If the metric name starts with nautobot_, we cache the lines
+        if metric.name.startswith("nautobot_") and metric.name not in always_generated_metrics:
+            cached_lines.extend(this_metric_output)
+        # END Nautobot-specific logic
+
+        # Always add the metric output to the final output
+        output.extend(this_metric_output)
+
+    # BEGIN Nautobot-specific logic
+    # Add in any previously cached metrics.
+    # Note that this is mutually-exclusive with the above block, that is to say,
+    # either cached_lines will be populated OR collector.local_cache will be populated,
+    # never both at the same time.
+    for collector in registry._collector_to_names:
+        # This is to avoid a race condition where between the time to collect the metrics and
+        # the time to generate the output, the cache is expired and we miss some metrics.
+        if hasattr(collector, "local_cache") and collector.local_cache:
+            output.extend(collector.local_cache)
+            del collector.local_cache  # avoid re-using stale data on next call
+
+    # If we have any cached lines, and the cache is empty or expired, update the cache.
+    if cached_lines and not cache.get(METRICS_CACHE_KEY):
+        cache.set(METRICS_CACHE_KEY, cached_lines, timeout=settings.METRICS_EXPERIMENTAL_CACHING_DURATION)
+    # END Nautobot-specific logic
+
+    return "".join(output).encode("utf-8")
+
+
+def get_bulk_queryset_from_view(
+    user, content_type, filter_query_params, pk_list, saved_view_id, action, delete_all=None, edit_all=None, log=None
+):
+    """
+    Return a queryset for bulk operations based on the provided parameters.
+
+    Args:
+        user: The user performing the bulk operation.
+        model: The model class on which the bulk operation is being performed.
+        delete_all: Boolean indicating whether the operation applies to pk_list or not.
+        edit_all: Boolean indicating whether the operation applies to pk_list or not.
+        filter_query_params: A dictionary of filter parameters to apply to the queryset as produced by convert_querydict_to_dict(request.GET).
+        pk_list: A list of primary keys to include, when not using a filter.
+        saved_view_id: (Optional) UUID of a saved view to apply additional filters from.
+
+    Returns:
+        A Django queryset representing the objects to be affected by the bulk operation.
+
+    Notes:
+        Start
+        ├── !is_all and pk_list: Return queryset filtered by pk_list
+        ├── !is_all and !pk_list: Return empty queryset
+        ├── is_all and !saved_view_id and !filter_query_params: Return all objects
+        ├── is_all and filter_query_params: Return queryset filtered by filter_query_params
+        ├── is_all and saved_view_id: Return queryset filtered by saved_view_filter_params
+        ├── is_all and not saved_view_id: Return queryset filtered by saved_view_filter_params
+        └── else: raise RuntimeError
+    """
+    model = content_type.model_class()
+    if not log:
+        log = logger
+
+    action_valid = (action == "delete" and delete_all is not None) or (action == "change" and edit_all is not None)
+    if not action_valid:
+        raise RuntimeError(
+            f"Invalid parameters *_all param for action {action}, got: delete_all={delete_all}, edit_all={edit_all}"
+        )
+
+    view_name = None
+    is_all = None
+    # Based on action_valid one of these must be True
+    if action == "delete":
+        view_name = "BulkDelete"
+        is_all = delete_all
+    elif action == "change":
+        view_name = "BulkEdit"
+        is_all = edit_all
+
+    # The view_class is determined from model on purpose, as view_class the view as a param, will not work
+    # with a job. It is better to be consistent with each with sending the same params that will
+    # always be available from to the confirmation page and to the job.
+    view_class = get_view_for_model(model, view_type=view_name)
+
+    if not view_class:
+        raise RuntimeError(f"No view found for model {model} to determine base queryset.")
+
+    queryset = view_class.queryset.restrict(user, action)
+
+    # The filterset_class is determined from model on purpose, as filterset_class the view as a param, will not work
+    # with a job. It is better to be consistent with each with sending the same params that will
+    # always be available from to the confirmation page and to the job.
+    filterset_class = get_filterset_for_model(model)
+
+    if not filterset_class:
+        log.debug(f"No filterset_class found for model {model}, returning all objects")
+        return queryset
+
+    filterset_class = lookup.get_filterset_for_model(model)
+    if filterset_class:
+        filter_query_params = normalize_querydict(filter_query_params, filterset=filterset_class())
+        log.debug(f"Normalized filter_query_params: {filter_query_params}")
+    else:
+        filter_query_params = {}
+
+    # The form actually sends the pks and the "all" parameter, so seeing pk_list by itself is not
+    # sufficient to determine if we are filtering by pk_list or by all. We need to see is_all=False.
+    if not is_all and pk_list:
+        log.debug("Filtering by PK list")
+        return queryset.filter(pk__in=pk_list)
+
+    # Should this ever happen?
+    if not is_all and not pk_list:
+        log.debug("Filtering by None, as no PKs provided for bulk operation, returning empty queryset")
+        return queryset.none()
+
+    # The query params when you manually delete filters from the UI include on the saved view filter
+    # set the flag all_filters_removed to true. If that is the case, we ignore the saved view below, by setting it
+    # to None here
+    if filter_query_params.get("all_filters_removed"):
+        log.debug("The `all_filters_removed` flag is set, ignoring saved view")
+        saved_view_id = None
+        filter_query_params.pop("all_filters_removed")
+
+    new_filter_query_params = {}
+
+    filterset = filterset_class()
+    for key, value in filter_query_params.items():
+        if filterset.filters.get(key) is not None:
+            new_filter_query_params[key] = value
+        else:
+            log.debug(f"Query parameter `{key}` not found in `{filterset_class}`, discarding it")
+    filter_query_params = new_filter_query_params
+
+    # short circuit if no filtering is needed
+    if is_all and not saved_view_id and not filter_query_params:
+        log.debug("No filters or saved view specified, returning all objects")
+        return queryset
+
+    # This covers if there is a filter and a saved view, as when you have both,
+    # the saved view filters show up in the query params or the url.
+    if is_all and filter_query_params:
+        log.debug(f"Filtering by parameters: {filter_query_params}")
+        inner_queryset = filterset_class(filter_query_params, queryset).qs.values("pk")
+        # We take this approach because filterset.qs has already applied .distinct(),
+        # and performing a .delete directly on a queryset with .distinct applied is not allowed.
+        return queryset.filter(pk__in=inner_queryset)
+
+    saved_view_filter_params = {}
+    if saved_view_id:
+        try:
+            saved_view_obj = SavedView.objects.get(id=saved_view_id)
+        except SavedView.DoesNotExist:
+            return queryset.none()
+        saved_view_filter_params = saved_view_obj.config.get("filter_params", {})
+
+    # This covers the case where there is a saved view but no additional filter parameters.
+    if is_all and saved_view_filter_params:
+        log.debug(f"Filtering by saved view parameters: {saved_view_filter_params}")
+        inner_queryset = filterset_class(saved_view_filter_params, queryset).qs.values("pk")
+        # We take this approach because filterset.qs has already applied .distinct(),
+        # and performing a .delete directly on a queryset with .distinct applied is not allowed.
+        return queryset.filter(pk__in=inner_queryset)
+
+    # short circuit if no filtering is applied with a saved view
+    if is_all and not saved_view_filter_params:
+        log.debug("Saved view with no filters specified, returning all objects")
+        return queryset
+
+    log.debug("No valid operation found to generate bulk queryset.")
+    raise RuntimeError("No valid operation found to generate bulk queryset.")

nautobot/dcim/api/serializers.py

@@ -1027,7 +1027,10 @@ class DeviceTypeToSoftwareImageFileSerializer(ValidatedModelSerializer):
 
 class ControllerSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
     capabilities = serializers.ListField(
-        child=ChoiceField(choices=ControllerCapabilitiesChoices, required=False), allow_empty=True, required=False
+        child=ChoiceField(choices=ControllerCapabilitiesChoices, required=False),
+        allow_empty=True,
+        allow_null=True,
+        required=False,
     )
 
     class Meta:
@@ -1037,7 +1040,10 @@ class ControllerSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
 
 class ControllerManagedDeviceGroupSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
     capabilities = serializers.ListField(
-        child=ChoiceField(choices=ControllerCapabilitiesChoices, required=False), allow_empty=True, required=False
+        child=ChoiceField(choices=ControllerCapabilitiesChoices, required=False),
+        allow_empty=True,
+        allow_null=True,
+        required=False,
     )
 
     class Meta:

nautobot/dcim/constants.py

@@ -7,6 +7,7 @@ from .choices import InterfaceTypeChoices
 #
 
 RACK_U_HEIGHT_DEFAULT = 42
+RACK_U_HEIGHT_MAXIMUM = 500
 
 RACK_ELEVATION_BORDER_WIDTH = 2
 RACK_ELEVATION_LEGEND_WIDTH_DEFAULT = 30

nautobot/dcim/factory.py

@@ -31,6 +31,7 @@ from nautobot.dcim.choices import (
     SoftwareImageFileHashingAlgorithmChoices,
     SubdeviceRoleChoices,
 )
+from nautobot.dcim.constants import RACK_U_HEIGHT_MAXIMUM
 from nautobot.dcim.models import (
     ConsolePortTemplate,
     ConsoleServerPortTemplate,
@@ -634,7 +635,7 @@ class RackFactory(PrimaryModelFactory):
     type = factory.Maybe("has_type", factory.Faker("random_element", elements=RackTypeChoices.values()), "")
 
     width = factory.Faker("random_element", elements=RackWidthChoices.values())
-    u_height = factory.Faker("pyint", min_value=10, max_value=100)
+    u_height = factory.Faker("pyint", min_value=10, max_value=RACK_U_HEIGHT_MAXIMUM)
     desc_units = NautobotBoolIterator()
 
     has_outer_width = NautobotBoolIterator()
@@ -743,7 +744,7 @@ class ControllerFactory(PrimaryModelFactory):
     capabilities = factory.Maybe(
         "has_capabilities",
         factory.Faker("random_elements", elements=ControllerCapabilitiesChoices.values(), unique=True),
-        [],
+        None,
     )
     platform = random_instance(Platform)
     location = random_instance(lambda: Location.objects.get_for_model(Controller), allow_null=False)
@@ -770,7 +771,7 @@ class ControllerManagedDeviceGroupFactory(PrimaryModelFactory):
     capabilities = factory.Maybe(
         "has_capabilities",
         factory.Faker("random_elements", elements=ControllerCapabilitiesChoices.values(), unique=True),
-        [],
+        None,
     )
     weight = factory.Faker("pyint", min_value=1, max_value=1000)
 

nautobot/dcim/filters/mixins.py

@@ -38,8 +38,7 @@ from nautobot.dcim.models import (
     RearPort,
     RearPortTemplate,
 )
-from nautobot.extras.filters import CustomFieldModelFilterSetMixin
-from nautobot.extras.filters.mixins import RelationshipModelFilterSetMixin
+from nautobot.extras.filters.mixins import CustomFieldModelFilterSetMixin, RelationshipModelFilterSetMixin
 
 
 class CableTerminationModelFilterSetMixin(django_filters.FilterSet):

nautobot/dcim/forms.py

@@ -37,6 +37,7 @@ from nautobot.core.forms import (
 )
 from nautobot.core.forms.constants import BOOLEAN_WITH_BLANK_CHOICES
 from nautobot.core.forms.fields import LaxURLField
+from nautobot.dcim.constants import RACK_U_HEIGHT_MAXIMUM
 from nautobot.dcim.form_mixins import (
     LocatableModelBulkEditFormMixin,
     LocatableModelFilterFormMixin,
@@ -612,7 +613,7 @@ class RackBulkEditForm(
         required=False,
         widget=StaticSelect2(),
     )
-    u_height = forms.IntegerField(required=False, label="Height (U)", min_value=1, max_value=100)
+    u_height = forms.IntegerField(required=False, label="Height (U)", min_value=1, max_value=RACK_U_HEIGHT_MAXIMUM)
     desc_units = forms.NullBooleanField(required=False, widget=BulkEditNullBooleanSelect, label="Descending units")
     outer_width = forms.IntegerField(required=False, min_value=1)
     outer_depth = forms.IntegerField(required=False, min_value=1)
@@ -5193,6 +5194,8 @@ class SoftwareImageFileFilterForm(NautobotFilterForm, StatusModelFilterFormMixin
 class SoftwareImageFileForm(NautobotModelForm):
     """SoftwareImageFile credit/edit form."""
 
+    software_version = DynamicModelChoiceField(queryset=SoftwareVersion.objects.all())
+
     device_types = DynamicModelMultipleChoiceField(
         queryset=DeviceType.objects.all(),
         required=False,
@@ -5339,6 +5342,7 @@ class SoftwareVersionFilterForm(NautobotFilterForm, StatusModelFilterFormMixin):
 class SoftwareVersionForm(NautobotModelForm):
     """SoftwareVersion credit/edit form."""
 
+    platform = DynamicModelChoiceField(queryset=Platform.objects.all())
     release_date = NullableDateField(required=False, widget=DatePicker())
     end_of_support_date = NullableDateField(required=False, widget=DatePicker())
     field_order = [

nautobot/dcim/migrations/0074_alter_rack_u_height.py

@@ -0,0 +1,21 @@
+# Generated by Django 4.2.24 on 2025-09-17 08:28
+
+import django.core.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("dcim", "0073_alter_powerport_power_factor_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="rack",
+            name="u_height",
+            field=models.PositiveSmallIntegerField(
+                default=42,
+                validators=[django.core.validators.MinValueValidator(1), django.core.validators.MaxValueValidator(500)],
+            ),
+        ),
+    ]

nautobot/dcim/models/devices.py

@@ -31,7 +31,10 @@ from nautobot.dcim.utils import get_all_network_driver_mappings, get_network_dri
 from nautobot.extras.models import ChangeLoggedModel, ConfigContextModel, RoleField, StatusField
 from nautobot.extras.querysets import ConfigContextModelQuerySet
 from nautobot.extras.utils import extras_features
-from nautobot.wireless.models import ControllerManagedDeviceGroupWirelessNetworkAssignment
+from nautobot.wireless.models import (
+    ControllerManagedDeviceGroupRadioProfileAssignment,
+    ControllerManagedDeviceGroupWirelessNetworkAssignment,
+)
 
 from .device_components import (
     ConsolePort,
@@ -940,6 +943,10 @@ class Device(PrimaryModel, ConfigContextModel):
         """
         return self.virtual_chassis.master if self.virtual_chassis else None
 
+    @property
+    def is_vc_master(self):
+        return self == self.get_vc_master()
+
     @property
     def vc_interfaces(self):
         """
@@ -1079,6 +1086,28 @@ class Device(PrimaryModel, ConfigContextModel):
         """
         return RearPort.objects.filter(Q(device=self) | Q(module__in=self.all_modules))
 
+    @property
+    def radio_profile_assignments(self):
+        """
+        Returns all Controller Managed Device Group Radio Profile Assignments linked to this device group.
+        """
+        if self.controller_managed_device_group is None:
+            return ControllerManagedDeviceGroupRadioProfileAssignment.objects.none()
+        return ControllerManagedDeviceGroupRadioProfileAssignment.objects.filter(
+            controller_managed_device_group=self.controller_managed_device_group
+        )
+
+    @property
+    def wireless_network_assignments(self):
+        """
+        Returns all Controller Managed Device Group Wireless Network Assignments linked to this device group.
+        """
+        if self.controller_managed_device_group is None:
+            return ControllerManagedDeviceGroupWirelessNetworkAssignment.objects.none()
+        return ControllerManagedDeviceGroupWirelessNetworkAssignment.objects.filter(
+            controller_managed_device_group=self.controller_managed_device_group
+        )
+
 
 #
 # Virtual chassis

nautobot/dcim/models/racks.py

@@ -14,7 +14,7 @@ from nautobot.core.models.utils import array_to_string
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.data import UtilizationData
 from nautobot.dcim.choices import DeviceFaceChoices, RackDimensionUnitChoices, RackTypeChoices, RackWidthChoices
-from nautobot.dcim.constants import RACK_ELEVATION_LEGEND_WIDTH_DEFAULT, RACK_U_HEIGHT_DEFAULT
+from nautobot.dcim.constants import RACK_ELEVATION_LEGEND_WIDTH_DEFAULT, RACK_U_HEIGHT_DEFAULT, RACK_U_HEIGHT_MAXIMUM
 from nautobot.dcim.elevations import RackElevationSVG
 from nautobot.extras.models import RoleField, StatusField
 from nautobot.extras.utils import extras_features
@@ -153,7 +153,7 @@ class Rack(PrimaryModel):
     u_height = models.PositiveSmallIntegerField(
         default=RACK_U_HEIGHT_DEFAULT,
         verbose_name="Height (U)",
-        validators=[MinValueValidator(1), MaxValueValidator(100)],
+        validators=[MinValueValidator(1), MaxValueValidator(RACK_U_HEIGHT_MAXIMUM)],
         help_text="Height in rack units",
     )
     desc_units = models.BooleanField(

nautobot/dcim/tables/__init__.py

@@ -39,6 +39,7 @@ from .devices import (
     RearPortTable,
     SoftwareImageFileTable,
     SoftwareVersionTable,
+    VirtualChassisMembersTable,
     VirtualChassisTable,
     VirtualDeviceContextTable,
 )
@@ -125,6 +126,7 @@ __all__ = (
     "RearPortTemplateTable",
     "SoftwareImageFileTable",
     "SoftwareVersionTable",
+    "VirtualChassisMembersTable",
     "VirtualChassisTable",
     "VirtualDeviceContextTable",
 )

nautobot/dcim/tables/devices.py

@@ -154,6 +154,30 @@ class PlatformTable(BaseTable):
 #
 
 
+class VirtualChassisMembersTable(BaseTable):
+    name = tables.TemplateColumn(order_by=("_name",), template_code=DEVICE_LINK, verbose_name="Device")
+    vc_position = tables.TemplateColumn(
+        verbose_name="Position", template_code='<span class="badge badge-default">{{ record.vc_position }}</span>'
+    )
+    master = BooleanColumn(accessor="is_vc_master", verbose_name="Master")
+    vc_priority = tables.Column(verbose_name="Priority")
+
+    class Meta(BaseTable.Meta):
+        model = Device
+        fields = (
+            "name",
+            "vc_position",
+            "master",
+            "vc_priority",
+        )
+        default_columns = (
+            "name",
+            "vc_position",
+            "master",
+            "vc_priority",
+        )
+
+
 class DeviceTable(StatusTableMixin, RoleTableMixin, BaseTable):
     pk = ToggleColumn()
     name = tables.TemplateColumn(order_by=("_name",), template_code=DEVICE_LINK)

nautobot/dcim/tables/power.py

@@ -76,8 +76,8 @@ class PowerFeedTable(StatusTableMixin, CableTerminationTable):
     rack = tables.Column(linkify=True)
     type = ChoiceFieldColumn()
     power_path = tables.Column()
-    occupied_positions = tables.Column(accessor="occupied_positions", verbose_name="Position")
-    phase_designation = tables.Column(accessor="phase_designation", verbose_name="Phase Designation")
+    occupied_positions = tables.Column(accessor="occupied_positions", verbose_name="Position", orderable=False)
+    phase_designation = tables.Column(accessor="phase_designation", verbose_name="Phase Designation", orderable=False)
     max_utilization = tables.TemplateColumn(template_code="{{ value }}%")
     available_power = tables.Column(verbose_name="Available power (VA)")
     tags = TagColumn(url_name="dcim:powerfeed_list")