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

nautobot/ipam/lookups.py

@@ -3,9 +3,7 @@ from django.db.models import Lookup, lookups
 import netaddr
 
 
-def _mysql_varbin_to_broadcast(alias=None):
-    if alias:
-        return f"HEX({alias}.broadcast)"
+def _mysql_varbin_to_broadcast():
     return "HEX(broadcast)"
 
 
@@ -15,15 +13,11 @@ def _mysql_varbin_to_hex(lhs, alias=None):
     return f"HEX({lhs})"
 
 
-def _mysql_varbin_to_network(alias=None):
-    if alias:
-        return f"HEX({alias}.network)"
+def _mysql_varbin_to_network():
     return "HEX(network)"
 
 
-def _postgresql_varbin_to_broadcast(length, alias=None):
-    if alias:
-        return f"right({alias}.broadcast::text, -1)::varbit::bit({length})"
+def _postgresql_varbin_to_broadcast(length):
     return f"right(broadcast::text, -1)::varbit::bit({length})"
 
 
@@ -33,10 +27,8 @@ 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, alias=None):
+def _postgresql_varbin_to_network(lhs, length):
     # 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})"
 
 
@@ -60,8 +52,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(alias=alias)
-        ip_details.q_bcast = _mysql_varbin_to_broadcast(alias=alias)
+        ip_details.q_net = _mysql_varbin_to_network()
+        ip_details.q_bcast = _mysql_varbin_to_broadcast()
         ip_details.q_ip = _mysql_varbin_to_hex(field_name, alias=alias)
 
     elif _connection.vendor == "postgresql":
@@ -69,8 +61,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, alias=alias)
-        ip_details.q_bcast = _postgresql_varbin_to_broadcast(ip_details.length, alias=alias)
+        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_ip = _postgresql_varbin_to_integer(field_name, ip_details.length, alias=alias)
 
     return ip_details
@@ -79,38 +71,25 @@ 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"""
 
-    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
+    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
     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, compiler, connection, lhs=None):
+    def process_lhs(self, qn, connection, lhs=None):
         lhs = lhs or self.lhs
-        lhs_string, lhs_params = compiler.compile(lhs)
+        lhs_string, lhs_params = qn.compile(lhs)
         if connection.vendor == "postgresql":
             raise NotSupportedError("Lookup not supported on postgresql.")
         return f"INET6_NTOA({lhs_string})", lhs_params
@@ -150,7 +129,6 @@ 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}.")
@@ -161,8 +139,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, compiler, connection):
-        sql, params = super().process_rhs(compiler, connection)
+    def process_rhs(self, qn, connection):
+        sql, params = super().process_rhs(qn, connection)
         params[0] = self.ip.rhs
         return sql, params
 
@@ -170,67 +148,50 @@ class NetworkFieldMixin:
 class NetEquals(NetworkFieldMixin, Lookup):
     lookup_name = "net_equals"
 
-    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}"
+    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}"
         return query, lhs_params + rhs_params
 
 
 class NetContainsOrEquals(NetworkFieldMixin, Lookup):
     lookup_name = "net_contains_or_equals"
 
-    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}"
+    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}"
         return query, lhs_params + rhs_params
 
 
 class NetContains(NetworkFieldMixin, Lookup):
     lookup_name = "net_contains"
 
-    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}"
+    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}"
         return query, lhs_params + rhs_params
 
 
 class NetContainedOrEqual(NetworkFieldMixin, Lookup):
     lookup_name = "net_contained_or_equal"
 
-    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}"
+    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}"
         return query, lhs_params + rhs_params
 
 
 class NetContained(NetworkFieldMixin, Lookup):
     lookup_name = "net_contained"
 
-    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}"
+    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}"
         return query, lhs_params + rhs_params
 
 
@@ -244,19 +205,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, compiler, connection):
-        sql, params = super().process_rhs(compiler, connection)
+    def process_rhs(self, qn, connection):
+        sql, params = super().process_rhs(qn, connection)
         params[0] = self.ip.rhs
         return sql, params
 
-    def process_lhs(self, compiler, connection, lhs=None):
+    def process_lhs(self, qn, connection, lhs=None):
         lhs = lhs or self.lhs
-        _, lhs_params = compiler.compile(lhs)
+        _, lhs_params = qn.compile(lhs)
         return self.ip.q_ip, lhs_params
 
-    def as_sql(self, compiler, connection):
-        lhs, lhs_params = self.process_lhs(compiler, connection)
-        rhs, rhs_params = self.process_rhs(compiler, connection)
+    def as_sql(self, qn, connection):
+        lhs, lhs_params = self.process_lhs(qn, connection)
+        rhs, rhs_params = self.process_rhs(qn, connection)
         return f"{lhs} = {rhs}", lhs_params + rhs_params
 
 
@@ -281,9 +242,9 @@ class NetIn(Lookup):
             self.query_starter = "'1' != ANY(%s) AND "
         return self.rhs
 
-    def as_sql(self, compiler, connection):
-        _, lhs_params = self.process_lhs(compiler, connection)
-        _, rhs_params = self.process_rhs(compiler, connection)
+    def as_sql(self, qn, connection):
+        _, lhs_params = self.process_lhs(qn, connection)
+        _, rhs_params = self.process_rhs(qn, 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
@@ -292,9 +253,9 @@ class NetIn(Lookup):
 class NetHostContained(NetworkFieldMixin, Lookup):
     lookup_name = "net_host_contained"
 
-    def as_sql(self, compiler, connection):
-        _, lhs_params = self.process_lhs(compiler, connection)
-        rhs, rhs_params = self.process_rhs(compiler, connection)
+    def as_sql(self, qn, connection):
+        _, lhs_params = self.process_lhs(qn, connection)
+        rhs, rhs_params = self.process_rhs(qn, connection)
         query = f"{self.ip.q_ip} BETWEEN {rhs} AND {self.ip.bcast_addr}"
         return query, lhs_params + rhs_params
 
@@ -309,12 +270,12 @@ class NetFamily(Lookup):
             self.rhs = 16
         return self.rhs
 
-    def process_lhs(self, compiler, connection, lhs=None):
+    def process_lhs(self, qn, connection, lhs=None):
         lhs = lhs or self.lhs
-        lhs_string, lhs_params = compiler.compile(lhs)
+        lhs_string, lhs_params = qn.compile(lhs)
         return f"LENGTH({lhs_string})", lhs_params
 
-    def as_sql(self, compiler, connection):
-        lhs, lhs_params = self.process_lhs(compiler, connection)
-        rhs, rhs_params = self.process_rhs(compiler, connection)
+    def as_sql(self, qn, connection):
+        lhs, lhs_params = self.process_lhs(qn, connection)
+        rhs, rhs_params = self.process_rhs(qn, connection)
         return f"{lhs} = {rhs}", lhs_params + rhs_params

nautobot/ipam/models.py

@@ -27,18 +27,18 @@ from .querysets import IPAddressQuerySet, PrefixQuerySet, RIRQuerySet, VLANQuery
 from .validators import DNSValidator
 
 __all__ = (
-    "RIR",
-    "VLAN",
-    "VRF",
     "IPAddress",
     "IPAddressToInterface",
     "Namespace",
     "Prefix",
     "PrefixLocationAssignment",
+    "RIR",
     "RouteTarget",
     "Service",
+    "VLAN",
     "VLANGroup",
     "VLANLocationAssignment",
+    "VRF",
     "VRFDeviceAssignment",
     "VRFPrefixAssignment",
 )
@@ -531,32 +531,8 @@ class Prefix(PrimaryModel):
         prefix = kwargs.pop("prefix", None)
         self._location = kwargs.pop("location", None)
         super().__init__(*args, **kwargs)
-
-        # Initialize cached fields
-        self._parent = None
-        self._network = None
-        self._prefix_length = None
-        self._namespace_id = None
-
         self._deconstruct_prefix(prefix)
 
-    @staticmethod
-    def _extract_field_value(field_name, field_names, values):
-        for current_field, field_value in zip(field_names, values):
-            if field_name == current_field:
-                return field_value
-        return None
-
-    @classmethod
-    def from_db(cls, db, field_names, values):
-        instance = super().from_db(db, field_names, values)
-        # These cached values are used to detect changes during save,
-        # avoiding unnecessary re-parenting of subnets and IPs if these fields have not been updated.
-        instance._network = cls._extract_field_value("network", field_names, values)
-        instance._prefix_length = cls._extract_field_value("prefix_length", field_names, values)
-        instance._namespace_id = cls._extract_field_value("namespace_id", field_names, values)
-        return instance
-
     def __str__(self):
         return str(self.prefix)
 
@@ -636,30 +612,18 @@ class Prefix(PrimaryModel):
             protected_objects.update(parent=self.parent)
             return super().delete(*args, **kwargs)
 
-    def get_parent(self):
-        # Determine if a parent exists and set it to the closest ancestor by `prefix_length`.
-        if self._parent is not None:
-            return self._parent
-
-        if supernets := self.supernets():
-            parent = max(supernets, key=operator.attrgetter("prefix_length"))
-            self._parent = parent
-            return parent
-        return None
-
-    def clean(self):
-        if self.prefix is not None:  # missing network/prefix_length will be caught by super().clean()
+    def save(self, *args, **kwargs):
+        if isinstance(self.prefix, netaddr.IPNetwork):
             # Clear host bits from prefix
             # This also has the subtle side effect of calling self._deconstruct_prefix(),
             # which will (re)set the broadcast and ip_version values of this instance to their correct values.
             self.prefix = self.prefix.cidr
 
-            self.parent = self.get_parent()
-
-        super().clean()
-
-    def save(self, *args, **kwargs):
-        self.clean()
+        # Determine if a parent exists and set it to the closest ancestor by `prefix_length`.
+        supernets = self.supernets()
+        if supernets:
+            parent = max(supernets, key=operator.attrgetter("prefix_length"))
+            self.parent = parent
 
         # Validate that creation of this prefix does not create an invalid parent/child relationship
         # 3.0 TODO: uncomment this to enforce this constraint
@@ -691,26 +655,15 @@ class Prefix(PrimaryModel):
         #     )
         #     raise ValidationError({"__all__": err_msg})
 
-        # cache the value of present_in_database; because after `super().save()`
-        # `self.present_in_database` would always return True`
-        present_in_database = self.present_in_database
-
         with transaction.atomic():
             super().save(*args, **kwargs)
             if self._location is not None:
                 self.location = self._location
 
-        # Only reparent subnets and ips if any of these fields has been updated.
-        if (
-            not present_in_database
-            or self._network != self.network
-            or self._namespace_id != self.namespace_id
-            or self._prefix_length != self.prefix_length
-        ):
-            # Determine the subnets and reparent them to this prefix.
-            self.reparent_subnets()
-            # Determine the child IPs and reparent them to this prefix.
-            self.reparent_ips()
+        # Determine the subnets and reparent them to this prefix.
+        self.reparent_subnets()
+        # Determine the child IPs and reparent them to this prefix.
+        self.reparent_ips()
 
     @property
     def cidr_str(self):
@@ -786,7 +739,6 @@ class Prefix(PrimaryModel):
         Returns:
             QuerySet
         """
-
         query = Prefix.objects.all()
 
         if for_update:
@@ -798,7 +750,7 @@ class Prefix(PrimaryModel):
         if not include_self:
             query = query.exclude(id=self.id)
 
-        supernets = query.filter(
+        return query.filter(
             ip_version=self.ip_version,
             prefix_length__lte=self.prefix_length,
             network__lte=self.network,
@@ -806,8 +758,6 @@ class Prefix(PrimaryModel):
             namespace=self.namespace,
         )
 
-        return supernets
-
     def subnets(self, direct=False, include_self=False, for_update=False):
         """
         Return subnets of this Prefix.
@@ -917,7 +867,7 @@ class Prefix(PrimaryModel):
         Return all available IPs within this prefix as an IPSet.
         """
         prefix = netaddr.IPSet(self.prefix)
-        child_ips = netaddr.IPSet([ip.address.ip for ip in self.get_all_ips()])
+        child_ips = netaddr.IPSet([ip.address.ip for ip in self.ip_addresses.all()])
         available_ips = prefix - child_ips
 
         # IPv6, pool, or IPv4 /31-32 sets are fully usable

nautobot/ipam/querysets.py

@@ -398,7 +398,7 @@ class IPAddressQuerySet(BaseNetworkQuerySet):
         """
         return super().order_by("host")
 
-    def get_or_create(self, defaults=None, **kwargs):
+    def get_or_create(self, **kwargs):
         from nautobot.ipam.models import get_default_namespace, Prefix
 
         parent = kwargs.get("parent")
@@ -421,7 +421,7 @@ class IPAddressQuerySet(BaseNetworkQuerySet):
                 raise ValidationError(f"{cidr} does not appear to be an IPv4 or IPv6 network.") from err
             parent = Prefix.objects.filter(namespace=namespace).get_closest_parent(cidr=cidr, include_self=True)
             kwargs["parent"] = parent
-        return super().get_or_create(defaults=defaults, **kwargs)
+        return super().get_or_create(**kwargs)
 
     def string_search(self, search):
         """

nautobot/ipam/tables.py

@@ -43,11 +43,9 @@ UTILIZATION_GRAPH = """
 """
 
 
-# record: the Prefix being rendered in this row
-# object: the base ancestor Prefix, in the case of PrefixDetailTable, else None
 PREFIX_COPY_LINK = """
 {% load helpers %}
-{% tree_hierarchy_ui_representation record.ancestors.count|as_range table.hide_hierarchy_ui base_tree_depth|default:0 %}
+{% tree_hierarchy_ui_representation record.ancestors.count|as_range table.hide_hierarchy_ui%}
 <span class="hover_copy">
   <a href="\
 {% if record.present_in_database %}\
@@ -406,7 +404,7 @@ class PrefixDetailTable(PrefixTable):
             "type",
             "status",
             "children",
-            "vrf_count",
+            # "vrf",
             "utilization",
             "tenant",
             "location_count",
@@ -422,7 +420,7 @@ class PrefixDetailTable(PrefixTable):
             "type",
             "status",
             "children",
-            "vrf_count",
+            # "vrf",
             "utilization",
             "tenant",
             "location_count",
@@ -444,27 +442,13 @@ class IPAddressTable(StatusTableMixin, RoleTableMixin, BaseTable):
     )
     tenant = TenantColumn()
     parent__namespace = tables.Column(linkify=True)
-    interface_count = LinkedCountColumn(
-        viewname="dcim:interface_list", url_params={"ip_addresses": "pk"}, verbose_name="Interfaces"
-    )
-    # TODO: what about interfaces assigned to modules?
-    interface_parent_count = LinkedCountColumn(
-        viewname="dcim:device_list",
-        url_params={"ip_addresses": "pk"},
-        reverse_lookup="interfaces__ip_addresses",
-        distinct=True,
-        verbose_name="Devices",
-    )
+    # Interface, Device, and VirtualMachine tables aren't currently filterable by IP address (?) so no LinkedCountColumn
+    interface_count = tables.Column(verbose_name="Interfaces")
+    interface_parent_count = tables.Column(verbose_name="Devices")
     vm_interface_count = LinkedCountColumn(
         viewname="virtualization:vminterface_list", url_params={"ip_addresses": "pk"}, verbose_name="VM Interfaces"
     )
-    vm_interface_parent_count = LinkedCountColumn(
-        viewname="virtualization:virtualmachine_list",
-        url_params={"ip_addresses": "pk"},
-        reverse_lookup="interfaces__ip_addresses",
-        distinct=True,
-        verbose_name="Virtual Machines",
-    )
+    vm_interface_parent_count = tables.Column(verbose_name="Virtual Machines")
 
     class Meta(BaseTable.Meta):
         model = IPAddress

nautobot/ipam/templates/ipam/ipaddress.html

@@ -83,7 +83,15 @@
                 <strong>Operational Details</strong>
             </div>
             <table class="table table-hover panel-body attr-table">
-                {% 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>Assignment</td>
                     <td>

nautobot/ipam/templates/ipam/ipaddress_bulk_add.html

@@ -21,6 +21,12 @@
             {% render_field model_form.description %}
         </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 model_form.tenant_group %}
+            {% render_field model_form.tenant %}
+        </div>
+    </div>
     {% include 'inc/extras_features_edit_form_fields.html' with form=model_form %}
 {% endblock %}

nautobot/ipam/templates/ipam/ipaddress_edit.html

@@ -22,7 +22,13 @@
             {% render_field form.description %}
         </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>
     <div class="panel panel-default">
         <div class="panel-heading"><strong>NAT IP (Inside)</strong></div>
         <div class="panel-body">

nautobot/ipam/templates/ipam/prefix.html

@@ -68,7 +68,15 @@
                             {{ object.get_type_display }}
                         </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>Locations</td>
                         <td>

nautobot/ipam/templates/ipam/prefix_edit.html

@@ -29,6 +29,12 @@
             {% render_field form.vlan %}
         </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/ipam/templates/ipam/vlan.html

@@ -44,7 +44,15 @@
                         <td>Name</td>
                         <td>{{ object.name }}</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>Status</td>
                         <td>

nautobot/ipam/templates/ipam/vlan_edit.html

@@ -19,6 +19,12 @@
             {% render_field form.vlan_group %}
         </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/ipam/templates/ipam/vrf_edit.html

@@ -37,6 +37,12 @@
             {% render_field form.export_targets %}
         </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 %}