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

nautobot/dcim/templates/dcim/rackreservation.html

@@ -43,7 +43,15 @@
                     <td>Units</td>
                     <td>{{ object.unit_list }}</td>
                 </tr>
-                {% include 'inc/tenant_table_row.html' %}
+                <tr>
+                    <td>Tenant</td>
+                    <td>
+                        {% if object.tenant and object.tenant.tenant_group %}
+                            {{ object.tenant.tenant_group|hyperlinked_object }} /
+                        {% endif %}
+                        {{ object.tenant|hyperlinked_object }}
+                    </td>
+                </tr>
                 <tr>
                     <td>User</td>
                     <td>{{ object.user }}</td>

nautobot/dcim/templates/dcim/virtualdevicecontext_retrieve.html

@@ -54,7 +54,15 @@
                     {{ object.primary_ip6|hyperlinked_object }}
                 </td>
             </tr>
-            {% include 'inc/tenant_table_row.html' %}
+            <tr>
+                <td>Tenant</td>
+                <td>
+                    {% if object.tenant and object.tenant.tenant_group %}
+                        {{ object.tenant.tenant_group|hyperlinked_object }} /
+                    {% endif %}
+                    {{ object.tenant|hyperlinked_object }}
+                </td>
+            </tr>
             <tr>
                 <td>Description</td>
                 <td>{{ object.description|placeholder }}</td>

nautobot/dcim/templates/dcim/virtualdevicecontext_update.html

@@ -23,6 +23,12 @@
             {% endif %}
         </div>
     </div>
-    {% include 'inc/tenancy_form_panel.html' %}
+    <div class="panel panel-default">
+        <div class="panel-heading"><strong>Tenancy</strong></div>
+        <div class="panel-body">
+            {% render_field form.tenant_group %}
+            {% render_field form.tenant %}
+        </div>
+    </div>
     {% include 'inc/extras_features_edit_form_fields.html' %}
 {% endblock %}

nautobot/dcim/tests/test_api.py

@@ -1469,24 +1469,11 @@ class DeviceTest(APIViewTestCases.APIViewTestCase):
             SecretsGroup.objects.create(name="Secrets Group 2"),
         )
 
-        device_type = DeviceType.objects.first()
+        device_type = DeviceType.objects.filter(software_image_files__isnull=False).first()
         device_role = Role.objects.get_for_model(Device).first()
 
-        software_version = SoftwareVersion.objects.first()
-        software_image_files = (
-            SoftwareImageFile.objects.create(
-                status=Status.objects.get_for_model(SoftwareImageFile).first(),
-                software_version=software_version,
-                image_file_name="test_software_image_file_1.bin",
-            ),
-            SoftwareImageFile.objects.create(
-                status=Status.objects.get_for_model(SoftwareImageFile).last(),
-                software_version=software_version,
-                image_file_name="test_software_image_file_2.bin",
-            ),
-        )
-        for software_image_file in software_image_files:
-            software_image_file.device_types.add(device_type)
+        software_version = SoftwareVersion.objects.filter(software_image_files__device_types=device_type).first()
+        software_image_files = SoftwareImageFile.objects.exclude(software_version=software_version)[:2]
 
         Device.objects.create(
             device_type=device_type,

nautobot/dcim/tests/test_filters.py

@@ -1,4 +1,3 @@
-# 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
@@ -1692,7 +1691,6 @@ class DeviceTestCase(
         ("front_ports", "front_ports__id"),
         ("interfaces", "interfaces__id"),
         ("interfaces", "interfaces__name"),
-        ("ip_addresses", "interfaces__ip_addresses__id"),
         ("mac_address", "interfaces__mac_address"),
         ("manufacturer", "device_type__manufacturer__id"),
         ("manufacturer", "device_type__manufacturer__name"),
@@ -1878,14 +1876,6 @@ class DeviceTestCase(
                 Device.objects.filter(primary_ip4__isnull=True, primary_ip6__isnull=True),
             )
 
-    def test_ip_addresses(self):
-        addresses = list(IPAddress.objects.filter(interfaces__isnull=False)[:2])
-        params = {"ip_addresses": [addresses[0].address, addresses[1].id]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(interfaces__ip_addresses__in=addresses).distinct(),
-        )
-
     def test_virtual_chassis_member(self):
         # TODO: Not a generic_filter_test because this is a boolean filter but not a RelatedMembershipBooleanFilter
         with self.subTest():
@@ -2141,7 +2131,6 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         ("child_interfaces", "child_interfaces__name"),
         ("description",),
         # ("device", "device__id"),  # TODO - InterfaceFilterSet overrides device as a MultiValueCharFilter on name only
-        ("ip_addresses", "ip_addresses__id"),
         ("label",),
         ("lag", "lag__id"),
         ("lag", "lag__name"),
@@ -2389,20 +2378,6 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
             status=interface_statuses[3],
         )
 
-        ipaddr_status = Status.objects.get_for_model(IPAddress).first()
-        prefix_status = Status.objects.get_for_model(Prefix).first()
-        namespace = Namespace.objects.first()
-        Prefix.objects.create(prefix="192.0.2.0/24", namespace=namespace, status=prefix_status)
-        Prefix.objects.create(prefix="2600::/64", namespace=namespace, status=prefix_status)
-        ipaddresses = (
-            IPAddress.objects.create(address="192.0.2.1/24", namespace=namespace, status=ipaddr_status),
-            IPAddress.objects.create(address="192.0.2.2/24", namespace=namespace, status=ipaddr_status),
-            IPAddress.objects.create(address="2600::1/120", namespace=namespace, status=ipaddr_status),
-            IPAddress.objects.create(address="2600::0100/120", namespace=namespace, status=ipaddr_status),
-        )
-
-        cabled_interfaces[0].add_ip_addresses([ipaddresses[0], ipaddresses[2]])
-        cabled_interfaces[1].add_ip_addresses([ipaddresses[1], ipaddresses[3]])
         # Virtual Device Context
         vdc_status = Status.objects.get_for_model(VirtualDeviceContext).first()
         vdcs = [
@@ -2648,14 +2623,6 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         with self.subTest("device (pk) filter with an invalid uuid"):
             self.assertFalse(self.filterset({"device": [uuid.uuid4()]}, self.queryset).is_valid())
 
-    def test_ip_addresses(self):
-        addresses = list(IPAddress.objects.filter(interfaces__isnull=False)[:2])
-        params = {"ip_addresses": [addresses[0].address, addresses[1].id]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(ip_addresses__in=addresses).distinct(),
-        )
-
     def test_kind(self):
         # TODO: Not a generic_filter_test because this is a single-value filter
         # 2.0 TODO: Support filtering for multiple values

nautobot/dcim/tests/test_forms.py

@@ -1,16 +1,8 @@
 from django.test import TestCase
 
 from nautobot.core.testing.forms import FormTestCases
-from nautobot.core.testing.mixins import NautobotTestCaseMixin
 from nautobot.dcim.choices import DeviceFaceChoices, InterfaceModeChoices, InterfaceTypeChoices, RackWidthChoices
-from nautobot.dcim.forms import (
-    DeviceFilterForm,
-    DeviceForm,
-    InterfaceBulkEditForm,
-    InterfaceCreateForm,
-    InterfaceForm,
-    RackForm,
-)
+from nautobot.dcim.forms import DeviceFilterForm, DeviceForm, InterfaceCreateForm, InterfaceForm, RackForm
 from nautobot.dcim.models import (
     Device,
     DeviceType,
@@ -328,7 +320,7 @@ class RackTestCase(TestCase):
         self.assertTrue(form.is_valid())
 
 
-class InterfaceTestCase(NautobotTestCaseMixin, TestCase):
+class InterfaceTestCase(TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.device = Device.objects.first()
@@ -388,44 +380,3 @@ class InterfaceTestCase(NautobotTestCaseMixin, TestCase):
         self.vlan.locations.clear()
         form = InterfaceForm(data=self.data, instance=self.interface)
         self.assertTrue(form.is_valid())
-
-    def test_untagged_vlans_dropdown_options_align_in_interface_edit_form_and_bulk_edit_form(self):
-        """
-        Assert that untagged_vlans field dropdown are populated correctly in InterfaceForm and InterfaceBulkEditForm,
-        and that the queryset is the same for both forms.
-        """
-        status = Status.objects.get_for_model(Interface).first()
-        location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
-        devices = Device.objects.all()[:3]
-        for device in devices:
-            device.location = location
-            device.save()
-        interfaces = (
-            Interface.objects.create(
-                device=devices[0],
-                name="Test Interface 1",
-                type=InterfaceTypeChoices.TYPE_2GFC_SFP,
-                status=status,
-            ),
-            Interface.objects.create(
-                device=devices[1],
-                name="Test Interface 2",
-                type=InterfaceTypeChoices.TYPE_LAG,
-                status=status,
-            ),
-            Interface.objects.create(
-                device=devices[2],
-                name="Test Interface 3",
-                type=InterfaceTypeChoices.TYPE_100ME_FIXED,
-                status=status,
-            ),
-        )
-        edit_form = InterfaceForm(data=self.data, instance=interfaces[0])
-        bulk_edit_form = InterfaceBulkEditForm(
-            model=Interface,
-            data={"pks": [interface.pk for interface in interfaces]},
-        )
-        self.assertQuerysetEqualAndNotEmpty(
-            edit_form.fields["untagged_vlan"].queryset,
-            bulk_edit_form.fields["untagged_vlan"].queryset,
-        )

nautobot/dcim/tests/test_graphql.py

@@ -83,55 +83,3 @@ 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

@@ -4,7 +4,6 @@ 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
 
@@ -78,7 +77,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: type[Model]
+    model = None
     device_field = "device"  # field name for the parent device
     module_field = "module"  # field name for the parent module
 
@@ -1955,8 +1954,6 @@ class CableTestCase(ModelTestCases.BaseModelTestCase):
 
     @classmethod
     def setUpTestData(cls):
-        cls.interface_choices = {section[0]: dict(section[1]) for section in InterfaceTypeChoices.CHOICES}
-
         location = Location.objects.first()
         manufacturer = Manufacturer.objects.first()
         devicetype = DeviceType.objects.create(
@@ -2185,46 +2182,20 @@ class CableTestCase(ModelTestCases.BaseModelTestCase):
         """
         A cable cannot terminate to a virtual interface
         """
-        self.cable.delete()
-        interface_status = Status.objects.get_for_model(Interface).first()
-        virtual_interface = Interface.objects.create(
-            device=self.device1,
-            name="V1",
-            type=InterfaceTypeChoices.TYPE_VIRTUAL,
-            status=interface_status,
-        )
+        virtual_interface = Interface(device=self.device1, name="V1", type=InterfaceTypeChoices.TYPE_VIRTUAL)
         cable = Cable(termination_a=self.interface2, termination_b=virtual_interface)
-        with self.assertRaises(ValidationError) as cm:
+        with self.assertRaises(ValidationError):
             cable.clean()
 
-        virtual_interface_choices = self.interface_choices["Virtual interfaces"]
-        self.assertIn(
-            f"Cables cannot be terminated to {virtual_interface_choices[InterfaceTypeChoices.TYPE_VIRTUAL]} interfaces",
-            str(cm.exception),
-        )
-
     def test_cable_cannot_terminate_to_a_wireless_interface(self):
         """
         A cable cannot terminate to a wireless interface
         """
-        self.cable.delete()
-        interface_status = Status.objects.get_for_model(Interface).first()
-        wireless_interface = Interface.objects.create(
-            device=self.device1,
-            name="W1",
-            type=InterfaceTypeChoices.TYPE_80211A,
-            status=interface_status,
-        )
+        wireless_interface = Interface(device=self.device1, name="W1", type=InterfaceTypeChoices.TYPE_80211A)
         cable = Cable(termination_a=self.interface2, termination_b=wireless_interface)
-        with self.assertRaises(ValidationError) as cm:
+        with self.assertRaises(ValidationError):
             cable.clean()
 
-        wireless_interface_choices = self.interface_choices["Wireless"]
-        self.assertIn(
-            f"Cables cannot be terminated to {wireless_interface_choices[InterfaceTypeChoices.TYPE_80211A]} interfaces",
-            str(cm.exception),
-        )
-
     def test_create_cable_with_missing_status_connected(self):
         """Test for https://github.com/nautobot/nautobot/issues/2081"""
         # Delete all cables because some cables has connected status.

nautobot/dcim/tests/test_views.py

@@ -116,7 +116,6 @@ from nautobot.extras.models import (
     CustomField,
     CustomFieldChoice,
     ExternalIntegration,
-    JobResult,
     Relationship,
     RelationshipAssociation,
     Role,
@@ -129,7 +128,6 @@ from nautobot.ipam.choices import IPAddressTypeChoices
 from nautobot.ipam.models import IPAddress, Namespace, Prefix, VLAN, VLANGroup, VRF
 from nautobot.tenancy.models import Tenant
 from nautobot.users.models import ObjectPermission
-from nautobot.virtualization.models import Cluster, ClusterType
 
 # Use the proper swappable User model
 User = get_user_model()
@@ -1152,15 +1150,9 @@ module-bays:
         }
 
         response = self.client.post(url, data)
-        job_result = JobResult.objects.filter(name="Bulk Edit Objects").first()
-        # Assert successfull redirect to Job Results; whcih means no form validation error was raised
-        self.assertRedirects(
-            response,
-            reverse("extras:jobresult", args=[job_result.pk]),
-            status_code=302,
-            target_status_code=200,
-        )
         self.assertHttpStatus(response, 302)
+        for instance in self._get_queryset().filter(pk__in=pk_list):
+            self.assertEqual(instance.u_height, data["u_height"])
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_rack_height_bulk_edit_invalid(self):
@@ -1176,12 +1168,7 @@ module-bays:
         }
 
         response = self.client.post(url, data)
-        response_content = response.content.decode(response.charset)
-        self.assertHttpStatus(response, 200)
-        self.assertInHTML(
-            '<strong class="panel-title">U height</strong>: <ul class="errorlist"><li>Ensure this value is greater than or equal to 0.</li></ul>',
-            response_content,
-        )
+        self.assertBodyContains(response, "failed validation")
 
 
 class ModuleTypeTestCase(
@@ -2058,9 +2045,6 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
 
         rack_group = RackGroup.objects.create(location=locations[0], name="Rack Group 1")
 
-        cluster_type = ClusterType.objects.create(name="Cluster Type 1")
-        cluster = Cluster.objects.create(name="Cluster 1", cluster_type=cluster_type)
-
         rack_status = Status.objects.get_for_model(Rack).first()
         racks = (
             Rack.objects.create(
@@ -2232,8 +2216,6 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "status": statuses[2].pk,
             "location": locations[1].pk,
             "rack": racks[1].pk,
-            "cluster": cluster.pk,
-            "comments": "An older device",
             "position": None,
             "face": DeviceFaceChoices.FACE_FRONT,
             "secrets_group": secrets_groups[1].pk,
@@ -4592,6 +4574,46 @@ class SoftwareImageFileTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "download_url": "https://example.com/software_image_file_test_case.bin",
         }
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_correct_handling_for_model_protected_error(self):
+        platform = Platform.objects.first()
+        software_version_status = Status.objects.get_for_model(SoftwareVersion).first()
+        software_image_file_status = Status.objects.get_for_model(SoftwareImageFile).first()
+        software_version = SoftwareVersion.objects.create(
+            platform=platform, version="Test version 1.0.0", status=software_version_status
+        )
+        software_image_file = SoftwareImageFile.objects.create(
+            software_version=software_version,
+            image_file_name="software_image_file_qs_test_1.bin",
+            status=software_image_file_status,
+        )
+        device_type = DeviceType.objects.first()
+        device_role = Role.objects.get_for_model(Device).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        location = Location.objects.filter(location_type__name="Campus").first()
+        Device.objects.create(
+            device_type=device_type,
+            role=device_role,
+            name="Device 1",
+            location=location,
+            status=device_status,
+            software_version=software_version,
+        )
+        device_type_to_software_image_file = DeviceTypeToSoftwareImageFile.objects.create(
+            device_type=device_type, software_image_file=software_image_file
+        )
+
+        self.add_permissions("dcim.delete_softwareimagefile")
+        pk_list = [software_image_file.pk]
+        data = {
+            "pk": pk_list,
+            "confirm": True,
+            "_confirm": True,  # Form button
+        }
+        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
+        # Assert protected error message included in the response body
+        self.assertBodyContains(response, f"<span>{device_type_to_software_image_file}</span>", html=True)
+
 
 class SoftwareVersionTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = SoftwareVersion
@@ -4630,6 +4652,46 @@ class SoftwareVersionTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "pre_release": True,
         }
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_correct_handling_for_model_protected_error(self):
+        platform = Platform.objects.first()
+        software_version_status = Status.objects.get_for_model(SoftwareVersion).first()
+        software_image_file_status = Status.objects.get_for_model(SoftwareImageFile).first()
+        software_version = SoftwareVersion.objects.create(
+            platform=platform, version="Test version 1.0.0", status=software_version_status
+        )
+        software_image_file = SoftwareImageFile.objects.create(
+            software_version=software_version,
+            image_file_name="software_image_file_qs_test_1.bin",
+            status=software_image_file_status,
+        )
+        device_type = DeviceType.objects.first()
+        device_role = Role.objects.get_for_model(Device).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        location = Location.objects.filter(location_type__name="Campus").first()
+        Device.objects.create(
+            device_type=device_type,
+            role=device_role,
+            name="Device 1",
+            location=location,
+            status=device_status,
+            software_version=software_version,
+        )
+        device_type_to_software_image_file = DeviceTypeToSoftwareImageFile.objects.create(
+            device_type=device_type, software_image_file=software_image_file
+        )
+
+        self.add_permissions("dcim.delete_softwareversion")
+        pk_list = [software_version.pk]
+        data = {
+            "pk": pk_list,
+            "confirm": True,
+            "_confirm": True,  # Form button
+        }
+        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
+        # Assert protected error message included in the response body
+        self.assertBodyContains(response, f"<span>{device_type_to_software_image_file}</span>", html=True)
+
 
 class ControllerTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = Controller

nautobot/dcim/views.py

@@ -697,7 +697,7 @@ class RackReservationEditView(generic.ObjectEditView):
     model_form = forms.RackReservationForm
     template_name = "dcim/rackreservation_edit.html"
 
-    def alter_obj(self, obj, request, url_args, url_kwargs):
+    def alter_obj(self, obj, request, args, kwargs):
         if not obj.present_in_database:
             if "rack" in request.GET:
                 obj.rack = get_object_or_404(Rack, pk=request.GET.get("rack"))
@@ -4502,6 +4502,12 @@ class ControllerManagedDeviceGroupUIViewSet(NautobotUIViewSet):
 
         return obj
 
+    def extra_post_save_action(self, obj, form):
+        if form.cleaned_data.get("add_radio_profiles", None):
+            obj.radio_profiles.add(*form.cleaned_data["add_radio_profiles"])
+        if form.cleaned_data.get("remove_radio_profiles", None):
+            obj.radio_profiles.remove(*form.cleaned_data["remove_radio_profiles"])
+
 
 #
 # Virtual Device Context
@@ -4528,3 +4534,9 @@ class VirtualDeviceContextUIViewSet(NautobotUIViewSet):
                 **super().get_extra_context(request, instance),
             }
         return super().get_extra_context(request, instance)
+
+    def extra_post_save_action(self, obj, form):
+        if form.cleaned_data.get("add_interfaces", None):
+            obj.prefixes.add(*form.cleaned_data["add_interfaces"])
+        if form.cleaned_data.get("remove_interfaces", None):
+            obj.prefixes.remove(*form.cleaned_data["remove_interfaces"])

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, value):
-        return {key: value.get(key) for key in self.custom_field_keys}
+    def to_representation(self, obj):
+        return {key: obj.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."""