nautobot 2.3.11__py3-none-any.whl → 2.3.13__py3-none-any.whl

nautobot/core/api/serializers.py

@@ -134,6 +134,7 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
 
     serializer_related_field = NautobotHyperlinkedRelatedField
 
+    id = serializers.UUIDField(read_only=False, default=serializers.CreateOnlyDefault(uuid.uuid4))
     display = serializers.SerializerMethodField(read_only=True, help_text="Human friendly display value")
     object_type = ObjectTypeField()
     # composite_key = serializers.SerializerMethodField()  # TODO: Revisit if we reintroduce composite keys

nautobot/core/celery/log.py

@@ -11,6 +11,10 @@ class NautobotDatabaseHandler(logging.Handler):
         if current_task is None:
             return
 
+        # Skip recording the log entry if it has been marked as such
+        if getattr(record, "skip_db_logging", False):
+            return
+
         from nautobot.extras.models.jobs import JobResult
 
         try:
@@ -24,10 +28,6 @@ class NautobotDatabaseHandler(logging.Handler):
                 # JobResult.DoesNotExist - because we might not have a JobResult with that ID
                 return
 
-            # Skip recording the log entry if it has been marked as such
-            if getattr(record, "skip_db_logging", False):
-                return
-
             job_result.log(
                 message=record.message,
                 level_choice=record.levelname.lower(),

nautobot/core/models/tree_queries.py

@@ -111,8 +111,11 @@ class TreeModel(TreeNode):
         if display_str:
             return display_str
         try:
-            if self.parent is not None:
-                display_str = self.parent.display + " → "
+            if self.parent_id is not None:
+                parent_display_str = cache.get(cache_key.replace(str(self.id), str(self.parent_id)), "")
+                if not parent_display_str:
+                    parent_display_str = self.parent.display
+                display_str = parent_display_str + " → "
         except self.DoesNotExist:
             # Expected to occur at times during bulk-delete operations
             pass

nautobot/core/settings.py

@@ -212,6 +212,32 @@ SOCIAL_AUTH_POSTGRES_JSONFIELD = False
 # Nautobot related - May be overridden if using custom social auth backend
 SOCIAL_AUTH_BACKEND_PREFIX = "social_core.backends"
 
+# Enables adding the OAuth2/OIDC group sync module to the authentication pipeline
+SSO_ENABLE_GROUP_SYNC = is_truthy(os.getenv("NAUTOBOT_SSO_ENABLE_GROUP_SYNC", "false"))
+if SSO_ENABLE_GROUP_SYNC:
+    SOCIAL_AUTH_PIPELINE = (
+        "social_core.pipeline.social_auth.social_details",
+        "social_core.pipeline.social_auth.social_uid",
+        "social_core.pipeline.social_auth.auth_allowed",
+        "social_core.pipeline.social_auth.social_user",
+        "social_core.pipeline.user.get_username",
+        "social_core.pipeline.user.create_user",
+        "social_core.pipeline.social_auth.associate_user",
+        "social_core.pipeline.social_auth.load_extra_data",
+        "social_core.pipeline.user.user_details",
+        "nautobot.extras.group_sync.group_sync",
+    )
+# OAuth2/OIDC claim where the list of groups the authenticating user is a part of
+SSO_CLAIMS_GROUP = os.getenv("NAUTOBOT_SSO_CLAIMS_GROUP", "groups")
+# list of groups that an authenticating user can be a part of to get the Django staff permission
+SSO_STAFF_GROUPS = [
+    group for group in os.getenv("NAUTOBOT_SSO_STAFF_GROUPS", "").split(_CONFIG_SETTING_SEPARATOR) if group != ""
+]
+# list of groups that an authenticating user can be a part of to be a Django super user
+SSO_SUPERUSER_GROUPS = [
+    group for group in os.getenv("NAUTOBOT_SSO_SUPERUSER_GROUPS", "").split(_CONFIG_SETTING_SEPARATOR) if group != ""
+]
+
 # Job log entry sanitization and similar
 SANITIZER_PATTERNS = [
     # General removal of username-like and password-like tokens

nautobot/core/settings.yaml

@@ -1705,6 +1705,37 @@ properties:
       "Single Sign On": "./authentication/sso.md"
       "`social-auth-app-django`": "https://python-social-auth.readthedocs.io/en/latest/configuration/django.html"
     type: "string"
+  SSO_CLAIMS_GROUP:
+    default: "groups"
+    description: "OAuth2/OIDC claim which will contain the groups which the authenticated user is a member of."
+    environment_variable: "NAUTOBOT_SSO_CLAIMS_GROUP"
+    see_also:
+      "Single Sign On": "./authentication/sso.md"
+  SSO_ENABLE_GROUP_SYNC:
+    default: false
+    type: "boolean"
+    description: "Enables the group syncing authentication module."
+    environment_variable: "NAUTOBOT_SSO_ENABLE_GROUP_SYNC"
+    see_also:
+      "Single Sign On": "./authentication/sso.md"
+  SSO_STAFF_GROUPS:
+    default: []
+    description: "List of groups that a user can be a member of to get the Django Staff permission."
+    environment_variable: "NAUTOBOT_SSO_STAFF_GROUPS"
+    see_also:
+      "Single Sign On": "./authentication/sso.md"
+    items:
+      type: "string"
+    type: "array"
+  SSO_SUPERUSER_GROUPS:
+    default: []
+    description: "List of groups that a user can be a member of to be a Django Super User."
+    environment_variable: "NAUTOBOT_SSO_SUPERUSER_GROUPS"
+    see_also:
+      "Single Sign On": "./authentication/sso.md"
+    items:
+      type: "string"
+    type: "array"
   STATIC_ROOT:
     "$ref": "#/definitions/absolute_path"
     default: "~/.nautobot/static"

nautobot/core/tables.py

@@ -14,7 +14,8 @@ from django.utils.http import urlencode
 from django.utils.safestring import mark_safe
 from django.utils.text import Truncator
 import django_tables2
-from django_tables2.data import TableQuerysetData
+from django_tables2.data import TableData, TableQuerysetData
+from django_tables2.rows import BoundRows
 from django_tables2.utils import Accessor, OrderBy, OrderByTuple
 from tree_queries.models import TreeNode
 
@@ -46,8 +47,24 @@ class BaseTable(django_tables2.Table):
         user=None,
         hide_hierarchy_ui=False,
         order_by=None,
+        data_transform_callback=None,
         **kwargs,
     ):
+        """
+        Instantiate a BaseTable.
+
+        Args:
+            *args (list, optional): Passed through to django_tables2.Table
+            table_changes_pending (bool): TODO
+            saved_view (SavedView, optional): TODO
+            user (User, optional): TODO
+            hide_hierarchy_ui (bool): Whether to display or hide hierarchy indentation of nested objects.
+            order_by (list, optional): Field(s) to sort by
+            data_transform_callback (function, optional): A function that takes the given `data` as an input and
+                returns new data. Runs after all of the queryset auto-optimization performed by this class.
+                Used for example in IPAM views to inject "fake" records for "available" Prefixes, IPAddresses, or VLANs.
+            **kwargs (dict, optional): Passed through to django_tables2.Table
+        """
         # Add custom field columns
         model = self._meta.model
 
@@ -89,6 +106,14 @@ class BaseTable(django_tables2.Table):
         # Init table
         super().__init__(*args, order_by=order_by, **kwargs)
 
+        if not isinstance(self.data, TableQuerysetData):
+            # LinkedCountColumns don't work properly if the data is a list of dicts instead of a queryset,
+            # as they rely on a `queryset.annotate()` call to gather the data.
+            self.exclude = [
+                *self.exclude,
+                *[column.name for column in self.columns if isinstance(column.column, LinkedCountColumn)],
+            ]
+
         # Don't show hierarchy if we're sorted
         if order_by is not None and hide_hierarchy_ui is None:
             hide_hierarchy_ui = True
@@ -122,7 +147,7 @@ class BaseTable(django_tables2.Table):
                 columns = user.get_config(f"tables.{self.__class__.__name__}.columns")
         if columns:
             for name, column in self.base_columns.items():
-                if name in columns:
+                if name in columns and name not in self.exclude:
                     self.columns.show(name)
                 else:
                     self.columns.hide(name)
@@ -161,7 +186,8 @@ class BaseTable(django_tables2.Table):
                         logger.error("Couldn't find model for %s", column.column.viewname)
                         continue
                     reverse_lookup = column.column.reverse_lookup or next(iter(column.column.url_params.keys()))
-                    count_fields.append((column.name, column_model, reverse_lookup))
+                    distinct = column.column.distinct
+                    count_fields.append((column.name, column_model, reverse_lookup, distinct))
                     try:
                         lookup = column.column.lookup or get_related_field_for_models(model, column_model).name
                         # For some reason get_related_field_for_models(Tag, DynamicGroup) gives a M2M with the name
@@ -173,7 +199,8 @@ class BaseTable(django_tables2.Table):
                     if lookup is not None:
                         # Also attempt to prefetch the first matching record for display - see LinkedCountColumn
                         prefetch_fields.append(
-                            Prefetch(lookup, column_model.objects.all()[:1], to_attr=f"{lookup}_list")
+                            # Use order_by() because we don't care about ordering here and it's potentially expensive
+                            Prefetch(lookup, column_model.objects.order_by()[:1], to_attr=f"{lookup}_list")
                         )
                     continue
 
@@ -256,24 +283,34 @@ class BaseTable(django_tables2.Table):
                         )
 
             if count_fields:
-                for column_name, column_model, lookup_name in count_fields:
+                for column_name, column_model, lookup_name, distinct in count_fields:
                     if hasattr(queryset.first(), column_name):
                         continue
                     try:
                         logger.debug(
-                            "Applying .annotate(%s=count_related(%s, %r) to %s QuerySet",
+                            "Applying .annotate(%s=count_related(%s, %r, distinct=%s) to %s QuerySet",
                             column_name,
                             column_model.__name__,
                             lookup_name,
+                            distinct,
                             model.__name__,
                         )
-                        queryset = queryset.annotate(**{column_name: count_related(column_model, lookup_name)})
+                        queryset = queryset.annotate(
+                            **{column_name: count_related(column_model, lookup_name, distinct=distinct)}
+                        )
                     except FieldError:
                         # No error message logged here as the above is *very much* best-effort
                         pass
 
             self.data.data = queryset
 
+        # TODO: it would be better if we could apply this transformation and the above queryset optimizations
+        #       **before** calling super().__init__(), but the current implementation works for now, though inelegant.
+        if data_transform_callback is not None:
+            self.data = TableData.from_data(data_transform_callback(self.data.data))
+            self.data.set_table(self)
+            self.rows = BoundRows(data=self.data, table=self, pinned_data=self.pinned_data)
+
     @property
     def configurable_columns(self):
         selected_columns = [
@@ -288,7 +325,7 @@ class BaseTable(django_tables2.Table):
 
     @property
     def visible_columns(self):
-        return [name for name in self.sequence if self.columns[name].visible]
+        return [name for name in self.sequence if self.columns[name].visible and name not in self.exclude]
 
     @property
     def order_by(self):
@@ -490,6 +527,7 @@ class LinkedCountColumn(django_tables2.Column):
             TODO: this currently does *not* support nested lookups via `__`. That may be solvable in the future.
         reverse_lookup (str, optional): The reverse lookup parameter to use to derive the count.
             If not specified, the first key in `url_params` will be implicitly used as the `reverse_lookup` value.
+        distinct (bool, optional): Parameter passed through to `count_related()`.
         **kwargs (dict, optional): As the parent Column class.
 
     Examples:
@@ -514,21 +552,33 @@ class LinkedCountColumn(django_tables2.Column):
                 # We'd like to do the below but this module isn't currently smart enough to build the right Prefetch()
                 # for a nested lookup:
                 # lookup="circuit_terminations__circuit",
-                # For the count, .annotate(circuit_count=count_related(Circuit, "circuit_terminations__cloud_network"))
+                # For the count,
+                # .annotate(circuit_count=count_related(Circuit, "circuit_terminations__cloud_network", distinct=True))
                 reverse_lookup="circuit_terminations__cloud_network",
+                distinct=True,
                 verbose_name="Circuits",
             )
         ```
     """
 
     def __init__(
-        self, viewname, *args, view_kwargs=None, url_params=None, lookup=None, reverse_lookup=None, default=0, **kwargs
+        self,
+        viewname,
+        *args,
+        view_kwargs=None,
+        url_params=None,
+        lookup=None,
+        reverse_lookup=None,
+        distinct=False,
+        default=None,
+        **kwargs,
     ):
         self.viewname = viewname
         self.lookup = lookup
         self.view_kwargs = view_kwargs or {}
         self.url_params = url_params
         self.reverse_lookup = reverse_lookup or next(iter(url_params.keys()))
+        self.distinct = distinct
         self.model = get_model_for_view_name(self.viewname)
         super().__init__(*args, default=default, **kwargs)
 

nautobot/core/templates/generic/object_notes.html

@@ -21,7 +21,7 @@
                     </div>
                 </div>
                 <div class="col-md-6 col-md-offset-3 text-right" style="margin-bottom: 20px;">
-                    <button type="submit" class="btn btn-primary">Create</button>
+                    <button id="createNote" type="submit" class="btn btn-primary">Create</button>
                     <a href="{{ object.get_absolute_url }}" class="btn btn-default">Cancel</a>
                 </div>
             </div>

nautobot/core/templates/generic/object_retrieve.html

@@ -54,7 +54,7 @@
         <h1>
             <span class="hover_copy">
                 <span id="copy_title">{% block title %}{{object.display|default:object}}{% endblock %}</span>
-                <button type="button" class="btn btn-inline btn-default hover_copy_button" data-clipboard-target="#copy_title">
+                <button type="button" class="btn btn-inline btn-default hover_copy_button" data-clipboard-text="{{ object.display | default:object }}">
                     <span class="mdi mdi-content-copy"></span>
                 </button>
             </span>

nautobot/core/templatetags/helpers.py

@@ -795,7 +795,13 @@ def saved_view_modal(
         "clear_view",
     ]
 
-    table_name = lookup.get_table_for_model(model).__name__
+    view_class = lookup.get_view_for_model(model, "List")
+    table_name = None
+    if hasattr(view_class, "table"):
+        table_name = view_class.table.__name__
+    if hasattr(view_class, "table_class"):
+        table_name = view_class.table_class.__name__
+
     for param in non_filter_params:
         if param == "saved_view":
             current_saved_view_pk = filters_applied.pop(param, None)

nautobot/core/testing/api.py

@@ -707,7 +707,11 @@ class APIViewTestCases:
             self.assertHttpStatus(response, status.HTTP_201_CREATED, csv_data)
             # Note that create via CSV is always treated as a bulk-create, and so the response is always a list of dicts
             new_instance = self._get_queryset().get(pk=response.data[0]["id"])
-            self.assertNotEqual(new_instance.pk, orig_pk)
+            if isinstance(orig_pk, int):
+                self.assertNotEqual(new_instance.pk, orig_pk)
+            else:
+                # for our non-integer PKs, we're expecting the creation to respect the requested PK
+                self.assertEqual(new_instance.pk, orig_pk)
 
             new_serializer = serializer_class(new_instance, context={"request": None})
             new_data = new_serializer.data

nautobot/core/testing/views.py

@@ -1,3 +1,4 @@
+import contextlib
 import re
 from typing import Optional, Sequence
 from unittest import skipIf
@@ -792,11 +793,16 @@ class ViewTestCases:
             response = self.client.get(f"{self._get_url('list')}?id={instance1.pk}")
             self.assertHttpStatus(response, 200)
             content = utils.extract_page_body(response.content.decode(response.charset))
+            # There should be only one row in the table
+            self.assertIn('<tr class="even', content)
+            self.assertNotIn('<tr class="odd', content)
             if hasattr(self.model, "name"):
                 self.assertRegex(content, r">\s*" + re.escape(escape(instance1.name)) + r"\s*<", msg=content)
                 self.assertNotRegex(content, r">\s*" + re.escape(escape(instance2.name)) + r"\s*<", msg=content)
-            if instance1.get_absolute_url() in content:
-                self.assertNotIn(instance2.get_absolute_url(), content, msg=content)
+            with contextlib.suppress(AttributeError):
+                # Some models, such as ObjectMetadata, don't have a detail URL
+                if instance1.get_absolute_url() in content:
+                    self.assertNotIn(instance2.get_absolute_url(), content, msg=content)
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"], STRICT_FILTERING=True)
         def test_list_objects_unknown_filter_strict_filtering(self):
@@ -833,11 +839,16 @@ class ViewTestCases:
             content = utils.extract_page_body(response.content.decode(response.charset))
             self.assertNotIn("Unknown filter field", content, msg=content)
             self.assertIn("None", content, msg=content)
+            # There should be at least two rows in the table
+            self.assertIn('<tr class="even', content)
+            self.assertIn('<tr class="odd', content)
             if hasattr(self.model, "name"):
                 self.assertRegex(content, r">\s*" + re.escape(escape(instance1.name)) + r"\s*<", msg=content)
                 self.assertRegex(content, r">\s*" + re.escape(escape(instance2.name)) + r"\s*<", msg=content)
-            if instance1.get_absolute_url() in content:
-                self.assertIn(instance2.get_absolute_url(), content, msg=content)
+            with contextlib.suppress(AttributeError):
+                # Some models, such as ObjectMetadata, don't have a detail URL
+                if instance1.get_absolute_url() in content:
+                    self.assertIn(instance2.get_absolute_url(), content, msg=content)
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_list_objects_without_permission(self):

nautobot/core/tests/test_api.py

@@ -3,6 +3,7 @@ from io import BytesIO, StringIO
 import json
 import os
 from unittest import skip
+import uuid
 
 from constance import config
 from constance.test import override_config
@@ -754,6 +755,25 @@ class WritableNestedSerializerTest(testing.APITestCase):
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertEqual(ipam_models.VLAN.objects.filter(name="Test VLAN 100").count(), 0)
 
+    def test_create_with_specified_id(self):
+        data = {
+            "id": str(uuid.uuid4()),
+            "vid": 400,
+            "name": "Test VLAN 400",
+            "status": self.statuses.first().pk,
+            "vlan_group": self.vlan_group1.pk,
+        }
+        url = reverse("ipam-api:vlan-list")
+        self.add_permissions("ipam.add_vlan")
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(str(response.data["vlan_group"]["url"]), self.absolute_api_url(self.vlan_group1))
+        self.assertEqual(str(response.data["id"]), data["id"])
+        vlan = ipam_models.VLAN.objects.get(pk=response.data["id"])
+        self.assertEqual(vlan.status, self.statuses.first())
+        self.assertEqual(vlan.vlan_group, self.vlan_group1)
+
 
 class APIOrderingTestCase(testing.APITestCase):
     """

nautobot/core/tests/test_csv.py

@@ -1,3 +1,6 @@
+import csv
+import io
+
 from django.contrib.contenttypes.models import ContentType
 from django.test import override_settings, RequestFactory, TestCase
 from django.urls import reverse
@@ -261,9 +264,28 @@ class CSVParsingRelatedTestCase(TestCase):
         self.assertEqual(response.status_code, 200)
         response_data = response.content.decode(response.charset)
 
-        # Replace Device Name
-        import_data = response_data.replace("TestDevice1", "TestDevice3").replace("TestDevice2", "")
-        data = {"csv_data": import_data}
+        # parse the csv data
+        csv_reader = csv.DictReader(response_data.splitlines())
+        # remove the 'id' column so that all the items are imported new
+        fieldnames = [field for field in csv_reader.fieldnames if field != "id"]
+        # read all entries into a list
+        response_csv = list(csv_reader)
+
+        # mutate our data for testing purposes
+        for row in response_csv:
+            if row["name"] == "TestDevice1":
+                row["name"] = "TestDevice3"
+            elif row["name"] == "TestDevice2":
+                row["name"] = ""
+
+        # prep our data to write out
+        with io.StringIO() as import_csv:
+            writer = csv.DictWriter(import_csv, fieldnames=fieldnames)
+            writer.writeheader()
+            for row in response_csv:
+                filtered_row = {key: row[key] for key in fieldnames}
+                writer.writerow(filtered_row)
+            data = {"csv_data": import_csv.getvalue()}
         url = reverse("dcim:device_import")
         response = self.client.post(url, data)
         self.assertEqual(response.status_code, 200)

nautobot/core/tests/test_utils.py

@@ -268,6 +268,14 @@ class GetFooForModelTest(TestCase):
                 lookup.get_model_for_view_name("unknown:plugins:example_app:examplemodel_list")
             self.assertEqual(str(err.exception), "Unexpected View Name: unknown:plugins:example_app:examplemodel_list")
 
+    def test_get_table_class_string_from_view_name(self):
+        # Testing UIViewSet
+        self.assertEqual(lookup.get_table_class_string_from_view_name("circuits:circuit_list"), "CircuitTable")
+        # Testing Legacy View
+        self.assertEqual(lookup.get_table_class_string_from_view_name("dcim:location_list"), "LocationTable")
+        # Testing unconventional table name
+        self.assertEqual(lookup.get_table_class_string_from_view_name("ipam:prefix_list"), "PrefixDetailTable")
+
 
 class IsTaggableTest(TestCase):
     def test_is_taggable_true(self):

nautobot/core/utils/lookup.py

@@ -8,7 +8,7 @@ from django.conf import settings
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Model
-from django.urls import get_resolver, URLPattern, URLResolver
+from django.urls import get_resolver, resolve, reverse, URLPattern, URLResolver
 from django.utils.module_loading import import_string
 
 
@@ -212,7 +212,7 @@ def get_related_field_for_models(from_model, to_model):
     return matching_field
 
 
-def get_table_for_model(model):
+def get_table_for_model(model, suffix=None):
     """Return the `Table` class associated with a given `model`.
 
     The `Table` class is expected to be in the `tables` module within the application
@@ -222,11 +222,12 @@ def get_table_for_model(model):
 
     Args:
         model (BaseModel): A model class
+        suffix (str): A replacement suffix for the table name (e.g. `DetailTable`, such as to retrieve `FooDetailTable`)
 
     Returns:
         (Union[Table, None]): Either the `Table` class or `None`
     """
-    return get_related_class_for_model(model, module_name="tables", object_suffix="Table")
+    return get_related_class_for_model(model, module_name="tables", object_suffix=suffix or "Table")
 
 
 def get_view_for_model(model, view_type=""):
@@ -275,11 +276,13 @@ def get_table_class_string_from_view_name(view_name):
     Returns:
         table_class_name (String): The name of the model table class or None e.g. LocationTable, CircuitTable
     """
-    model = get_model_for_view_name(view_name)
-    if model:
-        table_class = get_table_for_model(model)
-        if table_class:
-            return table_class.__name__
+
+    view_func = resolve(reverse(view_name)).func
+    view_class = getattr(view_func, "cls", getattr(view_func, "view_class", None))
+    if hasattr(view_class, "table_class"):
+        return view_class.table_class.__name__
+    if hasattr(view_class, "table"):
+        return view_class.table.__name__
     return None
 
 

nautobot/dcim/api/views.py

@@ -11,6 +11,7 @@ from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema, OpenApiParameter
 from rest_framework.decorators import action
 from rest_framework.mixins import ListModelMixin
+from rest_framework.parsers import JSONParser, MultiPartParser
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 from rest_framework.viewsets import GenericViewSet, ViewSet
@@ -18,6 +19,7 @@ from rest_framework.viewsets import GenericViewSet, ViewSet
 from nautobot.circuits.models import Circuit
 from nautobot.cloud.models import CloudAccount
 from nautobot.core.api.exceptions import ServiceUnavailable
+from nautobot.core.api.parsers import NautobotCSVParser
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.api.views import ModelViewSet
 from nautobot.core.models.querysets import count_related
@@ -300,6 +302,7 @@ class DeviceTypeViewSet(NautobotModelViewSet):
     )
     serializer_class = serializers.DeviceTypeSerializer
     filterset_class = filters.DeviceTypeFilterSet
+    parser_classes = [JSONParser, NautobotCSVParser, MultiPartParser]
 
 
 #

nautobot/dcim/choices.py

@@ -804,6 +804,9 @@ class InterfaceTypeChoices(ChoiceSet):
     TYPE_400GE_CFP8 = "400gbase-x-cfp8"
     TYPE_800GE_QSFP_DD = "800gbase-x-qsfpdd"
     TYPE_800GE_OSFP = "800gbase-x-osfp"
+    TYPE_800GE_OSFP_XD = "800gbase-x-osfp-xd"
+    TYPE_1600GE_OSFP = "1600gbase-x-osfp"
+    TYPE_1600GE_OSFP_XD = "1600gbase-x-osfp-xd"
 
     # Ethernet Backplane
     TYPE_1GE_KX = "1000base-kx"
@@ -977,6 +980,9 @@ class InterfaceTypeChoices(ChoiceSet):
                 (TYPE_400GE_CFP8, "CPF8 (400GE)"),
                 (TYPE_800GE_QSFP_DD, "QSFP-DD (800GE)"),
                 (TYPE_800GE_OSFP, "OSFP (800GE)"),
+                (TYPE_800GE_OSFP_XD, "OSFP-XD (800GE)"),
+                (TYPE_1600GE_OSFP, "OSFP (1600GE)"),
+                (TYPE_1600GE_OSFP_XD, "OSFP-XD (1600GE)"),
             ),
         ),
         (

nautobot/dcim/filters/__init__.py

@@ -903,6 +903,19 @@ class DeviceFilterSet(
         to_field_name="version",
         label="Software version (version or ID)",
     )
+    ip_addresses = MultiValueCharFilter(
+        method="filter_ip_addresses",
+        label="IP addresses (address or ID)",
+        distinct=True,
+    )
+    has_ip_addresses = RelatedMembershipBooleanFilter(field_name="interfaces__ip_addresses", label="Has IP addresses")
+
+    def filter_ip_addresses(self, queryset, name, value):
+        pk_values = set(item for item in value if is_uuid(item))
+        addresses = set(item for item in value if item not in pk_values)
+
+        ip_queryset = IPAddress.objects.filter_address_or_pk_in(addresses, pk_values)
+        return queryset.filter(interfaces__ip_addresses__in=ip_queryset).distinct()
 
     class Meta:
         model = Device
@@ -1130,6 +1143,19 @@ class InterfaceFilterSet(
         queryset=InterfaceRedundancyGroup.objects.all(),
         to_field_name="name",
     )
+    ip_addresses = MultiValueCharFilter(
+        method="filter_ip_addresses",
+        label="IP addresses (address or ID)",
+        distinct=True,
+    )
+    has_ip_addresses = RelatedMembershipBooleanFilter(field_name="ip_addresses", label="Has IP addresses")
+
+    def filter_ip_addresses(self, queryset, name, value):
+        pk_values = set(item for item in value if is_uuid(item))
+        addresses = set(item for item in value if item not in pk_values)
+
+        ip_queryset = IPAddress.objects.filter_address_or_pk_in(addresses, pk_values)
+        return queryset.filter(ip_addresses__in=ip_queryset).distinct()
 
     class Meta:
         model = Interface
@@ -1144,7 +1170,6 @@ class InterfaceFilterSet(
             "description",
             "label",
             "tags",
-            "interface_redundancy_groups",
         ]
 
     def generate_query_filter_device(self, value):

nautobot/dcim/forms.py

@@ -2123,6 +2123,8 @@ class DeviceBulkEditForm(
     rack_group = DynamicModelChoiceField(
         queryset=RackGroup.objects.all(), required=False, query_params={"location": "$location"}
     )
+    cluster = DynamicModelChoiceField(queryset=Cluster.objects.all(), required=False)
+    comments = CommentField(widget=SmallTextarea, label="Comments")
     tenant = DynamicModelChoiceField(queryset=Tenant.objects.all(), required=False)
     platform = DynamicModelChoiceField(queryset=Platform.objects.all(), required=False)
     serial = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False, label="Serial Number")
@@ -2146,6 +2148,8 @@ class DeviceBulkEditForm(
             "position",
             "face",
             "rack_group",
+            "cluster",
+            "comments",
             "secrets_group",
             "device_redundancy_group",
             "device_redundancy_group_priority",