nautobot 2.3.15b1__py3-none-any.whl → 2.3.16__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
+        return self.module.device if self.module else self.device  # pylint: disable=no-member
 
     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:
+        if self.module and self.module.parent_module_bay and "{module" in self.name:  # pylint: disable=no-member
             name = ""
-            module_bay = self.module.parent_module_bay
+            module_bay = self.module.parent_module_bay  # pylint: disable=no-member
             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()]
+        path = [self, *self._path.get_path()]  # pylint: disable=no-member
         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)
+        path.append(self._path.destination)  # pylint: disable=no-member
 
         # 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:
+        if not self.mode and self.untagged_vlan is not None:  # pylint: disable=no-member  # Intf/VMIntf both have untagged_vlan
             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:
-            self.tagged_vlans.clear()
+        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
 
         return super().save(*args, **kwargs)
 
@@ -710,18 +710,19 @@ 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:
+            if self.parent and self.parent_interface.parent != self.parent:  # pylint: disable=no-member
                 if getattr(self.parent, "virtual_chassis", None) is None:
                     raise ValidationError(
-                        {
-                            "parent_interface": f"The selected parent interface ({self.parent_interface}) belongs to a different device "
-                            f"({self.parent_interface.parent})."
+                        {  # 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})."
                         }
                     )
-                elif self.parent_interface.parent.virtual_chassis != self.parent.virtual_chassis:
+                elif self.parent_interface.parent.virtual_chassis != self.parent.virtual_chassis:  # pylint: disable=no-member
                     raise ValidationError(
-                        {
-                            "parent_interface": f"The selected parent interface ({self.parent_interface}) belongs to {self.parent_interface.parent}, which "
+                        {  # 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 "
                             f"is not part of virtual chassis {self.parent.virtual_chassis}."
                         }
                     )
@@ -754,21 +755,22 @@ 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:
+            if self.parent and self.bridge.parent != self.parent:  # pylint: disable=no-member
                 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:
+                elif self.bridge.parent.virtual_chassis_id != self.parent.virtual_chassis_id:  # pylint: disable=no-member
                     raise ValidationError(
                         {
                             "bridge": (
-                                f"The selected bridge interface ({self.bridge}) belongs to {self.bridge.parent}, which "
+                                f"The selected bridge interface ({self.bridge}) belongs to {self.bridge.parent}, which "  # pylint: disable=no-member
                                 f"is not part of virtual chassis {self.parent.virtual_chassis}."
                             )
                         }
@@ -1084,8 +1086,8 @@ class DeviceBay(ComponentModel):
         super().clean()
 
         # Validate that the parent Device can have DeviceBays
-        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.")
+        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
 
         # Cannot install a device into itself, obviously
         if self.device == self.installed_device:

nautobot/dcim/models/devices.py

@@ -1466,7 +1466,7 @@ 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:
+        if self.parent and self.controller and self.controller != self.parent.controller:  # pylint: disable=no-member
             raise ValidationError(
                 {"controller": "Controller device group must have the same controller as the parent group."}
             )

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:
+                    if self.parent.location_type != self.location_type:  # pylint: disable=no-member
                         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):
+                if self.parent.location_type not in (self.location_type, self.location_type.parent):  # pylint: disable=no-member
                     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:
+                if self.parent.location_type != self.location_type.parent:  # pylint: disable=no-member
                     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
-                and self.rack_group.location not in self.location.ancestors(include_self=True)
+                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
             ):
                 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,9 +151,10 @@ 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:
+        if self.rack and self.rack.location != self.power_panel.location:  # pylint: disable=no-member
             raise ValidationError(
-                f"Rack {self.rack} ({self.rack.location}) and power panel {self.power_panel} ({self.power_panel.location}) are in different locations"
+                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"
             )
 
         # 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
-            and self.parent.location not in self.location.ancestors(include_self=True)
+            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
         ):
             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)
+                permitted_device_ids = self.devices.restrict(user, "view").values_list("pk", flat=True)  # pylint: disable=no-member
 
             for device in queryset:
                 if expand_devices:

nautobot/dcim/tables/__init__.py

@@ -143,7 +143,7 @@ class ConsoleConnectionTable(BaseTable):
         linkify=True,
         verbose_name="Port",
     )
-    device = tables.Column(linkify=True, accessor="parent")
+    device = tables.Column(linkify=True, accessor="parent", orderable=False)
     name = tables.Column(linkify=True, verbose_name="Console Port")
     reachable = BooleanColumn(accessor=Accessor("_path__is_active"), verbose_name="Reachable")
 
@@ -171,7 +171,7 @@ class PowerConnectionTable(BaseTable):
         linkify=True,
         verbose_name="Outlet",
     )
-    device = tables.Column(linkify=True, accessor="parent")
+    device = tables.Column(linkify=True, accessor="parent", orderable=False)
     name = tables.Column(linkify=True, verbose_name="Power Port")
     reachable = BooleanColumn(accessor=Accessor("_path__is_active"), verbose_name="Reachable")
 
@@ -181,7 +181,7 @@ class PowerConnectionTable(BaseTable):
 
 
 class InterfaceConnectionTable(BaseTable):
-    device_a = tables.Column(accessor=Accessor("parent"), linkify=True, verbose_name="Device A")
+    device_a = tables.Column(accessor=Accessor("parent"), linkify=True, verbose_name="Device A", orderable=False)
     interface_a = tables.Column(accessor=Accessor("name"), linkify=True, verbose_name="Interface A")
     device_b = tables.Column(
         accessor=Accessor("_path__destination__parent"),

nautobot/dcim/tables/devicetypes.py

@@ -253,7 +253,7 @@ class PowerOutletTemplateTable(ComponentTemplateTable):
             "name",
             "label",
             "type",
-            "power_port",
+            "power_port_template",
             "feed_leg",
             "description",
             "actions",
@@ -290,7 +290,7 @@ class FrontPortTemplateTable(ComponentTemplateTable):
             "name",
             "label",
             "type",
-            "rear_port",
+            "rear_port_template",
             "rear_port_position",
             "description",
             "actions",

nautobot/dcim/tests/test_filters.py

@@ -1,3 +1,4 @@
+# pylint: disable=no-member  # it doesn't recognize the class attributes assigned in common_test_data()
 import uuid
 
 from django.contrib.auth import get_user_model

nautobot/dcim/tests/test_graphql.py

@@ -83,3 +83,55 @@ class GraphQLTestCase(TestCase):
             self.assertEqual(
                 resp["data"]["devices"][0]["platform"]["network_driver_mappings"]["scrapli"], "cisco_iosxe"
             )
+
+        with self.subTest("device serial number query"):
+            non_empty_serial_device = Device.objects.first()
+            non_empty_serial_device.serial = "1234567890abceFGHIJKL"
+            non_empty_serial_device.save()
+
+            # Test device serial query default behavior: serial__ie
+            query = 'query { devices (serial: " ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertEqual(device["serial"], "")
+
+            # Test device serial default filter with non-empty serial number
+            query = 'query { devices (serial:"' + non_empty_serial_device.serial.lower() + '") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            self.assertEqual(resp["data"]["devices"][0]["serial"], non_empty_serial_device.serial)
+
+            # Test device serial iexact filter with non-empty serial number
+            query = 'query { devices (serial__ie:"' + non_empty_serial_device.serial.upper() + '") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            self.assertEqual(resp["data"]["devices"][0]["serial"], non_empty_serial_device.serial)
+
+            # Test device serial__nie filter with non-empty serial number
+            query = 'query { devices (serial__nie:"' + non_empty_serial_device.serial.lower() + '") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertNotEqual(device["serial"], non_empty_serial_device.serial)
+
+            # Test device serial__ie filter with empty serial number
+            query = 'query { devices (serial__ie:" ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertEqual(device["serial"], "")
+
+            # Test device serial__nie filter with empty serial number
+            query = 'query { devices (serial__nie:" ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertNotEqual(device["serial"], "")
+
+            # Test device serial__n filter with empty serial number
+            query = 'query { devices (serial__n:" ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertNotEqual(device["serial"], "")

nautobot/dcim/tests/test_models.py

@@ -1,9 +1,12 @@
+from __future__ import annotations  # python 3.8
+
 from decimal import Decimal
 
 from constance.test import override_config
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.db import IntegrityError
+from django.db.models import Model
 from django.test import TestCase
 from django.test.utils import override_settings
 
@@ -76,7 +79,7 @@ class ModularDeviceComponentTestCaseMixin:
 
     # fields required to create instances of the model, with the exception of name, device_field and module_field
     modular_component_create_data = {}
-    model = None
+    model: type[Model]
     device_field = "device"  # field name for the parent device
     module_field = "module"  # field name for the parent module
 

nautobot/dcim/views.py

@@ -699,7 +699,7 @@ class RackReservationEditView(generic.ObjectEditView):
     model_form = forms.RackReservationForm
     template_name = "dcim/rackreservation_edit.html"
 
-    def alter_obj(self, obj, request, args, kwargs):
+    def alter_obj(self, obj, request, url_args, url_kwargs):
         if not obj.present_in_database:
             if "rack" in request.GET:
                 obj.rack = get_object_or_404(Rack, pk=request.GET.get("rack"))

nautobot/extras/api/customfields.py

@@ -42,8 +42,8 @@ class CustomFieldsDataField(Field):
     def custom_field_keys(self):
         return CustomField.objects.keys_for_model(self.parent.Meta.model)
 
-    def to_representation(self, obj):
-        return {key: obj.get(key) for key in self.custom_field_keys}
+    def to_representation(self, value):
+        return {key: value.get(key) for key in self.custom_field_keys}
 
     def to_internal_value(self, data):
         """Support updates to individual fields on an existing instance without needing to provide the entire dict."""