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

nautobot/dcim/tables/devices.py

@@ -220,13 +220,11 @@ class DeviceTable(StatusTableMixin, RoleTableMixin, BaseTable):
         )
 
 
-class DeviceImportTable(BaseTable):
+class DeviceImportTable(StatusTableMixin, RoleTableMixin, BaseTable):
     name = tables.TemplateColumn(template_code=DEVICE_LINK)
-    status = ColoredLabelColumn()
     tenant = TenantColumn()
     location = tables.Column(linkify=True)
     rack = tables.Column(linkify=True)
-    role = tables.Column(verbose_name="Role")
     device_type = tables.Column(verbose_name="Type")
 
     class Meta(BaseTable.Meta):
@@ -1333,15 +1331,13 @@ class SoftwareVersionTable(StatusTableMixin, BaseTable):
         )
 
 
-class ControllerTable(BaseTable):
+class ControllerTable(StatusTableMixin, RoleTableMixin, BaseTable):
     """Table for list view."""
 
     pk = ToggleColumn()
     name = tables.Column(linkify=True)
-    status = ColoredLabelColumn()
     location = tables.Column(linkify=True)
     platform = tables.Column(linkify=True)
-    role = tables.Column(linkify=True)
     tenant = TenantColumn()
     external_integration = tables.Column(linkify=True)
     controller_device = tables.Column(linkify=True)

nautobot/dcim/templates/dcim/controller_retrieve.html

@@ -20,7 +20,7 @@
                         </tr>
                         <tr>
                             <td>Role</td>
-                            <td>{{ object.role|hyperlinked_object }}</td>
+                            <td>{{ object.role|hyperlinked_object_with_color }}</td>
                         </tr>
                         <tr>
                             <td>Location</td>

nautobot/dcim/templates/dcim/device/base.html

@@ -58,7 +58,7 @@
     <span class="hover_copy">
         <h1>
             <span id="devicename">{% block title %}{{ object }}{% endblock title %}</span>
-            <button class="btn btn-xs btn-default hover_copy_button" data-clipboard-target="#devicename">
+            <button class="btn btn-xs btn-default hover_copy_button" data-clipboard-text="{{ object }}">
                 <span class="mdi mdi-content-copy"></span>
             </button>
         </h1>

nautobot/dcim/tests/test_filters.py

@@ -1701,6 +1701,7 @@ 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"),
@@ -1874,6 +1875,14 @@ 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():
@@ -2168,6 +2177,7 @@ 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"),
@@ -2413,6 +2423,21 @@ 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]])
+
     def test_enabled(self):
         # TODO: Not a generic_filter_test because this is a boolean filter but not a RelatedMembershipBooleanFilter
         with self.subTest():
@@ -2646,6 +2671,14 @@ 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_views.py

@@ -130,6 +130,7 @@ 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()
@@ -2047,6 +2048,9 @@ 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(
@@ -2218,6 +2222,8 @@ 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,

nautobot/extras/api/serializers.py

@@ -270,6 +270,7 @@ class ContactAssociationSerializer(NautobotModelSerializer):
 
 
 class ContentTypeSerializer(BaseModelSerializer):
+    id = serializers.IntegerField(read_only=True)
     url = serializers.HyperlinkedIdentityField(view_name="extras-api:contenttype-detail")
     display = serializers.SerializerMethodField()
 

nautobot/extras/api/views.py

@@ -17,6 +17,7 @@ from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 
 from nautobot.core.api.authentication import TokenPermissions
+from nautobot.core.api.parsers import NautobotCSVParser
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.api.views import (
     BulkDestroyModelMixin,
@@ -484,6 +485,7 @@ class ImageAttachmentViewSet(ModelViewSet):
     queryset = ImageAttachment.objects.all()
     serializer_class = serializers.ImageAttachmentSerializer
     filterset_class = filters.ImageAttachmentFilterSet
+    parser_classes = [JSONParser, NautobotCSVParser, MultiPartParser]
 
 
 #

nautobot/extras/forms/forms.py

@@ -1682,6 +1682,8 @@ class RoleBulkEditForm(NautobotBulkEditForm):
 
     pk = forms.ModelMultipleChoiceField(queryset=Role.objects.all(), widget=forms.MultipleHiddenInput)
     color = forms.CharField(max_length=6, required=False, widget=ColorSelect())
+    description = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False)
+    weight = forms.IntegerField(required=False)
     content_types = MultipleContentTypeField(
         queryset=RoleModelsQuery().as_queryset(), required=False, label="Content Type(s)"
     )

nautobot/extras/group_sync.py

@@ -0,0 +1,42 @@
+"""Additional functions to process an OAuth2/OIDC user."""
+
+import logging
+
+from django.conf import settings
+from django.contrib.auth.models import Group
+
+logger = logging.getLogger(__name__)
+
+
+CLAIMS_GROUP_NAME = getattr(settings, "SSO_CLAIMS_GROUP", "groups")
+""" Which claim to look at in the OAuth2/OIDC response
+
+    For Okta you can look at `Okta -> Authorization Servers -> Claims`. And a reasonable
+    default is "groups". For Azure a reasonable default is "roles".
+"""
+
+SUPERUSER_GROUPS = getattr(settings, "SSO_SUPERUSER_GROUPS", [])
+STAFF_GROUPS = getattr(settings, "SSO_STAFF_GROUPS", [])
+
+
+def group_sync(uid, user=None, response=None, *args, **kwargs):
+    """Sync the users groups from OAuth2/OIDC auth and set staff/superuser as appropriate."""
+    if user and response and CLAIMS_GROUP_NAME and response.get(CLAIMS_GROUP_NAME, False):
+        group_memberships = response.get(CLAIMS_GROUP_NAME)
+        is_staff = False
+        is_superuser = False
+        logger.debug(f"User {uid} is a member of {', '.join(group_memberships)}")
+        # Make sure all groups exist in Nautobot
+        group_ids = []
+        for group in group_memberships:
+            if group in SUPERUSER_GROUPS:
+                is_superuser = True
+            if group in STAFF_GROUPS:
+                is_staff = True
+            group_ids.append(Group.objects.get_or_create(name=group)[0].id)
+        user.groups.set(group_ids)
+        user.is_superuser = is_superuser
+        user.is_staff = is_staff
+        user.save()
+    else:
+        logger.debug(f"Did not receive groups from OAuth2/OIDC, response: {response}")

nautobot/extras/models/metadata.py

@@ -201,6 +201,7 @@ class ObjectMetadata(ChangeLoggedModel, BaseModel):
     objects = ObjectMetadataManager()
     natural_key_field_names = ["pk"]
     documentation_static_path = "docs/user-guide/platform-functionality/objectmetadata.html"
+    is_metadata_associable_model = False
 
     class Meta:
         ordering = ["metadata_type"]

nautobot/extras/models/models.py

@@ -831,7 +831,7 @@ class Note(ChangeLoggedModel, BaseModel):
         unique_together = [["assigned_object_type", "assigned_object_id", "user_name", "created"]]
 
     def __str__(self):
-        return f"{self.assigned_object} - {self.created.isoformat()}"
+        return f"{self.assigned_object} - {self.created.isoformat() if self.created else None}"
 
     def save(self, *args, **kwargs):
         # Record the user's name as static strings

nautobot/extras/plugins/__init__.py

@@ -207,8 +207,9 @@ class NautobotAppConfig(NautobotConfig):
         override_views = import_object(f"{self.__module__}.{self.override_views}")
         if override_views is not None:
             for qualified_view_name, view in override_views.items():
+                view_class_name = view.view_class.__name__ if hasattr(view, "view_class") else view.cls.__name__
                 self.features.setdefault("overridden_views", []).append(
-                    (qualified_view_name, f"{view.__module__}.{view.view_class.__name__}")
+                    (qualified_view_name, f"{view.__module__}.{view_class_name}")
                 )
             register_override_views(override_views, self.name)
 
@@ -518,6 +519,7 @@ class TableExtension:
     """
 
     model = None
+    suffix = None
     table_columns = {}
     add_to_default_columns = ()
     remove_from_default_columns = ()
@@ -593,7 +595,7 @@ def _add_columns_into_model_table(table_extension, app_name):
         logger.error(error)
         return
 
-    table = get_table_for_model(table_extension.model)
+    table = get_table_for_model(table_extension.model, suffix=table_extension.suffix)
     for name, column in table_extension.table_columns.items():
         _validate_table_column_name_is_prefixed_with_app_name(name, app_name)
         _add_column_to_table_base_columns(table, name, column, app_name)
@@ -628,18 +630,28 @@ def _modify_default_table_columns(table_extension, app_name):
     """Add or remove columns from the table default columns."""
     from nautobot.core.utils.lookup import get_table_for_model
 
-    table = get_table_for_model(table_extension.model)
+    table = get_table_for_model(table_extension.model, suffix=table_extension.suffix)
     message = (
         f"{app_name}: Cannot {{action}} column `{{column_name}}` {{preposition}} the default columns for `{table}`."
     )
 
     for column_name in table_extension.add_to_default_columns:
+        if not getattr(table.Meta, "default_columns", None):
+            logger.warning(
+                f"{app_name}: Table `{table}` does not have a `default_columns` attribute. Cannot add column: {column_name}."
+            )
+            continue
         if column_name in table.base_columns:
             table.Meta.default_columns = (*table.Meta.default_columns, column_name)
         else:
             logger.debug(message.format(action="add", column_name=column_name, preposition="to"))
 
     for column_name in table_extension.remove_from_default_columns:
+        if not getattr(table.Meta, "default_columns", None):
+            logger.warning(
+                f"{app_name}: Table `{table}` does not have a `default_columns` attribute. Cannot remove column: {column_name}."
+            )
+            continue
         if column_name in table.Meta.default_columns:
             table.Meta.default_columns = tuple(name for name in table.Meta.default_columns if name != column_name)
         else:

nautobot/extras/tables.py

@@ -978,6 +978,7 @@ class MetadataTypeTable(BaseTable):
 
 class ObjectMetadataTable(BaseTable):
     pk = ToggleColumn()
+    # NOTE: there is no identity column in this table; this is intentional as we have no detail view for ObjectMetadata
     metadata_type = tables.Column(linkify=True)
     assigned_object = tables.TemplateColumn(
         template_code=ASSIGNED_OBJECT, verbose_name="Assigned object", orderable=False

nautobot/extras/templates/extras/inc/job_table.html

@@ -28,7 +28,7 @@
                 </th>
             </tr>
             {% endifchanged %}
-            <tr class="collapseme-{{ row.record.grouping|slugify }}{% if not perms.extras.run_job or not row.record.runnable %} disabled{% endif %} collapse in" data-parent="#accordion" {{ row.attrs.as_html }}>
+            <tr class="{% cycle 'even' 'odd' %} collapseme-{{ row.record.grouping|slugify }}{% if not perms.extras.run_job or not row.record.runnable %} disabled{% endif %} collapse in" data-parent="#accordion" {{ row.attrs.as_html }}>
                 {% for column, cell in row.items %}
                     <td {{ column.attrs.td.as_html }}>{{ cell }}</td>
                 {% endfor %}

nautobot/extras/tests/test_views.py

@@ -3033,8 +3033,6 @@ class ObjectChangeTestCase(TestCase):
 
 
 class ObjectMetadataTestCase(
-    ViewTestCases.GetObjectViewTestCase,
-    ViewTestCases.GetObjectChangelogViewTestCase,
     ViewTestCases.ListObjectsViewTestCase,
 ):
     model = ObjectMetadata
@@ -3609,6 +3607,8 @@ class RoleTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
 
         cls.bulk_edit_data = {
             "color": "000000",
+            "description": "I used to be a new role object.",
+            "weight": 255,
         }
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])

nautobot/extras/views.py

@@ -2228,8 +2228,6 @@ class MetadataTypeUIViewSet(NautobotUIViewSet):
 
 
 class ObjectMetadataUIViewSet(
-    ObjectChangeLogViewMixin,
-    ObjectDetailViewMixin,
     ObjectListViewMixin,
 ):
     filterset_class = filters.ObjectMetadataFilterSet

nautobot/ipam/lookups.py

@@ -3,7 +3,9 @@ from django.db.models import Lookup, lookups
 import netaddr
 
 
-def _mysql_varbin_to_broadcast():
+def _mysql_varbin_to_broadcast(alias=None):
+    if alias:
+        return f"HEX({alias}.broadcast)"
     return "HEX(broadcast)"
 
 
@@ -13,11 +15,15 @@ def _mysql_varbin_to_hex(lhs, alias=None):
     return f"HEX({lhs})"
 
 
-def _mysql_varbin_to_network():
+def _mysql_varbin_to_network(alias=None):
+    if alias:
+        return f"HEX({alias}.network)"
     return "HEX(network)"
 
 
-def _postgresql_varbin_to_broadcast(length):
+def _postgresql_varbin_to_broadcast(length, alias=None):
+    if alias:
+        return f"right({alias}.broadcast::text, -1)::varbit::bit({length})"
     return f"right(broadcast::text, -1)::varbit::bit({length})"
 
 
@@ -27,8 +33,10 @@ def _postgresql_varbin_to_integer(lhs, length, alias=None):
     return f"right({lhs}::text, -1)::varbit::bit({length})"
 
 
-def _postgresql_varbin_to_network(lhs, length):
+def _postgresql_varbin_to_network(lhs, length, alias=None):
     # convert to bitstring, 0 out everything larger than prefix_length
+    if alias:
+        return f"lpad(right({alias}.{lhs}::text, -1)::varbit::text, {alias}.prefix_length, '0')::bit({length})"
     return f"lpad(right({lhs}::text, -1)::varbit::text, prefix_length, '0')::bit({length})"
 
 
@@ -52,8 +60,8 @@ def get_ip_info(field_name, ip_str, alias=None):
         ip_details.rhs = py_to_hex(ip.ip, ip_details.length)
         ip_details.net_addr = f"'{py_to_hex(ip.network, ip_details.length)}'"
         ip_details.bcast_addr = f"'{py_to_hex(ip[-1], ip_details.length)}'"
-        ip_details.q_net = _mysql_varbin_to_network()
-        ip_details.q_bcast = _mysql_varbin_to_broadcast()
+        ip_details.q_net = _mysql_varbin_to_network(alias=alias)
+        ip_details.q_bcast = _mysql_varbin_to_broadcast(alias=alias)
         ip_details.q_ip = _mysql_varbin_to_hex(field_name, alias=alias)
 
     elif _connection.vendor == "postgresql":
@@ -61,8 +69,8 @@ def get_ip_info(field_name, ip_str, alias=None):
         ip_details.addr_str = f"B'{bin(int(ip_details.addr))[2:].zfill(ip_details.length)}'"
         ip_details.net_addr = f"B'{bin(int(ip.network))[2:].zfill(ip_details.length)}'"
         ip_details.bcast_addr = f"B'{bin(int(ip[-1]))[2:].zfill(ip_details.length)}'"
-        ip_details.q_net = _postgresql_varbin_to_network(field_name, ip_details.length)
-        ip_details.q_bcast = _postgresql_varbin_to_broadcast(ip_details.length)
+        ip_details.q_net = _postgresql_varbin_to_network(field_name, ip_details.length, alias=alias)
+        ip_details.q_bcast = _postgresql_varbin_to_broadcast(ip_details.length, alias=alias)
         ip_details.q_ip = _postgresql_varbin_to_integer(field_name, ip_details.length, alias=alias)
 
     return ip_details
@@ -71,25 +79,38 @@ def get_ip_info(field_name, ip_str, alias=None):
 class IPDetails:
     """Class for setting up all details about an IP they may be needed"""
 
-    net = None
-    addr = None
-    ip = None
-    prefix = None
-    length = None
-    addr_str = None
-    rhs = None
-    net_addr = None
-    bcast_addr = None
-    q_net = None
-    q_bcast = None
-    q_ip = None
+    addr = None  # 10.0.0.0
+    ip = None  # 10.0.0.0/8
+    prefix = None  # 8
+    length = None  # 32
+    addr_str = None  # B'00001010000000000000000000000000'
+    rhs = None  # 00001010000000000000000000000000
+    net_addr = None  # B'00001010000000000000000000000000'
+    bcast_addr = None  # B'00001010111111111111111111111111'
+    q_net = None  # mysql or postgres specific
+    q_bcast = None  # mysql or postgres specific
+    q_ip = None  # mysql or postgres specific
     to_len = {4: 32, 6: 128}
 
+    def __str__(self):
+        return f"""\
+addr: {self.addr}
+ip: {self.ip}
+prefix: {self.prefix}
+length: {self.length}
+addr_str: {self.addr_str}
+rhs: {self.rhs}
+net_addr: {self.net_addr}
+bcast_addr: {self.bcast_addr}
+q_net: {self.q_net}
+q_bcast: {self.q_bcast}
+q_ip: {self.q_ip}"""
+
 
 class StringMatchMixin:
-    def process_lhs(self, qn, connection, lhs=None):
+    def process_lhs(self, compiler, connection, lhs=None):
         lhs = lhs or self.lhs
-        lhs_string, lhs_params = qn.compile(lhs)
+        lhs_string, lhs_params = compiler.compile(lhs)
         if connection.vendor == "postgresql":
             raise NotSupportedError("Lookup not supported on postgresql.")
         return f"INET6_NTOA({lhs_string})", lhs_params
@@ -129,6 +150,7 @@ class IRegex(StringMatchMixin, lookups.IRegex):
 
 class NetworkFieldMixin:
     def get_prep_lookup(self):
+        self.alias = self.lhs.alias
         field_name = self.lhs.field.name
         if field_name not in ["host", "network"]:
             raise NotSupportedError(f"Lookup only provided on the host and network fields, not {field_name}.")
@@ -139,8 +161,8 @@ class NetworkFieldMixin:
         self.ip = get_ip_info(field_name, self.rhs, alias=self.lhs.alias)
         return str(self.ip.ip)
 
-    def process_rhs(self, qn, connection):
-        sql, params = super().process_rhs(qn, connection)
+    def process_rhs(self, compiler, connection):
+        sql, params = super().process_rhs(compiler, connection)
         params[0] = self.ip.rhs
         return sql, params
 
@@ -148,50 +170,67 @@ class NetworkFieldMixin:
 class NetEquals(NetworkFieldMixin, Lookup):
     lookup_name = "net_equals"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length = {self.ip.prefix} AND {rhs} = {self.ip.q_ip}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = f"{self.alias}.prefix_length = {self.ip.prefix} AND {rhs} = {self.ip.q_ip}"
+        else:
+            query = f"prefix_length = {self.ip.prefix} AND {rhs} = {self.ip.q_ip}"
         return query, lhs_params + rhs_params
 
 
 class NetContainsOrEquals(NetworkFieldMixin, Lookup):
     lookup_name = "net_contains_or_equals"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length <= {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = f"{self.alias}.prefix_length <= {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
+        else:
+            query = f"prefix_length <= {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
         return query, lhs_params + rhs_params
 
 
 class NetContains(NetworkFieldMixin, Lookup):
     lookup_name = "net_contains"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length < {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = (
+                f"{self.alias}.prefix_length < {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
+            )
+        else:
+            query = f"prefix_length < {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
         return query, lhs_params + rhs_params
 
 
 class NetContainedOrEqual(NetworkFieldMixin, Lookup):
     lookup_name = "net_contained_or_equal"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length >= {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = f"{self.alias}.prefix_length >= {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
+        else:
+            query = f"prefix_length >= {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
         return query, lhs_params + rhs_params
 
 
 class NetContained(NetworkFieldMixin, Lookup):
     lookup_name = "net_contained"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length > {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = f"{self.alias}.prefix_length > {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
+        else:
+            query = f"prefix_length > {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
         return query, lhs_params + rhs_params
 
 
@@ -205,19 +244,19 @@ class NetHost(Lookup):
         self.ip = get_ip_info(field_name, self.rhs, alias=self.lhs.alias)
         return str(self.ip.ip)
 
-    def process_rhs(self, qn, connection):
-        sql, params = super().process_rhs(qn, connection)
+    def process_rhs(self, compiler, connection):
+        sql, params = super().process_rhs(compiler, connection)
         params[0] = self.ip.rhs
         return sql, params
 
-    def process_lhs(self, qn, connection, lhs=None):
+    def process_lhs(self, compiler, connection, lhs=None):
         lhs = lhs or self.lhs
-        _, lhs_params = qn.compile(lhs)
+        _, lhs_params = compiler.compile(lhs)
         return self.ip.q_ip, lhs_params
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         return f"{lhs} = {rhs}", lhs_params + rhs_params
 
 
@@ -242,9 +281,9 @@ class NetIn(Lookup):
             self.query_starter = "'1' != ANY(%s) AND "
         return self.rhs
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        _, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        _, rhs_params = self.process_rhs(compiler, connection)
         query = self.query_starter
         query += "OR ".join(f"{ip.q_ip} BETWEEN {ip.net_addr} AND {ip.bcast_addr} " for ip in self.ips)
         return query, lhs_params + rhs_params
@@ -253,9 +292,9 @@ class NetIn(Lookup):
 class NetHostContained(NetworkFieldMixin, Lookup):
     lookup_name = "net_host_contained"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         query = f"{self.ip.q_ip} BETWEEN {rhs} AND {self.ip.bcast_addr}"
         return query, lhs_params + rhs_params
 
@@ -270,12 +309,12 @@ class NetFamily(Lookup):
             self.rhs = 16
         return self.rhs
 
-    def process_lhs(self, qn, connection, lhs=None):
+    def process_lhs(self, compiler, connection, lhs=None):
         lhs = lhs or self.lhs
-        lhs_string, lhs_params = qn.compile(lhs)
+        lhs_string, lhs_params = compiler.compile(lhs)
         return f"LENGTH({lhs_string})", lhs_params
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         return f"{lhs} = {rhs}", lhs_params + rhs_params