nautobot 2.3.16__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/dcim/models/device_components.py

@@ -138,7 +138,7 @@ class ModularComponentModel(ComponentModel):
     @property
     def parent(self):
         """Device that this component belongs to, walking up module inheritance if necessary."""
-        return self.module.device if self.module else self.device  # pylint: disable=no-member
+        return self.module.device if self.module else self.device
 
     def render_name_template(self, save=False):
         """
@@ -161,9 +161,9 @@ class ModularComponentModel(ComponentModel):
 
             The deeply nested interface would be named "A{module.parent}" after calling this method.
         """
-        if self.module and self.module.parent_module_bay and "{module" in self.name:  # pylint: disable=no-member
+        if self.module and self.module.parent_module_bay and "{module" in self.name:
             name = ""
-            module_bay = self.module.parent_module_bay  # pylint: disable=no-member
+            module_bay = self.module.parent_module_bay
             positions = []
             while module_bay is not None:
                 position = getattr(module_bay, "position", None)
@@ -291,11 +291,11 @@ class PathEndpoint(models.Model):
             return []
 
         # Construct the complete path
-        path = [self, *self._path.get_path()]  # pylint: disable=no-member
+        path = [self, *self._path.get_path()]
         while (len(path) + 1) % 3:
             # Pad to ensure we have complete three-tuples (e.g. for paths that end at a RearPort)
             path.append(None)
-        path.append(self._path.destination)  # pylint: disable=no-member
+        path.append(self._path.destination)
 
         # Return the path as a list of three-tuples (A termination, cable, B termination)
         return list(zip(*[iter(path)] * 3))
@@ -555,7 +555,7 @@ class BaseInterface(RelationshipModel):
 
     def clean(self):
         # Remove untagged VLAN assignment for non-802.1Q interfaces
-        if not self.mode and self.untagged_vlan is not None:  # pylint: disable=no-member  # Intf/VMIntf both have untagged_vlan
+        if not self.mode and self.untagged_vlan is not None:
             raise ValidationError({"untagged_vlan": "Mode must be set when specifying untagged_vlan"})
 
     def save(self, *args, **kwargs):
@@ -569,8 +569,8 @@ class BaseInterface(RelationshipModel):
             self.status = status
 
         # Only "tagged" interfaces may have tagged VLANs assigned. ("tagged all" implies all VLANs are assigned.)
-        if self.present_in_database and self.mode != InterfaceModeChoices.MODE_TAGGED:  # pylint: disable=no-member
-            self.tagged_vlans.clear()  # pylint: disable=no-member  # Intf/VMIntf both have tagged_vlans
+        if self.present_in_database and self.mode != InterfaceModeChoices.MODE_TAGGED:
+            self.tagged_vlans.clear()
 
         return super().save(*args, **kwargs)
 
@@ -710,19 +710,18 @@ class Interface(ModularComponentModel, CableTermination, PathEndpoint, BaseInter
                 )
 
             # An interface's parent must belong to the same device or virtual chassis
-            if self.parent and self.parent_interface.parent != self.parent:  # pylint: disable=no-member
+            if self.parent and self.parent_interface.parent != self.parent:
                 if getattr(self.parent, "virtual_chassis", None) is None:
                     raise ValidationError(
-                        {  # pylint: disable=no-member  # false positive on parent_interface.parent
-                            "parent_interface": f"The selected parent interface ({self.parent_interface}) belongs "
-                            f"to a different device ({self.parent_interface.parent})."
+                        {
+                            "parent_interface": f"The selected parent interface ({self.parent_interface}) belongs to a different device "
+                            f"({self.parent_interface.parent})."
                         }
                     )
-                elif self.parent_interface.parent.virtual_chassis != self.parent.virtual_chassis:  # pylint: disable=no-member
+                elif self.parent_interface.parent.virtual_chassis != self.parent.virtual_chassis:
                     raise ValidationError(
-                        {  # pylint: disable=no-member  # false positive on parent_interface.parent
-                            "parent_interface": f"The selected parent interface ({self.parent_interface}) belongs "
-                            f"to {self.parent_interface.parent}, which "
+                        {
+                            "parent_interface": f"The selected parent interface ({self.parent_interface}) belongs to {self.parent_interface.parent}, which "
                             f"is not part of virtual chassis {self.parent.virtual_chassis}."
                         }
                     )
@@ -755,22 +754,21 @@ class Interface(ModularComponentModel, CableTermination, PathEndpoint, BaseInter
                 raise ValidationError({"bridge": "An interface cannot be bridged to itself."})
 
             # A bridged interface belong to the same device or virtual chassis
-            if self.parent and self.bridge.parent != self.parent:  # pylint: disable=no-member
+            if self.parent and self.bridge.parent != self.parent:
                 if getattr(self.parent, "virtual_chassis", None) is None:
                     raise ValidationError(
                         {
                             "bridge": (
-                                # pylint: disable=no-member  # false positive on bridge.parent
                                 f"The selected bridge interface ({self.bridge}) belongs to a different device "
                                 f"({self.bridge.parent})."
                             )
                         }
                     )
-                elif self.bridge.parent.virtual_chassis_id != self.parent.virtual_chassis_id:  # pylint: disable=no-member
+                elif self.bridge.parent.virtual_chassis_id != self.parent.virtual_chassis_id:
                     raise ValidationError(
                         {
                             "bridge": (
-                                f"The selected bridge interface ({self.bridge}) belongs to {self.bridge.parent}, which "  # pylint: disable=no-member
+                                f"The selected bridge interface ({self.bridge}) belongs to {self.bridge.parent}, which "
                                 f"is not part of virtual chassis {self.parent.virtual_chassis}."
                             )
                         }
@@ -1086,8 +1084,8 @@ class DeviceBay(ComponentModel):
         super().clean()
 
         # Validate that the parent Device can have DeviceBays
-        if not self.device.device_type.is_parent_device:  # pylint: disable=no-member
-            raise ValidationError(f"This type of device ({self.device.device_type}) does not support device bays.")  # pylint: disable=no-member
+        if not self.device.device_type.is_parent_device:
+            raise ValidationError(f"This type of device ({self.device.device_type}) does not support device bays.")
 
         # Cannot install a device into itself, obviously
         if self.device == self.installed_device:

nautobot/dcim/models/devices.py

@@ -9,16 +9,17 @@ from django.db import models
 from django.db.models import F, ProtectedError, Q
 from django.urls import reverse
 from django.utils.functional import cached_property, classproperty
-from django.utils.html import format_html
+from django.utils.html import format_html, format_html_join
 import yaml
 
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.models import BaseManager, RestrictedQuerySet
-from nautobot.core.models.fields import NaturalOrderingField
+from nautobot.core.models.fields import JSONArrayField, NaturalOrderingField
 from nautobot.core.models.generics import BaseModel, OrganizationalModel, PrimaryModel
 from nautobot.core.models.tree_queries import TreeModel
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.dcim.choices import (
+    ControllerCapabilitiesChoices,
     DeviceFaceChoices,
     DeviceRedundancyGroupFailoverStrategyChoices,
     SoftwareImageFileHashingAlgorithmChoices,
@@ -47,12 +48,13 @@ __all__ = (
     "Controller",
     "ControllerManagedDeviceGroup",
     "Device",
-    "DeviceFamily",
     "DeviceRedundancyGroup",
     "DeviceType",
+    "InterfaceVDCAssignment",
     "Manufacturer",
     "Platform",
     "VirtualChassis",
+    "VirtualDeviceContext",
 )
 
 
@@ -1365,6 +1367,12 @@ class Controller(PrimaryModel):
         null=True,
     )
     role = RoleField(blank=True, null=True)
+    capabilities = JSONArrayField(
+        base_field=models.CharField(choices=ControllerCapabilitiesChoices),
+        blank=True,
+        null=True,
+        help_text="List of capabilities supported by the controller, these capabilities are used to enhance views in Nautobot.",
+    )
     tenant = models.ForeignKey(
         to="tenancy.Tenant",
         on_delete=models.PROTECT,
@@ -1416,6 +1424,11 @@ class Controller(PrimaryModel):
                     {"location": f'Devices may not associate to locations of type "{self.location.location_type}".'}
                 )
 
+    def get_capabilities_display(self):
+        if not self.capabilities:
+            return format_html('<span class="text-muted">&mdash;</span>')
+        return format_html_join(" ", '<span class="label label-default">{}</span>', ((v,) for v in self.capabilities))
+
 
 @extras_features(
     "custom_links",
@@ -1435,6 +1448,7 @@ class ControllerManagedDeviceGroup(TreeModel, PrimaryModel):
         unique=True,
         help_text="Name of the controller device group",
     )
+    description = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True)
     weight = models.PositiveIntegerField(
         default=1000,
         help_text="Weight of the controller device group, used to sort the groups within its parent group",
@@ -1447,6 +1461,26 @@ class ControllerManagedDeviceGroup(TreeModel, PrimaryModel):
         null=False,
         help_text="Controller that manages the devices in this group",
     )
+    radio_profiles = models.ManyToManyField(
+        to="wireless.RadioProfile",
+        related_name="controller_managed_device_groups",
+        through="wireless.ControllerManagedDeviceGroupRadioProfileAssignment",
+        through_fields=("controller_managed_device_group", "radio_profile"),
+        blank=True,
+    )
+    wireless_networks = models.ManyToManyField(
+        to="wireless.WirelessNetwork",
+        related_name="controller_managed_device_groups",
+        through="wireless.ControllerManagedDeviceGroupWirelessNetworkAssignment",
+        through_fields=("controller_managed_device_group", "wireless_network"),
+        blank=True,
+    )
+    capabilities = JSONArrayField(
+        base_field=models.CharField(choices=ControllerCapabilitiesChoices),
+        blank=True,
+        null=True,
+        help_text="List of capabilities supported by the controller device group, these capabilities are used to enhance views in Nautobot.",
+    )
 
     class Meta:
         ordering = ("weight",)
@@ -1466,11 +1500,16 @@ class ControllerManagedDeviceGroup(TreeModel, PrimaryModel):
         if self.controller == self._original_controller and self.parent == self._original_parent:
             return
 
-        if self.parent and self.controller and self.controller != self.parent.controller:  # pylint: disable=no-member
+        if self.parent and self.controller and self.controller != self.parent.controller:
             raise ValidationError(
                 {"controller": "Controller device group must have the same controller as the parent group."}
             )
 
+    def get_capabilities_display(self):
+        if not self.capabilities:
+            return format_html('<span class="text-muted">&mdash;</span>')
+        return format_html_join(" ", '<span class="label label-default">{}</span>', ((v,) for v in self.capabilities))
+
 
 #
 # Modules
@@ -1839,3 +1878,133 @@ class Module(PrimaryModel):
         Return the set of child Modules installed in ModuleBays within this Module.
         """
         return Module.objects.filter(parent_module_bay__parent_module=self)
+
+
+#
+# Virtual Device Contexts
+#
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+    "statuses",
+    "webhooks",
+)
+class VirtualDeviceContext(PrimaryModel):
+    name = models.CharField(max_length=CHARFIELD_MAX_LENGTH)
+    device = models.ForeignKey("dcim.Device", on_delete=models.CASCADE, related_name="virtual_device_contexts")
+    identifier = models.PositiveSmallIntegerField(
+        help_text="Unique identifier provided by the platform being virtualized (Example: Nexus VDC Identifier)",
+        blank=True,
+        null=True,
+    )
+    status = StatusField(blank=False, null=False)
+    role = RoleField(blank=True, null=True)
+    primary_ip4 = models.ForeignKey(
+        to="ipam.IPAddress",
+        on_delete=models.SET_NULL,
+        related_name="ip4_vdcs",
+        blank=True,
+        null=True,
+        verbose_name="Primary IPv4",
+    )
+    primary_ip6 = models.ForeignKey(
+        to="ipam.IPAddress",
+        on_delete=models.SET_NULL,
+        related_name="ip6_vdcs",
+        blank=True,
+        null=True,
+        verbose_name="Primary IPv6",
+    )
+    tenant = models.ForeignKey(
+        "tenancy.Tenant", on_delete=models.CASCADE, related_name="virtual_device_contexts", blank=True, null=True
+    )
+    interfaces = models.ManyToManyField(
+        blank=True,
+        related_name="virtual_device_contexts",
+        to="dcim.Interface",
+        through="dcim.InterfaceVDCAssignment",
+    )
+    description = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True)
+
+    class Meta:
+        ordering = ("name",)
+        unique_together = (("device", "identifier"), ("device", "name"))
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def primary_ip(self):
+        if get_settings_or_config("PREFER_IPV4") and self.primary_ip4:
+            return self.primary_ip4
+        elif self.primary_ip6:
+            return self.primary_ip6
+        elif self.primary_ip4:
+            return self.primary_ip4
+        else:
+            return None
+
+    def validate_primary_ips(self):
+        for field in ["primary_ip4", "primary_ip6"]:
+            ip = getattr(self, field)
+            if ip is not None:
+                if field == "primary_ip4" and ip.ip_version != 4:
+                    raise ValidationError({f"{field}": f"{ip} is not an IPv4 address."})
+                if field == "primary_ip6" and ip.ip_version != 6:
+                    raise ValidationError({f"{field}": f"{ip} is not an IPv6 address."})
+                if not ip.interfaces.filter(device=self.device).exists():
+                    raise ValidationError(
+                        {f"{field}": f"{ip} is not part of an interface that belongs to this VDC's device."}
+                    )
+                # Note: The validation for primary IPs `validate_primary_ips` is commented out due to the order in which Django processes form validation with
+                # Many-to-Many (M2M) fields. During form saving, Django creates the instance first before assigning the M2M fields (in this case, interfaces).
+                # As a result, the primary_ips fields could fail validation at this point because the interfaces are not yet linked to the instance,
+                # leading to validation errors.
+                # interfaces = self.interfaces.all()
+                # if IPAddressToInterface.objects.filter(ip_address=ip, interface__in=interfaces).exists():
+                #     pass
+                # elif (
+                #     ip.nat_inside is None
+                #     or not IPAddressToInterface.objects.filter(
+                #         ip_address=ip.nat_inside, interface__in=interfaces
+                #     ).exists()
+                # ):
+                #     raise ValidationError(
+                #         {f"{field}": f"The specified IP address ({ip}) is not assigned to this Virtual Device Context."}
+                #     )
+
+    def clean(self):
+        super().clean()
+        self.validate_primary_ips()
+
+        # Validate that device is not being modified
+        if self.present_in_database:
+            vdc = VirtualDeviceContext.objects.get(id=self.id)
+            if vdc.device != self.device:
+                raise ValidationError({"device": "Virtual Device Context's device cannot be changed once created"})
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+)
+class InterfaceVDCAssignment(BaseModel):
+    virtual_device_context = models.ForeignKey(
+        VirtualDeviceContext, on_delete=models.CASCADE, related_name="interface_assignments"
+    )
+    interface = models.ForeignKey(
+        Interface, on_delete=models.CASCADE, related_name="virtual_device_context_assignments"
+    )
+
+    class Meta:
+        unique_together = ["virtual_device_context", "interface"]
+        ordering = ["virtual_device_context", "interface"]
+
+    def __str__(self):
+        return f"{self.virtual_device_context}: {self.interface}"

nautobot/dcim/models/locations.py

@@ -283,7 +283,7 @@ class Location(TreeModel, PrimaryModel):
             # We shouldn't have a parent, *unless* our own location type is permitted to be nested.
             if self.parent is not None:
                 if self.location_type.nestable:
-                    if self.parent.location_type != self.location_type:  # pylint: disable=no-member
+                    if self.parent.location_type != self.location_type:
                         raise ValidationError(
                             {
                                 "parent": f"A Location of type {self.location_type} may only have "
@@ -304,7 +304,7 @@ class Location(TreeModel, PrimaryModel):
 
             # Is the parent location of a correct type?
             if self.location_type.nestable:
-                if self.parent.location_type not in (self.location_type, self.location_type.parent):  # pylint: disable=no-member
+                if self.parent.location_type not in (self.location_type, self.location_type.parent):
                     raise ValidationError(
                         {
                             "parent": f"A Location of type {self.location_type} can only have a Location "
@@ -312,7 +312,7 @@ class Location(TreeModel, PrimaryModel):
                         }
                     )
             else:
-                if self.parent.location_type != self.location_type.parent:  # pylint: disable=no-member
+                if self.parent.location_type != self.location_type.parent:
                     raise ValidationError(
                         {
                             "parent": f"A Location of type {self.location_type} can only have a Location "

nautobot/dcim/models/power.py

@@ -73,11 +73,11 @@ class PowerPanel(PrimaryModel):
         if self.rack_group:
             if (
                 self.location is not None
-                and self.rack_group.location is not None  # pylint: disable=no-member
-                and self.rack_group.location not in self.location.ancestors(include_self=True)  # pylint: disable=no-member
+                and self.rack_group.location is not None
+                and self.rack_group.location not in self.location.ancestors(include_self=True)
             ):
                 raise ValidationError(
-                    {  # pylint: disable=no-member  # false positive on rack_group.location
+                    {
                         "rack_group": f'Rack group "{self.rack_group}" belongs to a location '
                         f'("{self.rack_group.location}") that does not contain "{self.location}".'
                     }
@@ -151,10 +151,9 @@ class PowerFeed(PrimaryModel, PathEndpoint, CableTermination):
         super().clean()
 
         # Rack must belong to same Location as PowerPanel
-        if self.rack and self.rack.location != self.power_panel.location:  # pylint: disable=no-member
+        if self.rack and self.rack.location != self.power_panel.location:
             raise ValidationError(
-                f"Rack {self.rack} ({self.rack.location}) and "  # pylint: disable=no-member
-                f"power panel {self.power_panel} ({self.power_panel.location}) are in different locations"
+                f"Rack {self.rack} ({self.rack.location}) and power panel {self.power_panel} ({self.power_panel.location}) are in different locations"
             )
 
         # AC voltage cannot be negative

nautobot/dcim/models/racks.py

@@ -77,11 +77,11 @@ class RackGroup(TreeModel, OrganizationalModel):
         # Parent RackGroup (if any) must belong to the same or ancestor Location
         if (
             self.parent is not None
-            and self.parent.location is not None  # pylint: disable=no-member
-            and self.parent.location not in self.location.ancestors(include_self=True)  # pylint: disable=no-member
+            and self.parent.location is not None
+            and self.parent.location not in self.location.ancestors(include_self=True)
         ):
             raise ValidationError(
-                {  # pylint: disable=no-member  # false positive on parent.location
+                {
                     "location": f'Location "{self.location}" is not descended from '
                     f'parent rack group "{self.parent}" location "{self.parent.location}".'
                 }
@@ -296,7 +296,7 @@ class Rack(PrimaryModel):
             # Determine which devices the user has permission to view
             permitted_device_ids = []
             if user is not None:
-                permitted_device_ids = self.devices.restrict(user, "view").values_list("pk", flat=True)  # pylint: disable=no-member
+                permitted_device_ids = self.devices.restrict(user, "view").values_list("pk", flat=True)
 
             for device in queryset:
                 if expand_devices:
@@ -391,9 +391,9 @@ class Rack(PrimaryModel):
             Defaults to True, showing device full name and hiding truncated.
         """
         if unit_width is None:
-            unit_width = get_settings_or_config("RACK_ELEVATION_DEFAULT_UNIT_WIDTH")
+            unit_width = get_settings_or_config("RACK_ELEVATION_DEFAULT_UNIT_WIDTH", fallback=230)
         if unit_height is None:
-            unit_height = get_settings_or_config("RACK_ELEVATION_DEFAULT_UNIT_HEIGHT")
+            unit_height = get_settings_or_config("RACK_ELEVATION_DEFAULT_UNIT_HEIGHT", fallback=22)
         elevation = RackElevationSVG(
             self, user=user, include_images=include_images, base_url=base_url, display_fullname=display_fullname
         )