nautobot 2.3.5__py3-none-any.whl → 2.3.6__py3-none-any.whl

nautobot/ipam/models.py

@@ -10,8 +10,9 @@ from django.utils.functional import cached_property
 import netaddr
 
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
+from nautobot.core.forms.utils import parse_numeric_range
 from nautobot.core.models import BaseManager, BaseModel
-from nautobot.core.models.fields import JSONArrayField
+from nautobot.core.models.fields import JSONArrayField, PositiveRangeNumberTextField
 from nautobot.core.models.generics import OrganizationalModel, PrimaryModel
 from nautobot.core.models.utils import array_to_string
 from nautobot.core.utils.data import UtilizationData
@@ -1274,11 +1275,14 @@ class IPAddressToInterface(BaseModel):
 
 
 @extras_features(
+    "custom_links",
     "custom_validators",
+    "export_templates",
     "graphql",
     "locations",
+    "webhooks",
 )
-class VLANGroup(OrganizationalModel):
+class VLANGroup(PrimaryModel):
     """
     A VLAN group is an arbitrary collection of VLANs within which VLAN IDs and names must be unique.
     """
@@ -1293,11 +1297,36 @@ class VLANGroup(OrganizationalModel):
     )
     description = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True)
 
+    range = PositiveRangeNumberTextField(
+        blank=False,
+        default="1-4094",
+        help_text="Permitted VID range(s) as comma-separated list, default '1-4094' if left blank.",
+        min_boundary=constants.VLAN_VID_MIN,
+        max_boundary=constants.VLAN_VID_MAX,
+    )
+
     class Meta:
         ordering = ("name",)
         verbose_name = "VLAN group"
         verbose_name_plural = "VLAN groups"
 
+    @property
+    def expanded_range(self):
+        """
+        Expand VLAN's range into a list of integers (VLAN IDs).
+        """
+        return parse_numeric_range(self.range)
+
+    @property
+    def available_vids(self):
+        """
+        Return all available VLAN IDs within this VLANGroup as a list.
+        """
+        used_ids = self.vlans.all().values_list("vid", flat=True)
+        available = sorted([vid for vid in self.expanded_range if vid not in used_ids])
+
+        return available
+
     def clean(self):
         super().clean()
 
@@ -1308,18 +1337,25 @@ class VLANGroup(OrganizationalModel):
                     {"location": f'VLAN groups may not associate to locations of type "{self.location.location_type}".'}
                 )
 
+        # Validate ranges for related VLANs.
+        _expanded_range = self.expanded_range
+        out_of_range_vids = [_vlan.vid for _vlan in self.vlans.all() if _vlan.vid not in _expanded_range]
+        if out_of_range_vids:
+            raise ValidationError(
+                {
+                    "range": f"VLAN group range may not be re-sized due to existing VLANs (IDs: {','.join(map(str, out_of_range_vids))})."
+                }
+            )
+
     def __str__(self):
         return self.name
 
     def get_next_available_vid(self):
         """
-        Return the first available VLAN ID (1-4094) in the group.
+        Return the first available VLAN ID in the group's range.
         """
-        vlan_ids = VLAN.objects.filter(vlan_group=self).values_list("vid", flat=True)
-        for i in range(1, 4095):
-            if i not in vlan_ids:
-                return i
-        return None
+        _available_vids = self.available_vids
+        return _available_vids[0] if _available_vids else None
 
 
 @extras_features(
@@ -1438,6 +1474,13 @@ class VLAN(PrimaryModel):
         # Return all VM interfaces assigned to this VLAN
         return VMInterface.objects.filter(Q(untagged_vlan_id=self.pk) | Q(tagged_vlans=self.pk)).distinct()
 
+    def clean(self):
+        super().clean()
+
+        # Validate Vlan Group Range
+        if self.vlan_group and self.vid not in self.vlan_group.expanded_range:
+            raise ValidationError({"vid": f"VLAN ID is not contained in VLAN Group range ({self.vlan_group.range})"})
+
 
 @extras_features("graphql")
 class VLANLocationAssignment(BaseModel):

nautobot/ipam/tables.py

@@ -161,9 +161,9 @@ VLAN_LINK = """
 {% url 'ipam:vlan_add' %}\
 ?vid={{ record.vid }}&vlan_group={{ vlan_group.pk }}\
 {% if vlan_group.location %}&location={{ vlan_group.location.pk }}{% endif %}\
-" class="btn btn-xs btn-success">{{ record.available }} VLAN{{ record.available|pluralize }} available</a>\
+" class="btn btn-xs btn-success">{{ record.available }} VLAN{{ record.available|pluralize }} available ({{ record.range }})</a>\
 {% else %}
-    {{ record.available }} VLAN{{ record.available|pluralize }} available
+    {{ record.available }} VLAN{{ record.available|pluralize }} available ({{ record.range }})
 {% endif %}
 """
 
@@ -665,8 +665,8 @@ class VLANGroupTable(BaseTable):
 
     class Meta(BaseTable.Meta):
         model = VLANGroup
-        fields = ("pk", "name", "location", "vlan_count", "description", "actions")
-        default_columns = ("pk", "name", "location", "vlan_count", "description", "actions")
+        fields = ("pk", "name", "location", "range", "vlan_count", "description", "actions")
+        default_columns = ("pk", "name", "range", "location", "vlan_count", "description", "actions")
 
 
 #

nautobot/ipam/templates/ipam/vlangroup.html

@@ -17,6 +17,10 @@
                     <td>Location</td>
                     <td>{% include 'dcim/inc/location_hierarchy.html' with location=object.location %}</td>
                 </tr>
+                <tr>
+                    <td>Range</td>
+                    <td>{{ object.range }}</td>
+                </tr>
                 <tr>
                     <td>VLANs</td>
                     <td>

nautobot/ipam/tests/test_api.py

@@ -991,6 +991,15 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         "description": "New description",
     }
 
+    @classmethod
+    def setUpTestData(cls):
+        cls.vlan_group = VLANGroup.objects.create(name="Test", range="5-10,15-20")
+        cls.default_status = Status.objects.first()
+        VLAN.objects.create(name="vlan_5", vid=5, status=cls.default_status, vlan_group=cls.vlan_group)
+        VLAN.objects.create(name="vlan_10", vid=10, status=cls.default_status, vlan_group=cls.vlan_group)
+        VLAN.objects.create(name="vlan_17", vid=17, status=cls.default_status, vlan_group=cls.vlan_group)
+        cls.unused_vids = [6, 7, 8, 9, 15, 16, 18, 19, 20]
+
     def get_deletable_object(self):
         return VLANGroup.objects.create(name="DELETE ME")
 
@@ -1002,6 +1011,171 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         ]
         return [vg.pk for vg in vlangroups]
 
+    def test_list_available_vlans(self):
+        """
+        Test retrieval of all available VLAN IDs within a VLANGroup.
+        """
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions("ipam.view_vlangroup")
+
+        # Retrieve all available VLAN IDs
+        response = self.client.get(url, **self.header)
+
+        self.assertEqual(response.data["results"], self.unused_vids)
+        self.assertEqual(response.data["count"], len(self.unused_vids))
+
+    def test_create_single_available_vlan(self):
+        """
+        Test creation of the first available VLAN within a VLANGroup.
+        """
+        cf = CustomField.objects.create(key="sor", label="Source of Record Field", type="text")
+        cf.content_types.add(ContentType.objects.get_for_model(VLAN))
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Create all nine available VLANs with individual requests
+        for unused_vid in self.unused_vids:
+            data = {
+                "name": f"VLAN_{unused_vid}",
+                "description": f"Test VLAN {unused_vid}",
+                "status": self.default_status.pk,
+                "custom_fields": {"sor": "Nautobot"},
+            }
+            response = self.client.post(url, data, format="json", **self.header)
+            self.assertHttpStatus(response, status.HTTP_201_CREATED)
+            self.assertEqual(response.data["results"]["name"], data["name"])
+            self.assertEqual(response.data["results"]["vid"], unused_vid)
+            self.assertEqual(response.data["results"]["description"], data["description"])
+            self.assertEqual(response.data["results"]["vlan_group"]["id"], self.vlan_group.pk)
+            self.assertIn("custom_fields", response.data["results"])
+            self.assertIn("sor", response.data["results"]["custom_fields"])
+            self.assertEqual("Nautobot", response.data["results"]["custom_fields"]["sor"])
+
+        # Try to create one more VLAN
+        response = self.client.post(
+            url, {"name": "UTILIZED_VLAN_GROUP", "status": self.default_status.pk}, format="json", **self.header
+        )
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+        self.assertIn(
+            f"An insufficient number of VLANs are available within the VLANGroup {self.vlan_group}",
+            response.data["detail"],
+        )
+
+    def test_create_multiple_available_vlans(self):
+        """
+        Test the creation of available VLANS within a VLANGroup.
+        """
+        cf = CustomField.objects.create(key="sor", label="Source of Record Field", type="text")
+        cf.content_types.add(ContentType.objects.get_for_model(VLAN))
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Try to create ten VLANs (only nine are available)
+        data = [  # First nine VLANs
+            {
+                "name": f"VLAN_{unused_vid}",
+                "description": f"Test VLAN {unused_vid}",
+                "status": self.default_status.pk,
+                "custom_fields": {"sor": "Nautobot"},
+            }
+            for unused_vid in self.unused_vids
+        ]
+        additional_vlan = [
+            {
+                "name": "VLAN_10",  # Out of range VLAN
+                "description": "Test VLAN 10",
+                "status": self.default_status.pk,
+                "custom_fields": {"sor": "Nautobot"},
+            }
+        ]
+        response = self.client.post(url, data + additional_vlan, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+
+        # Create all nine available VLANs in a single request
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data["results"]), 9)
+
+        for i, vlan_data in enumerate(data):
+            self.assertEqual(response.data["results"][i]["name"], vlan_data["name"])
+            self.assertEqual(response.data["results"][i]["vid"], int(vlan_data["name"].replace("VLAN_", "")))
+            self.assertEqual(response.data["results"][i]["description"], vlan_data["description"])
+            self.assertEqual(response.data["results"][i]["vlan_group"]["id"], self.vlan_group.pk)
+            self.assertIn("custom_fields", response.data["results"][i])
+            self.assertIn("sor", response.data["results"][i]["custom_fields"])
+            self.assertEqual("Nautobot", response.data["results"][i]["custom_fields"]["sor"])
+
+    def test_create_multiple_explicit_vlans(self):
+        """
+        Test the creation of available VLANS within a VLANGroup requesting explicit VLAN IDs.
+        """
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Try to create VLANs with specified VLAN IDs. Also, explicitly (and redundantly) specify a VLAN Group.
+        data = [
+            {"name": "VLAN_6", "status": self.default_status.pk, "vid": 6},
+            {"name": "VLAN_7", "status": self.default_status.pk, "vid": 7},
+            {"name": "VLAN_8", "status": self.default_status.pk},
+            {"name": "VLAN_9", "status": self.default_status.pk, "vid": 9, "vlan_group": self.vlan_group.pk},
+            {"name": "VLAN_15", "status": self.default_status.pk},
+            {"name": "VLAN_16", "status": self.default_status.pk, "vid": 16, "vlan_group": self.vlan_group.pk},
+        ]
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data["results"]), 6)
+
+        for i, vlan_data in enumerate(data):
+            self.assertEqual(response.data["results"][i]["name"], vlan_data["name"])
+            self.assertEqual(response.data["results"][i]["vid"], int(vlan_data["name"].replace("VLAN_", "")))
+            self.assertEqual(response.data["results"][i]["vlan_group"]["id"], self.vlan_group.pk)
+
+    def test_create_invalid_vlans(self):
+        """
+        Test the creation of VLANs using invalid requests.
+        """
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Try to create VLANs using same vid
+        data = [
+            {"name": "VLAN_6", "status": self.default_status.pk, "vid": 6},
+            {"name": "VLAN_7", "status": self.default_status.pk, "vid": 6},
+            {"name": "VLAN_8", "status": self.default_status.pk},
+        ]
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+        self.assertEqual("VLAN 6 is not available within the VLANGroup.", response.data["detail"])
+
+        # Try to create VLANs specifying other VLAN Group
+        some_other_vlan_group = VLANGroup.objects.create(name="VLAN Group 100-200", range="100-200")
+        data = [{"name": "VLAN_7", "status": self.default_status.pk, "vlan_group": some_other_vlan_group.pk}]
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+        self.assertEqual(
+            f"Invalid VLAN Group requested: {some_other_vlan_group}. Only VLAN Group {self.vlan_group} is permitted.",
+            response.data["detail"],
+        )
+
 
 class VLANTest(APIViewTestCases.APIViewTestCase):
     model = VLAN

nautobot/ipam/tests/test_models.py

@@ -1302,7 +1302,7 @@ class TestVLANGroup(ModelTestCases.BaseModelTestCase):
         self.assertIn(f'VLAN groups may not associate to locations of type "{location_type.name}"', str(cm.exception))
 
     def test_get_next_available_vid(self):
-        vlangroup = VLANGroup.objects.create(name="VLAN Group 1")
+        vlangroup = VLANGroup.objects.create(name="VLAN Group 1", range="1-6")
         status = Status.objects.get_for_model(VLAN).first()
         VLAN.objects.bulk_create(
             (
@@ -1316,6 +1316,40 @@ class TestVLANGroup(ModelTestCases.BaseModelTestCase):
 
         VLAN.objects.bulk_create((VLAN(name="VLAN 4", vid=4, vlan_group=vlangroup, status=status),))
         self.assertEqual(vlangroup.get_next_available_vid(), 6)
+        # Next out of range.
+        VLAN.objects.bulk_create((VLAN(name="VLAN 6", vid=6, vlan_group=vlangroup, status=status),))
+        self.assertEqual(vlangroup.get_next_available_vid(), None)
+
+    def test_range_resize(self):
+        vlangroup = VLANGroup.objects.create(name="VLAN Group 1", range="1-3")
+        status = Status.objects.get_for_model(VLAN).first()
+        VLAN.objects.bulk_create(
+            (
+                VLAN(name="VLAN 1", vid=1, vlan_group=vlangroup, status=status),
+                VLAN(name="VLAN 2", vid=2, vlan_group=vlangroup, status=status),
+                VLAN(name="VLAN 3", vid=3, vlan_group=vlangroup, status=status),
+            )
+        )
+        with self.assertRaises(ValidationError) as exc:
+            vlangroup.range = "1-2"
+            vlangroup.validated_save()
+        self.assertEqual(
+            str(exc.exception), "{'range': ['VLAN group range may not be re-sized due to existing VLANs (IDs: 3).']}"
+        )
+
+    def test_assign_vlan_out_of_range(self):
+        vlangroup = VLANGroup.objects.create(name="VLAN Group 1", range="1-2")
+        status = Status.objects.get_for_model(VLAN).first()
+        VLAN.objects.bulk_create(
+            (
+                VLAN(name="VLAN 1", vid=1, vlan_group=vlangroup, status=status),
+                VLAN(name="VLAN 2", vid=2, vlan_group=vlangroup, status=status),
+            )
+        )
+        with self.assertRaises(ValidationError) as exc:
+            vlan = VLAN(name="VLAN 3", vid=3, vlan_group=vlangroup, status=status)
+            vlan.validated_save()
+        self.assertEqual(str(exc.exception), "{'vid': ['VLAN ID is not contained in VLAN Group range (1-2)']}")
 
 
 class TestVLAN(ModelTestCases.BaseModelTestCase):

nautobot/ipam/tests/test_utils.py

@@ -0,0 +1,61 @@
+from django.test import TestCase
+
+from nautobot.core.forms.utils import parse_numeric_range
+from nautobot.extras.models import Status
+from nautobot.ipam.models import VLAN, VLANGroup
+from nautobot.ipam.utils import add_available_vlans
+
+
+class AddAvailableVlansTest(TestCase):
+    """Tests for add_available_vlans()."""
+
+    def test_add_available_vlans(self):
+        vlan_group = VLANGroup.objects.create(name="VLAN Group 1", range="100-105,110-112,115")
+        status = Status.objects.get_for_model(VLAN).first()
+        vlan_100 = {"vid": 100, "available": 2, "range": "100-101"}
+        vlan_102 = VLAN.objects.create(name="VLAN 102", vid=102, vlan_group=vlan_group, status=status)
+        vlan_103 = VLAN.objects.create(name="VLAN 103", vid=103, vlan_group=vlan_group, status=status)
+        vlan_104 = {"vid": 104, "available": 2, "range": "104-105"}
+        vlan_110 = VLAN.objects.create(name="VLAN 110", vid=110, vlan_group=vlan_group, status=status)
+        vlan_111 = VLAN.objects.create(name="VLAN 111", vid=111, vlan_group=vlan_group, status=status)
+        vlan_112 = {"vid": 112, "available": 1, "range": "112"}
+        vlan_115 = VLAN.objects.create(name="VLAN 115", vid=115, vlan_group=vlan_group, status=status)
+
+        self.assertEqual(
+            list(add_available_vlans(vlan_group=vlan_group, vlans=vlan_group.vlans.all())),
+            [vlan_100, vlan_102, vlan_103, vlan_104, vlan_110, vlan_111, vlan_112, vlan_115],
+        )
+
+
+class ParseNumericRangeTest(TestCase):
+    """Tests for add_available_vlans()."""
+
+    def test_parse(self):
+        self.assertEqual(parse_numeric_range(input_string="5"), [5])
+        self.assertEqual(parse_numeric_range(input_string="5-5"), [5])
+        self.assertEqual(parse_numeric_range(input_string="5-5,5,5"), [5])
+        self.assertEqual(parse_numeric_range(input_string="1-5"), [1, 2, 3, 4, 5])
+        self.assertEqual(parse_numeric_range(input_string="1,2,3,4,5"), [1, 2, 3, 4, 5])
+        self.assertEqual(parse_numeric_range(input_string="5,4,3,1,2"), [1, 2, 3, 4, 5])
+        self.assertEqual(parse_numeric_range(input_string="1-5,10"), [1, 2, 3, 4, 5, 10])
+        self.assertEqual(parse_numeric_range(input_string="1,5,10-11"), [1, 5, 10, 11])
+        self.assertEqual(parse_numeric_range(input_string="10-11,1,5"), [1, 5, 10, 11])
+        self.assertEqual(parse_numeric_range(input_string="a", base=16), [10])
+        self.assertEqual(parse_numeric_range(input_string="a,b", base=16), [10, 11])
+        self.assertEqual(parse_numeric_range(input_string="9-c,f", base=16), [9, 10, 11, 12, 15])
+        self.assertEqual(parse_numeric_range(input_string="15-19", base=16), [21, 22, 23, 24, 25])
+        self.assertEqual(parse_numeric_range(input_string="fa-ff", base=16), [250, 251, 252, 253, 254, 255])
+
+    def test_invalid_input(self):
+        invalid_inputs = [
+            [1, 2, 3],
+            None,
+            1,
+            "",
+            "3-",
+        ]
+
+        for x in invalid_inputs:
+            with self.assertRaises(TypeError) as exc:
+                parse_numeric_range(input_string=x)
+            self.assertEqual(str(exc.exception), "Input value must be a string using a range format.")

nautobot/ipam/tests/test_views.py

@@ -1031,6 +1031,8 @@ class VLANGroupTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
             "name": "VLAN Group X",
             "location": location.pk,
             "description": "A new VLAN group",
+            "range": "1-4094",
+            "tags": [t.pk for t in Tag.objects.get_for_model(VLANGroup)],
         }
 
     def get_deletable_object(self):

nautobot/ipam/utils/__init__.py

@@ -1,9 +1,9 @@
 from django.core.exceptions import ValidationError
 import netaddr
 
+from nautobot.core.forms.utils import compress_range
 from nautobot.dcim.models import Interface
 from nautobot.extras.models import RelationshipAssociation
-from nautobot.ipam.constants import VLAN_VID_MAX, VLAN_VID_MIN
 from nautobot.ipam.models import Prefix, VLAN
 from nautobot.ipam.querysets import IPAddressQuerySet
 from nautobot.virtualization.models import VMInterface
@@ -85,24 +85,17 @@ def add_available_vlans(vlan_group, vlans):
     """
     Create fake records for all gaps between used VLANs
     """
-    if not vlans:
-        return [{"vid": VLAN_VID_MIN, "available": VLAN_VID_MAX - VLAN_VID_MIN + 1}]
+    fake_vlans = [
+        {
+            "vid": t[0],
+            "available": t[1] - t[0] + 1,
+            "range": f"{t[0]}" if t[0] == t[1] else f"{t[0]}-{t[1]}",
+        }
+        for t in compress_range(vlan_group.available_vids)
+    ]
 
-    prev_vid = VLAN_VID_MAX
-    new_vlans = []
-    for vlan in vlans:
-        if vlan.vid - prev_vid > 1:
-            new_vlans.append({"vid": prev_vid + 1, "available": vlan.vid - prev_vid - 1})
-        prev_vid = vlan.vid
-
-    if vlans[0].vid > VLAN_VID_MIN:
-        new_vlans.append({"vid": VLAN_VID_MIN, "available": vlans[0].vid - VLAN_VID_MIN})
-    if prev_vid < VLAN_VID_MAX:
-        new_vlans.append({"vid": prev_vid + 1, "available": VLAN_VID_MAX - prev_vid})
-
-    vlans = list(vlans) + new_vlans
+    vlans = list(vlans) + fake_vlans
     vlans.sort(key=lambda v: v.vid if isinstance(v, VLAN) else v["vid"])
-
     return vlans
 
 

nautobot/ipam/views.py

@@ -1233,7 +1233,7 @@ class VLANGroupView(generic.ObjectView):
             .prefetch_related(Prefetch("prefixes", queryset=Prefix.objects.restrict(request.user)))
         )
         vlans_count = vlans.count()
-        vlans = add_available_vlans(instance, vlans)
+        vlans = add_available_vlans(vlan_group=instance, vlans=vlans)
 
         vlan_table = tables.VLANDetailTable(vlans)
         if request.user.has_perm("ipam.change_vlan") or request.user.has_perm("ipam.delete_vlan"):

nautobot/project-static/docs/code-reference/nautobot/apps/forms.html

@@ -13399,14 +13399,14 @@ are marked as not required.</p>
 
 
 <h2 id="nautobot.apps.forms.parse_numeric_range" class="doc doc-heading">
-            <code class="highlight language-python"><span class="n">nautobot</span><span class="o">.</span><span class="n">apps</span><span class="o">.</span><span class="n">forms</span><span class="o">.</span><span class="n">parse_numeric_range</span><span class="p">(</span><span class="n">string</span><span class="p">,</span> <span class="n">base</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span></code>
+            <code class="highlight language-python"><span class="n">nautobot</span><span class="o">.</span><span class="n">apps</span><span class="o">.</span><span class="n">forms</span><span class="o">.</span><span class="n">parse_numeric_range</span><span class="p">(</span><span class="n">input_string</span><span class="p">,</span> <span class="n">base</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span></code>
 
 <a href="#nautobot.apps.forms.parse_numeric_range" class="headerlink" title="Permanent link">&para;</a></h2>
 
 
     <div class="doc doc-contents ">
 
-      <p>Expand a numeric range (continuous or not) into a decimal or
+      <p>Expand a numeric range (continuous or not) into a sorted decimal or
 hexadecimal list, as specified by the base parameter
   '0-3,5' =&gt; [0, 1, 2, 3, 5]
   '2,8-b,d,f' =&gt; [2, 8, 9, a, b, d, f]</p>

nautobot/project-static/docs/development/apps/api/models/index.html

@@ -8689,11 +8689,11 @@
 </details>
 <details class="version-changed">
 <summary>Changed in version 2.3.0 — Support for Contact and Team assignment on OrganizationalModel and PrimaryModel only</summary>
-<p>Default support for Contact and Team assignment was removed from <code>django.db.models.Model</code> and <code>BaseModel</code>. The mixin class <code>ContactMixin</code> has been added to be used by <code>BaseModel</code> subclasses that want to be assignable to Contacts and Teams. All subclasses of <code>OrganizationalModel</code> and <code>PrimaryModel</code> include this mixin and therefore default to supporting Contact and Team assignment.</p>
+<p>Default support for Contact and Team assignment was removed from <code>django.db.models.Model</code> and <code>BaseModel</code>. The mixin class <code>ContactMixin</code> has been added to be used by <code>BaseModel</code> subclasses that want to be assignable to Contacts and Teams. All subclasses of <code>OrganizationalModel</code> and <code>PrimaryModel</code> include this mixin and therefore default to supporting Contact and Team assignment. Models can opt out of this feature by declaring the class attribute <code>is_contact_associable_model = False</code>.</p>
 </details>
 <details class="version-added">
 <summary>Added in version 2.3.0 — Support for Dynamic Groups and Saved Views on OrganizationalModel and PrimaryModel</summary>
-<p>Support for Dynamic Groups and Saved Views was added to <code>OrganizationalModel</code> and <code>PrimaryModel</code>. The mixin classes <code>DynamicGroupsModelMixin</code> and <code>SavedViewMixin</code> (included in both of those base classes) have been added to be used by <code>BaseModel</code> subclasses that want to be assignable to Dynamic Groups and/or to be Saved View capable.</p>
+<p>Support for Dynamic Groups and Saved Views was added to <code>OrganizationalModel</code> and <code>PrimaryModel</code>. The mixin classes <code>DynamicGroupsModelMixin</code> and <code>SavedViewMixin</code> (included in both of those base classes) have been added to be used by <code>BaseModel</code> subclasses that want to be assignable to Dynamic Groups and/or to be Saved View capable. Models can opt out of either of these features by declaring <code>is_dynamic_group_associable_model = False</code> and/or <code>is_saved_view_model = False</code> as applicable.</p>
 </details>
 <details class="version-changed">
 <summary>Changed in version 2.3.0 — Replacement of DynamicGroupMixin with DynamicGroupsModelMixin</summary>