nautobot 2.3.12__py3-none-any.whl → 2.3.14__py3-none-any.whl

nautobot/circuits/tables.py

@@ -110,6 +110,7 @@ class CircuitTable(StatusTableMixin, BaseTable):
     pk = ToggleColumn()
     cid = tables.LinkColumn(verbose_name="ID")
     provider = tables.Column(linkify=True)
+    circuit_type = tables.Column(linkify=True)
     tenant = TenantColumn()
     tags = TagColumn(url_name="circuits:circuit_list")
 
@@ -146,7 +147,7 @@ class CircuitTable(StatusTableMixin, BaseTable):
             "pk",
             "cid",
             "provider",
-            "type",
+            "circuit_type",
             "status",
             "tenant",
             "circuit_termination_a",

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/filters.py

@@ -618,6 +618,7 @@ class BaseFilterSet(django_filters.FilterSet):
     @staticmethod
     def _get_filter_lookup_dict(existing_filter):
         # Choose the lookup expression map based on the filter type
+
         if isinstance(
             existing_filter,
             (
@@ -637,6 +638,7 @@ class BaseFilterSet(django_filters.FilterSet):
             (
                 django_filters.ModelChoiceFilter,
                 django_filters.ModelMultipleChoiceFilter,
+                MultiValueUUIDFilter,
                 TagFilter,
                 TreeNodeMultipleChoiceFilter,
             ),

nautobot/core/jobs/cleanup.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
 
 from django.core.exceptions import PermissionDenied
+from django.db.models import CASCADE
 from django.db.models.signals import pre_delete
 from django.utils import timezone
 
@@ -48,6 +49,27 @@ class LogsCleanup(Job):
         description = "Delete ObjectChange and/or JobResult/JobLogEntry records older than a specified cutoff."
         has_sensitive_variables = False
 
+    def recursive_delete_with_cascade(self, queryset, deletion_summary):
+        """
+        Recursively deletes all related objects with CASCADE for a given queryset.
+
+        Args:
+            queryset (QuerySet): The queryset of objects to delete.
+            deletion_summary (dict): A dictionary to store the count of deleted objects for each model.
+        """
+        related_objects = queryset.model._meta.related_objects
+        queryset = queryset.only("id")
+
+        for related_object in related_objects:
+            if related_object.on_delete is CASCADE:
+                related_model = related_object.related_model
+                related_field_name = related_object.field.name
+                cascade_queryset = related_model.objects.filter(**{f"{related_field_name}__id__in": queryset})
+                self.recursive_delete_with_cascade(cascade_queryset, deletion_summary)
+        _, deleted_dict = queryset.delete()
+        deletion_summary.update(deleted_dict)
+        return deletion_summary
+
     def run(self, *, cleanup_types, max_age=None):
         if max_age in (None, ""):
             max_age = get_settings_or_config("CHANGELOG_RETENTION")
@@ -77,22 +99,36 @@ class LogsCleanup(Job):
 
             if CleanupTypes.JOB_RESULT in cleanup_types:
                 self.logger.info("Deleting JobResult records prior to %s", cutoff)
-                _, deleted_dict = JobResult.objects.restrict(self.user, "delete").filter(date_done__lt=cutoff).delete()
+                queryset = JobResult.objects.restrict(self.user, "delete").filter(date_done__lt=cutoff)
+                deletion_summary = {}
+                self.recursive_delete_with_cascade(queryset, deletion_summary)
                 result.setdefault("extras.JobResult", 0)
                 result.setdefault("extras.JobLogEntry", 0)
-                result.update(**deleted_dict)
-                self.logger.info(
-                    "Deleted %d JobResult records and their associated %d JobLogEntry records",
-                    result["extras.JobResult"],
-                    result["extras.JobLogEntry"],
-                )
+                result.update(deletion_summary)
+
+                for modelname, count in deletion_summary.items():
+                    self.logger.info(
+                        "As part of deleting %d JobResult records, also deleted %d related %s records",
+                        result["extras.JobResult"],
+                        count,
+                        modelname,
+                    )
 
             if CleanupTypes.OBJECT_CHANGE in cleanup_types:
                 self.logger.info("Deleting ObjectChange records prior to %s", cutoff)
-                deleted_count, _ = ObjectChange.objects.restrict(self.user, "delete").filter(time__lt=cutoff).delete()
-                self.logger.info("Deleted %d ObjectChange records", deleted_count)
-                result["extras.ObjectChange"] = deleted_count
-
+                queryset = ObjectChange.objects.restrict(self.user, "delete").filter(time__lt=cutoff)
+                deletion_summary = {}
+                self.recursive_delete_with_cascade(queryset, deletion_summary)
+                result.setdefault("extras.ObjectChange", 0)
+                result.update(deletion_summary)
+
+                for modelname, count in deletion_summary.items():
+                    self.logger.info(
+                        "As part of deleting %d ObjectChange records, also deleted %d related %s records",
+                        result["extras.ObjectChange"],
+                        count,
+                        modelname,
+                    )
             return result
         finally:
             # Be sure to clean up after ourselves!

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

@@ -225,7 +225,7 @@ if SSO_ENABLE_GROUP_SYNC:
         "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",
+        "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")

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/search.html

@@ -65,3 +65,10 @@
         </div>
     {% endif %}
 {% endblock %}
+
+{% block javascript %}
+    {{ block.super }}
+    <script>
+        var clipboard = new ClipboardJS('.btn');
+    </script>
+{% endblock %}

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/filters.py

@@ -88,11 +88,26 @@ class FilterTestCases:
             return self.filterset.declared_filters["q"].filter_predicates
 
         def test_id(self):
-            """Verify that the filterset supports filtering by id."""
-            params = {"id": self.queryset.values_list("pk", flat=True)[:2]}
-            filterset = self.filterset(params, self.queryset)
-            self.assertTrue(filterset.is_valid())
-            self.assertEqual(filterset.qs.count(), 2)
+            """Verify that the filterset supports filtering by id with only lookup `__n`."""
+            with self.subTest("Assert `id`"):
+                params = {"id": list(self.queryset.values_list("pk", flat=True)[:2])}
+                expected_queryset = self.queryset.filter(id__in=params["id"])
+                filterset = self.filterset(params, self.queryset)
+                self.assertTrue(filterset.is_valid())
+                self.assertQuerysetEqualAndNotEmpty(filterset.qs.order_by("id"), expected_queryset.order_by("id"))
+
+            with self.subTest("Assert negate lookup"):
+                params = {"id__n": list(self.queryset.values_list("pk", flat=True)[:2])}
+                expected_queryset = self.queryset.exclude(id__in=params["id__n"])
+                filterset = self.filterset(params, self.queryset)
+                self.assertTrue(filterset.is_valid())
+                self.assertQuerysetEqualAndNotEmpty(filterset.qs.order_by("id"), expected_queryset.order_by("id"))
+
+            with self.subTest("Assert invalid lookup"):
+                params = {"id__in": list(self.queryset.values_list("pk", flat=True)[:2])}
+                filterset = self.filterset(params, self.queryset)
+                self.assertFalse(filterset.is_valid())
+                self.assertIn("Unknown filter field", filterset.errors.as_text())
 
         def test_invalid_filter(self):
             """Verify that the filterset reports as invalid when initialized with an unsupported filter parameter."""

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/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):