nautobot 3.0.0a2__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/dcim/filter_mixins.py

@@ -1,5 +1,354 @@
-# TODO: remove this entire file in 2.2
-# for backwards compatibility with Nautobot 1.4 - avoid importing this file if at all possible!
-from nautobot.dcim.filters.mixins import LocatableModelFilterSetMixin
+from django.db.models import Q
+import django_filters
 
-__all__ = ("LocatableModelFilterSetMixin",)
+from nautobot.core.filters import (
+    MultiValueCharFilter,
+    MultiValueMACAddressFilter,
+    MultiValueUUIDFilter,
+    NameSearchFilterSet,
+    NaturalKeyOrPKMultipleChoiceFilter,
+    RelatedMembershipBooleanFilter,
+    SearchFilter,
+    TreeNodeMultipleChoiceFilter,
+)
+from nautobot.core.utils.data import is_uuid
+from nautobot.dcim.constants import MODULE_RECURSION_DEPTH_LIMIT
+from nautobot.dcim.models import (
+    Cable,
+    ConsolePort,
+    ConsolePortTemplate,
+    ConsoleServerPort,
+    ConsoleServerPortTemplate,
+    Device,
+    DeviceType,
+    FrontPort,
+    FrontPortTemplate,
+    Interface,
+    InterfaceTemplate,
+    Location,
+    Manufacturer,
+    Module,
+    ModuleBay,
+    ModuleBayTemplate,
+    ModuleType,
+    PowerOutlet,
+    PowerOutletTemplate,
+    PowerPort,
+    PowerPortTemplate,
+    RearPort,
+    RearPortTemplate,
+)
+from nautobot.extras.filter_mixins import CustomFieldModelFilterSetMixin, RelationshipModelFilterSetMixin
+
+
+class CableTerminationModelFilterSetMixin(django_filters.FilterSet):
+    has_cable = RelatedMembershipBooleanFilter(
+        field_name="cable",
+        label="Has cable",
+    )
+    cable = django_filters.ModelMultipleChoiceFilter(
+        queryset=Cable.objects.all(),
+        label="Cable",
+    )
+
+
+class DeviceComponentTemplateModelFilterSetMixin(NameSearchFilterSet, CustomFieldModelFilterSetMixin):
+    device_type = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=DeviceType.objects.all(),
+        to_field_name="model",
+        label="Device type (model or ID)",
+    )
+    label = MultiValueCharFilter(label="Label")
+    description = MultiValueCharFilter(label="Description")
+    id = MultiValueUUIDFilter(label="ID")
+    name = MultiValueCharFilter(label="Name")
+
+
+class ModularDeviceComponentTemplateModelFilterSetMixin(DeviceComponentTemplateModelFilterSetMixin):
+    has_device_type = RelatedMembershipBooleanFilter(
+        field_name="device_type",
+        label="Has device type",
+    )
+    module_type = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=ModuleType.objects.all(),
+        to_field_name="model",
+        label="Module type (model or ID)",
+    )
+    has_module_type = RelatedMembershipBooleanFilter(
+        field_name="module_type",
+        label="Has module type",
+    )
+
+
+class DeviceComponentModelFilterSetMixin(CustomFieldModelFilterSetMixin):
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "label": "icontains",
+            "description": "icontains",
+        },
+    )
+    location = NaturalKeyOrPKMultipleChoiceFilter(
+        field_name="device__location",
+        queryset=Location.objects.all(),
+        to_field_name="name",
+        label="Location (name or ID)",
+    )
+    device = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Device.objects.all(),
+        to_field_name="name",
+        label="Device (name or ID)",
+    )
+
+
+class ModularDeviceComponentModelFilterSetMixin(DeviceComponentModelFilterSetMixin, RelationshipModelFilterSetMixin):
+    module = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Module.objects.all(),
+        to_field_name="module_type__model",
+        label="Module (model or ID)",
+    )
+    device = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Device.objects.all(),
+        to_field_name="name",
+        label="Device (name or ID)",
+        method="filter_device",
+    )
+
+    def _construct_device_filter_recursively(self, field_name, value):
+        recursion_depth = MODULE_RECURSION_DEPTH_LIMIT - 1
+        query = Q(**{f"device__{field_name}__in": value})
+        for level in range(recursion_depth):
+            recursive_query = "module__parent_module_bay__" + "parent_module__parent_module_bay__" * level
+            query = query | Q(**{f"{recursive_query}parent_device__{field_name}__in": value})
+        return query
+
+    def generate_query_filter_device(self, value):
+        if not hasattr(value, "__iter__") or isinstance(value, str):
+            value = [value]
+
+        device_ids = set(str(item) for item in value if is_uuid(item))
+        device_names = set(str(item) for item in value if not is_uuid(item))
+        query = self._construct_device_filter_recursively("name", device_names)
+        query |= self._construct_device_filter_recursively("id", device_ids)
+        return query
+
+    def filter_device(self, queryset, name, value):
+        if not value:
+            return queryset
+        params = self.generate_query_filter_device(value)
+        return queryset.filter(params)
+
+
+class LocatableModelFilterSetMixin(django_filters.FilterSet):
+    """Mixin to add `location` filter fields to a FilterSet.
+
+    The expectation is that the linked model has `location` FK fields.
+    """
+
+    location = TreeNodeMultipleChoiceFilter(
+        prefers_id=True,
+        queryset=Location.objects.all(),
+        to_field_name="name",
+        label="Location (name or ID)",
+    )
+
+
+class PathEndpointModelFilterSetMixin(django_filters.FilterSet):
+    connected = django_filters.BooleanFilter(method="filter_connected", label="Connected status (bool)")
+
+    def filter_connected(self, queryset, name, value):
+        if value:
+            return queryset.filter(_path__is_active=True)
+        else:
+            return queryset.filter(Q(_path__isnull=True) | Q(_path__is_active=False))
+
+
+class DeviceModuleCommonFiltersMixin(django_filters.FilterSet):
+    mac_address = MultiValueMACAddressFilter(
+        field_name="interfaces__mac_address",
+        label="MAC address",
+    )
+    has_console_ports = RelatedMembershipBooleanFilter(
+        field_name="console_ports",
+        label="Has console ports",
+    )
+    console_ports = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=ConsolePort.objects.all(),
+        to_field_name="name",
+        label="Console Ports (name or ID)",
+    )
+    has_console_server_ports = RelatedMembershipBooleanFilter(
+        field_name="console_server_ports",
+        label="Has console server ports",
+    )
+    console_server_ports = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=ConsoleServerPort.objects.all(),
+        to_field_name="name",
+        label="Console Server Ports (name or ID)",
+    )
+    has_power_ports = RelatedMembershipBooleanFilter(
+        field_name="power_ports",
+        label="Has power ports",
+    )
+    power_ports = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=PowerPort.objects.all(),
+        to_field_name="name",
+        label="Power Ports (name or ID)",
+    )
+    has_power_outlets = RelatedMembershipBooleanFilter(
+        field_name="power_outlets",
+        label="Has power outlets",
+    )
+    power_outlets = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=PowerOutlet.objects.all(),
+        to_field_name="name",
+        label="Power Outlets (name or ID)",
+    )
+    has_interfaces = RelatedMembershipBooleanFilter(
+        field_name="interfaces",
+        label="Has interfaces",
+    )
+    interfaces = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Interface.objects.all(),
+        to_field_name="name",
+        label="Interfaces (name or ID)",
+    )
+    has_front_ports = RelatedMembershipBooleanFilter(
+        field_name="front_ports",
+        label="Has front ports",
+    )
+    front_ports = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=FrontPort.objects.all(),
+        to_field_name="name",
+        label="Front Ports (name or ID)",
+    )
+    has_rear_ports = RelatedMembershipBooleanFilter(
+        field_name="rear_ports",
+        label="Has rear ports",
+    )
+    rear_ports = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=RearPort.objects.all(),
+        to_field_name="name",
+        label="Rear Ports (name or ID)",
+    )
+    has_module_bays = RelatedMembershipBooleanFilter(
+        field_name="module_bays",
+        label="Has module bays",
+    )
+    has_empty_module_bays = django_filters.BooleanFilter(
+        method="filter_has_empty_module_bays",
+        label="Has empty module bays",
+    )
+    module_bays = django_filters.ModelMultipleChoiceFilter(
+        queryset=ModuleBay.objects.all(),
+        label="Module Bays",
+    )
+    has_modules = RelatedMembershipBooleanFilter(
+        field_name="module_bays__installed_module",
+        label="Has modules",
+    )
+
+    def generate_query_filter_has_empty_module_bays(self, value):
+        if value is True:
+            query = Q(module_bays__isnull=False, module_bays__installed_module__isnull=True)
+        else:
+            query = Q(module_bays__isnull=True) | ~Q(module_bays__installed_module__isnull=True)
+        return query
+
+    def filter_has_empty_module_bays(self, queryset, name, value):
+        if value is None:
+            return queryset.none
+        params = self.generate_query_filter_has_empty_module_bays(value)
+        return queryset.filter(params)
+
+
+class DeviceTypeModuleTypeCommonFiltersMixin(django_filters.FilterSet):
+    manufacturer = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Manufacturer.objects.all(),
+        to_field_name="name",
+        label="Manufacturer (name or ID)",
+    )
+    # TODO: solve https://github.com/nautobot/nautobot/issues/2875 to use this filter correctly
+    console_port_templates = NaturalKeyOrPKMultipleChoiceFilter(
+        prefers_id=True,
+        to_field_name="name",
+        queryset=ConsolePortTemplate.objects.all(),
+        label="Console port templates (name or ID)",
+    )
+    has_console_port_templates = RelatedMembershipBooleanFilter(
+        field_name="console_port_templates",
+        label="Has console port templates",
+    )
+    # TODO: solve https://github.com/nautobot/nautobot/issues/2875 to use this filter correctly
+    console_server_port_templates = NaturalKeyOrPKMultipleChoiceFilter(
+        prefers_id=True,
+        to_field_name="name",
+        queryset=ConsoleServerPortTemplate.objects.all(),
+        label="Console server port templates (name or ID)",
+    )
+    has_console_server_port_templates = RelatedMembershipBooleanFilter(
+        field_name="console_server_port_templates",
+        label="Has console server port templates",
+    )
+    # TODO: solve https://github.com/nautobot/nautobot/issues/2875 to use this filter correctly
+    power_port_templates = NaturalKeyOrPKMultipleChoiceFilter(
+        prefers_id=True,
+        to_field_name="name",
+        queryset=PowerPortTemplate.objects.all(),
+        label="Power port templates (name or ID)",
+    )
+    has_power_port_templates = RelatedMembershipBooleanFilter(
+        field_name="power_port_templates",
+        label="Has power port templates",
+    )
+    # TODO: solve https://github.com/nautobot/nautobot/issues/2875 to use this filter correctly
+    power_outlet_templates = NaturalKeyOrPKMultipleChoiceFilter(
+        prefers_id=True,
+        to_field_name="name",
+        queryset=PowerOutletTemplate.objects.all(),
+        label="Power outlet templates (name or ID)",
+    )
+    has_power_outlet_templates = RelatedMembershipBooleanFilter(
+        field_name="power_outlet_templates",
+        label="Has power outlet templates",
+    )
+    # TODO: solve https://github.com/nautobot/nautobot/issues/2875 to use this filter correctly
+    interface_templates = NaturalKeyOrPKMultipleChoiceFilter(
+        prefers_id=True,
+        to_field_name="name",
+        queryset=InterfaceTemplate.objects.all(),
+        label="Interface templates (name or ID)",
+    )
+    has_interface_templates = RelatedMembershipBooleanFilter(
+        field_name="interface_templates",
+        label="Has interface templates",
+    )
+    # TODO: solve https://github.com/nautobot/nautobot/issues/2875 to use this filter correctly
+    front_port_templates = NaturalKeyOrPKMultipleChoiceFilter(
+        prefers_id=True,
+        to_field_name="name",
+        queryset=FrontPortTemplate.objects.all(),
+        label="Front port templates (name or ID)",
+    )
+    has_front_port_templates = RelatedMembershipBooleanFilter(
+        field_name="front_port_templates",
+        label="Has front port templates",
+    )
+    # TODO: solve https://github.com/nautobot/nautobot/issues/2875 to use this filter correctly
+    rear_port_templates = NaturalKeyOrPKMultipleChoiceFilter(
+        prefers_id=True,
+        to_field_name="name",
+        queryset=RearPortTemplate.objects.all(),
+        label="Rear port templates (name or ID)",
+    )
+    has_rear_port_templates = RelatedMembershipBooleanFilter(
+        field_name="rear_port_templates",
+        label="Has rear port templates",
+    )
+    module_bay_templates = django_filters.ModelMultipleChoiceFilter(
+        queryset=ModuleBayTemplate.objects.all(),
+    )
+    has_module_bay_templates = RelatedMembershipBooleanFilter(
+        field_name="module_bay_templates",
+        label="Has module bay templates",
+    )

nautobot/dcim/{filters/__init__.py → filters.py}

@@ -18,7 +18,6 @@ from nautobot.core.filters import (
     TreeNodeMultipleChoiceFilter,
 )
 from nautobot.core.utils.data import is_uuid
-from nautobot.core.utils.deprecation import class_deprecated_in_favor_of
 from nautobot.dcim.choices import (
     CableTypeChoices,
     ConsolePortTypeChoices,
@@ -35,7 +34,7 @@ from nautobot.dcim.constants import (
     VIRTUAL_IFACE_TYPES,
     WIRELESS_IFACE_TYPES,
 )
-from nautobot.dcim.filters.mixins import (
+from nautobot.dcim.filter_mixins import (
     CableTerminationModelFilterSetMixin,
     DeviceComponentModelFilterSetMixin,
     DeviceComponentTemplateModelFilterSetMixin,
@@ -104,14 +103,13 @@ from nautobot.extras.filters import (
 from nautobot.extras.models import ExternalIntegration, SecretsGroup
 from nautobot.extras.utils import FeatureQuery
 from nautobot.ipam.models import IPAddress, VLAN, VLANGroup
-from nautobot.tenancy.filters.mixins import TenancyModelFilterSetMixin
+from nautobot.tenancy.filter_mixins import TenancyModelFilterSetMixin
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import Cluster, VirtualMachine
 from nautobot.wireless.models import RadioProfile, WirelessNetwork
 
 __all__ = (
     "CableFilterSet",
-    "CableTerminationFilterSet",
     "CableTerminationModelFilterSetMixin",
     "ConsoleConnectionFilterSet",
     "ConsolePortFilterSet",
@@ -145,7 +143,6 @@ __all__ = (
     "ModuleFamilyFilterSet",
     "ModuleFilterSet",
     "ModuleTypeFilterSet",
-    "PathEndpointFilterSet",
     "PathEndpointModelFilterSetMixin",
     "PlatformFilterSet",
     "PowerConnectionFilterSet",
@@ -667,12 +664,6 @@ class DeviceTypeFilterSet(DeviceTypeModuleTypeCommonFiltersMixin, NautobotFilter
         return queryset.exclude(device_bay_templates__isnull=value)
 
 
-# TODO: remove in 2.2
-@class_deprecated_in_favor_of(DeviceComponentTemplateModelFilterSetMixin)
-class DeviceTypeComponentFilterSet(DeviceComponentTemplateModelFilterSetMixin):
-    pass
-
-
 class ConsolePortTemplateFilterSet(ModularDeviceComponentTemplateModelFilterSetMixin, BaseFilterSet):
     class Meta:
         model = ConsolePortTemplate
@@ -978,24 +969,6 @@ class DeviceFilterSet(
         return queryset.filter(params)
 
 
-# TODO: remove in 2.2
-@class_deprecated_in_favor_of(DeviceComponentModelFilterSetMixin)
-class DeviceComponentFilterSet(DeviceComponentModelFilterSetMixin):
-    pass
-
-
-# TODO: remove in 2.2
-@class_deprecated_in_favor_of(CableTerminationModelFilterSetMixin)
-class CableTerminationFilterSet(CableTerminationModelFilterSetMixin):
-    pass
-
-
-# TODO: remove in 2.2
-@class_deprecated_in_favor_of(PathEndpointModelFilterSetMixin)
-class PathEndpointFilterSet(PathEndpointModelFilterSetMixin):
-    pass
-
-
 class ConsolePortFilterSet(
     ModularDeviceComponentModelFilterSetMixin,
     CableTerminationModelFilterSetMixin,
@@ -1524,12 +1497,6 @@ class ConnectionFilterSetMixin:
         return queryset.filter(**{f"{name}__in": value})
 
 
-# TODO: remove in 2.2
-@class_deprecated_in_favor_of(ConnectionFilterSetMixin)
-class ConnectionFilterSet(ConnectionFilterSetMixin):
-    pass
-
-
 class ConsoleConnectionFilterSet(ConnectionFilterSetMixin, BaseFilterSet):
     location = django_filters.CharFilter(
         method="filter_location",

nautobot/dcim/forms.py

@@ -4577,7 +4577,7 @@ class BaseVCMemberFormSet(forms.BaseModelFormSet):
                 vc_position_list.append(vc_position)
 
 
-class DeviceVCMembershipForm(forms.ModelForm):
+class DeviceVCMembershipForm(BootstrapMixin, forms.ModelForm):
     class Meta:
         model = Device
         fields = [

nautobot/dcim/migrations/0078_remove_device_location_tenant_name_uniqueness.py

@@ -0,0 +1,16 @@
+# Generated by Django 4.2.24 on 2025-10-07 07:18
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("dcim", "0077_remove_device_cluster"),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name="device",
+            unique_together={("rack", "position", "face"), ("virtual_chassis", "vc_position")},
+        ),
+    ]

nautobot/dcim/migrations/0079_device_name_data_migration.py

@@ -0,0 +1,59 @@
+# Generated by Django 4.2.24 on 2025-10-07 07:18
+
+from constance.models import Constance
+from django.db import migrations
+
+from nautobot.core.utils.config import get_settings_or_config
+from nautobot.dcim.choices import DeviceUniquenessChoices
+
+
+def migrate_device_uniqueness_setting(apps, schema_editor):
+    """
+    Migrate deprecated DEVICE_NAME_AS_NATURAL_KEY setting to DEVICE_UNIQUENESS and DEVICE_NAME_REQUIRED.
+    """
+    try:
+        old_value = get_settings_or_config("DEVICE_NAME_AS_NATURAL_KEY")
+    except AttributeError:
+        old_value = False
+    new_value = DeviceUniquenessChoices.NAME if old_value else DeviceUniquenessChoices.LOCATION_TENANT_NAME
+
+    # Update or create DEVICE_UNIQUENESS in Constance
+    Constance.objects.update_or_create(
+        key="DEVICE_UNIQUENESS",
+        defaults={"value": new_value},
+    )
+
+    # cleanup: remove deprecated setting entry if it exists
+    Constance.objects.filter(key="DEVICE_NAME_AS_NATURAL_KEY").delete()
+
+
+def reverse_migrate_device_uniqueness_setting(apps, schema_editor):
+    """
+    Reverse migration set DEVICE_NAME_AS_NATURAL_KEY based on DEVICE_UNIQUENESS.
+    """
+    try:
+        device_uniqueness = Constance.objects.get(key="DEVICE_UNIQUENESS").value
+    except Constance.DoesNotExist:
+        return
+
+    if device_uniqueness == DeviceUniquenessChoices.NAME:
+        Constance.objects.update_or_create(key="DEVICE_NAME_AS_NATURAL_KEY", defaults={"value": True})
+    else:
+        Constance.objects.update_or_create(key="DEVICE_NAME_AS_NATURAL_KEY", defaults={"value": False})
+
+    # cleanup: remove DEVICE_UNIQUENESS setting entry if it exists
+    Constance.objects.filter(key="DEVICE_UNIQUENESS").delete()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("dcim", "0078_remove_device_location_tenant_name_uniqueness"),
+        ("constance", "0003_drop_pickle"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            migrate_device_uniqueness_setting,
+            reverse_migrate_device_uniqueness_setting,
+        ),
+    ]