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

nautobot/core/api/utils.py

@@ -116,7 +116,7 @@ def get_serializer_for_model(model, prefix=""):
         return dynamic_import(serializer_name)
     except AttributeError as exc:
         raise exceptions.SerializerNotFound(
-            f"Could not determine serializer for {app_label}.{model_name} with prefix '{prefix}'"
+            f"Serializer for {app_label}.{model_name} not found, expected it at {serializer_name}"
         ) from exc
 
 
@@ -129,16 +129,26 @@ def nested_serializers_for_models(models, prefix=""):
 
     Used exclusively in OpenAPI schema generation.
     """
+    from nautobot.core.api.serializers import BaseModelSerializer  # avoid circular import
+
     serializer_classes = []
     for model in models:
         try:
             serializer_classes.append(get_serializer_for_model(model, prefix=prefix))
         except exceptions.SerializerNotFound as exc:
-            logger.error("%s", exc)
+            logger.warning("%s", exc)
             continue
 
     nested_serializer_classes = []
     for serializer_class in serializer_classes:
+        if not issubclass(serializer_class, BaseModelSerializer):
+            logger.warning(
+                "Serializer class %s.%s does not inherit from nautobot.apps.api.BaseModelSerializer. "
+                "This should probably be corrected.",
+                serializer_class.__module__,
+                serializer_class.__name__,
+            )
+            continue
         nested_serializer_name = f"Nested{serializer_class.__name__}"
         if nested_serializer_name in NESTED_SERIALIZER_CACHE:
             nested_serializer_classes.append(NESTED_SERIALIZER_CACHE[nested_serializer_name])

nautobot/core/forms/fields.py

@@ -719,8 +719,11 @@ class NumericArrayField(SimpleArrayField):
 
     def to_python(self, value):
         try:
-            value = ",".join([str(n) for n in forms.parse_numeric_range(value)])
-        except ValueError as error:
+            if not value:
+                value = ""
+            else:
+                value = ",".join([str(n) for n in forms.parse_numeric_range(value)])
+        except (TypeError, ValueError) as error:
             raise ValidationError(error)
         return super().to_python(value)
 

nautobot/core/forms/utils.py

@@ -1,3 +1,4 @@
+from itertools import groupby
 import re
 
 from django import forms as django_forms
@@ -18,24 +19,31 @@ __all__ = (
 )
 
 
-def parse_numeric_range(string, base=10):
+def parse_numeric_range(input_string, base=10):
     """
-    Expand a numeric range (continuous or not) into a decimal or
+    Expand a numeric range (continuous or not) into a sorted decimal or
     hexadecimal list, as specified by the base parameter
       '0-3,5' => [0, 1, 2, 3, 5]
       '2,8-b,d,f' => [2, 8, 9, a, b, d, f]
     """
+    if base not in [10, 16]:
+        raise TypeError("Invalid base value.")
+
+    if not isinstance(input_string, str) or not input_string:
+        raise TypeError("Input value must be a string using a range format.")
+
     values = []
-    if not string:
-        return values
-    for dash_range in string.split(","):
+
+    for dash_range in input_string.split(","):
         try:
             begin, end = dash_range.split("-")
+            if begin == "" or end == "":
+                raise TypeError("Input value must be a string using a range format.")
         except ValueError:
             begin, end = dash_range, dash_range
         begin, end = int(begin.strip(), base=base), int(end.strip(), base=base) + 1
         values.extend(range(begin, end))
-    return list(set(values))
+    return sorted(list(set(values)))
 
 
 def parse_alphanumeric_range(string):
@@ -150,3 +158,20 @@ def add_field_to_filter_form_class(form_class, field_name, field_obj):
             f"There was a conflict with filter form field `{field_name}`, the custom filter form field was ignored."
         )
     form_class.base_fields[field_name] = field_obj
+
+
+def compress_range(iterable):
+    """
+    Generates compressed range from an un-sorted expanded range.
+    For example:
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101, 102, 103, 104, 105, 1000, 1100, 1101, 1102, 1103, 1104, 1105, 1106]
+        =>
+        iter1: (1, 10)
+        iter2: (100, 105)
+        iter3: (1000, 1000)
+        iter4: (1100, 1106)
+    """
+    iterable = sorted(set(iterable))
+    for _, grp in groupby(enumerate(iterable), lambda t: t[1] - t[0]):
+        grp = list(grp)
+        yield grp[0][1], grp[-1][1]

nautobot/core/models/fields.py

@@ -4,6 +4,7 @@ import re
 from django.core import exceptions
 from django.core.validators import MaxLengthValidator, RegexValidator
 from django.db import models
+from django.forms import TextInput
 from django.utils.text import slugify
 from django_extensions.db.fields import AutoSlugField as _AutoSlugField
 from netaddr import AddrFormatError, EUI, mac_unix_expanded
@@ -11,6 +12,7 @@ from taggit.managers import TaggableManager
 
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.forms import fields, widgets
+from nautobot.core.forms.utils import compress_range, parse_numeric_range
 from nautobot.core.models import ordering
 from nautobot.core.models.managers import TagsManager
 from nautobot.core.models.validators import EnhancedURLValidator
@@ -415,3 +417,57 @@ class TagsField(TaggableManager):
         kwargs.setdefault("required", False)
         kwargs.setdefault("query_params", {"content_types": self.model._meta.label_lower})
         return super().formfield(form_class=form_class, **kwargs)
+
+
+class PositiveRangeNumberTextField(models.TextField):
+    default_error_messages = {
+        "invalid": "Invalid value. Specify a value using non-negative integers in a range format (i.e. '10-20').",
+    }
+
+    description = "A text based representation of positive number range."
+
+    def __init__(self, min_boundary=0, max_boundary=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.min_boundary = min_boundary
+        self.max_boundary = max_boundary
+
+    def to_python(self, value):
+        if value is None:
+            return None
+
+        try:
+            self.expanded = sorted(parse_numeric_range(value))
+        except (ValueError, AttributeError):
+            raise exceptions.ValidationError(
+                self.error_messages["invalid"],
+                code="invalid",
+                params={"value": value},
+            )
+
+        converted_ranges = compress_range(self.expanded)
+        normalized_range = ",".join([f"{x[0]}" if x[0] == x[1] else f"{x[0]}-{x[1]}" for x in converted_ranges])
+
+        return normalized_range
+
+    def validate(self, value, model_instance):
+        """
+        Validate `value` and raise ValidationError if necessary.
+        """
+        super().validate(value, model_instance)
+
+        if (self.min_boundary is not None and self.expanded[0] < self.min_boundary) or (
+            self.max_boundary is not None and self.expanded[-1] > self.max_boundary
+        ):
+            raise exceptions.ValidationError(
+                message=f"Invalid value. Specify a range value between {self.min_boundary}-{self.max_boundary or 'unlimited'}",
+                code="outofrange",
+                params={"value": value},
+            )
+
+    def formfield(self, **kwargs):
+        return super().formfield(
+            **{
+                "widget": TextInput,
+                **kwargs,
+            }
+        )

nautobot/core/tests/test_utils.py

@@ -11,6 +11,7 @@ from django.http import QueryDict
 from nautobot.circuits import models as circuits_models
 from nautobot.core import exceptions, forms, settings_funcs
 from nautobot.core.api import utils as api_utils
+from nautobot.core.forms.utils import compress_range
 from nautobot.core.models import fields as core_fields, utils as models_utils, validators
 from nautobot.core.testing import TestCase
 from nautobot.core.utils import data as data_utils, filtering, lookup, requests
@@ -365,6 +366,88 @@ class PrettyPrintQueryTest(TestCase):
                 self.assertEqual(models_utils.pretty_print_query(query), expected)
 
 
+class CompressRangeTest(TestCase):
+    """Tests for compress_range()."""
+
+    def test_compress_range_sparse(self):
+        values = [1500, 200, 10, 2222, 3000, 4096]
+        self.assertEqual(
+            list(compress_range(values)),
+            [
+                (10, 10),
+                (200, 200),
+                (1500, 1500),
+                (2222, 2222),
+                (3000, 3000),
+                (4096, 4096),
+            ],
+        )
+
+    def test_compress_range_dense(self):
+        values = [
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            100,
+            101,
+            102,
+            103,
+            104,
+            105,
+            1100,
+            1101,
+            1102,
+            1103,
+            1104,
+            1105,
+            1106,
+        ]
+        self.assertEqual(
+            list(compress_range(values)),
+            [(1, 10), (100, 105), (1100, 1106)],
+        )
+
+    def test_compress_range_complex(self):
+        values = [
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            100,
+            200,
+            210,
+            211,
+            212,
+            222,
+            500,
+            501,
+            502,
+            503,
+            600,
+        ]
+        self.assertEqual(
+            list(compress_range(values)),
+            [
+                (10, 15),
+                (100, 100),
+                (200, 200),
+                (210, 212),
+                (222, 222),
+                (500, 503),
+                (600, 600),
+            ],
+        )
+
+
 class SlugifyFunctionsTest(TestCase):
     """Test custom slugify functions."""
 

nautobot/dcim/tests/test_api.py

@@ -646,6 +646,7 @@ class RackTest(APIViewTestCases.APIViewTestCase):
         locations = Location.objects.filter(devices__isnull=False)[:2]
         for location in locations:
             location.location_type.content_types.add(ContentType.objects.get_for_model(RackGroup))
+            location.location_type.content_types.add(ContentType.objects.get_for_model(Rack))
 
         rack_groups = (
             RackGroup.objects.create(location=locations[0], name="Rack Group 1"),
@@ -685,7 +686,9 @@ class RackTest(APIViewTestCases.APIViewTestCase):
             status=statuses[0],
         )
         # Place a device in Rack 4
-        device = Device.objects.filter(location=populated_rack.location, rack=None).first()
+        device = Device.objects.filter(
+            location=populated_rack.location, rack__isnull=True, device_type__u_height__gt=0
+        ).first()
         device.rack = populated_rack
         device.face = "front"
         device.position = 10

nautobot/extras/factory.py

@@ -246,7 +246,8 @@ class MetadataTypeFactory(PrimaryModelFactory):
                         lambda: ContentType.objects.filter(
                             FeatureQuery("metadata").get_query(), pk__in=existing_content_type_pks
                         ),
-                        minimum=1,
+                        minimum=3,
+                        maximum=5,
                     )
                 )
 

nautobot/extras/models/models.py

@@ -575,6 +575,8 @@ class FileAttachment(BaseModel):
     filename = models.CharField(max_length=CHARFIELD_MAX_LENGTH)
     mimetype = models.CharField(max_length=CHARFIELD_MAX_LENGTH)
 
+    is_metadata_associable_model = False
+
     natural_key_field_names = ["pk"]
 
     def __str__(self):

nautobot/extras/tests/test_api.py

@@ -4080,14 +4080,14 @@ class TagTest(APIViewTestCases.APIViewTestCase):
     def test_create_tags_with_invalid_content_types(self):
         self.add_permissions("extras.add_tag")
 
-        # VLANGroup is an OrganizationalModel, not a PrimaryModel, and therefore does not support tags
-        data = {**self.create_data[0], "content_types": [VLANGroup._meta.label_lower]}
+        # Manufacturer is an OrganizationalModel, not a PrimaryModel, and therefore does not support tags
+        data = {**self.create_data[0], "content_types": [Manufacturer._meta.label_lower]}
         response = self.client.post(self._get_list_url(), data, format="json", **self.header)
 
         tag = Tag.objects.filter(name=data["name"])
         self.assertHttpStatus(response, 400)
         self.assertFalse(tag.exists())
-        self.assertIn(f"Invalid content type: {VLANGroup._meta.label_lower}", response.data["content_types"])
+        self.assertIn(f"Invalid content type: {Manufacturer._meta.label_lower}", response.data["content_types"])
 
     def test_create_tags_without_content_types(self):
         self.add_permissions("extras.add_tag")

nautobot/extras/tests/test_forms.py

@@ -388,6 +388,7 @@ class RelationshipModelFormTestCase(TestCase):
         cls.vlangroup_form_base_data = {
             "location": cls.location.pk,
             "name": "New VLAN Group",
+            "range": "1-4094",
         }
 
     def test_create_relationship_associations_valid_1(self):
@@ -665,6 +666,7 @@ class RelationshipModelFormTestCase(TestCase):
             data={
                 "name": self.vlangroup_1.name,
                 "location": self.location,
+                "range": "1-4094",
                 f"cr_{self.relationship_2.key}__source": self.device_2.pk,
             },
         )

nautobot/extras/tests/test_views.py

@@ -3595,11 +3595,11 @@ class TagTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
 
     def test_create_tags_with_invalid_content_types(self):
         self.add_permissions("extras.add_tag")
-        vlangroup_content_type = ContentType.objects.get_for_model(VLANGroup)
+        manufacturer_content_type = ContentType.objects.get_for_model(Manufacturer)
 
         form_data = {
             **self.form_data,
-            "content_types": [vlangroup_content_type.id],
+            "content_types": [manufacturer_content_type.id],
         }
 
         request = {

nautobot/ipam/api/serializers.py

@@ -118,7 +118,7 @@ class RIRSerializer(NautobotModelSerializer):
 #
 
 
-class VLANGroupSerializer(NautobotModelSerializer):
+class VLANGroupSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
     vlan_count = serializers.IntegerField(read_only=True)
 
     class Meta:
@@ -481,6 +481,35 @@ class IPAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin
         return super().validate(data)
 
 
+class VLANAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
+    """
+    Input serializer for POST to /api/ipam/vlan-groups/<id>/available-vlans/, i.e. allocating VLAN from VLANGroup.
+    """
+
+    vid = serializers.IntegerField(required=False, min_value=constants.VLAN_VID_MIN, max_value=constants.VLAN_VID_MAX)
+
+    def validate(self, data):
+        """Skip `ValidatedModel` validation.
+        This allows to skip `vid` attribute of `VLAN` model, while validate name and status.
+        """
+        return data
+
+    class Meta(VLANSerializer.Meta):
+        model = VLAN
+        fields = (
+            # permit "vid" and "vlan_group" for `VLAN` consistency.
+            # validate them under `VLANGroupViewSet`
+            "vid",
+            "vlan_group",
+            "name",
+            "status",
+            "role",
+            "tenant",
+            "description",
+            "custom_fields",
+        )
+
+
 #
 # IP address to interface
 #

nautobot/ipam/api/views.py

@@ -6,12 +6,15 @@ from rest_framework import status
 from rest_framework.decorators import action
 from rest_framework.exceptions import APIException
 from rest_framework.response import Response
+from rest_framework.serializers import IntegerField, ListSerializer
 
+from nautobot.core.api.authentication import TokenPermissions
 from nautobot.core.models.querysets import count_related
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.dcim.models import Location
 from nautobot.extras.api.views import NautobotModelViewSet
 from nautobot.ipam import filters
+from nautobot.ipam.api import serializers
 from nautobot.ipam.models import (
     IPAddress,
     IPAddressToInterface,
@@ -29,8 +32,6 @@ from nautobot.ipam.models import (
     VRFPrefixAssignment,
 )
 
-from . import serializers
-
 #
 # Namespace
 #
@@ -387,10 +388,171 @@ class IPAddressToInterfaceViewSet(NautobotModelViewSet):
 
 
 class VLANGroupViewSet(NautobotModelViewSet):
-    queryset = VLANGroup.objects.select_related("location").annotate(vlan_count=count_related(VLAN, "vlan_group"))
+    queryset = (
+        VLANGroup.objects.select_related("location")
+        .prefetch_related("tags")
+        .annotate(vlan_count=count_related(VLAN, "vlan_group"))
+    )
     serializer_class = serializers.VLANGroupSerializer
     filterset_class = filters.VLANGroupFilterSet
 
+    def restrict_queryset(self, request, *args, **kwargs):
+        """
+        Apply "view" permissions on the POST /available-vlans/ endpoint, otherwise as ModelViewSetMixin.
+        """
+        if request.user.is_authenticated and self.action == "available_vlans":
+            self.queryset = self.queryset.restrict(request.user, "view")
+        else:
+            super().restrict_queryset(request, *args, **kwargs)
+
+    class AvailableVLANPermissions(TokenPermissions):
+        """As nautobot.core.api.authentication.TokenPermissions, but enforcing add_vlan permission."""
+
+        perms_map = {
+            "GET": ["ipam.view_vlangroup"],
+            "POST": ["ipam.view_vlangroup", "ipam.add_vlan"],
+        }
+
+    @extend_schema(methods=["get"], responses={200: ListSerializer(child=IntegerField())})
+    @extend_schema(
+        methods=["post"],
+        responses={201: serializers.VLANSerializer(many=True)},
+        request=serializers.VLANAllocationSerializer(many=True),
+    )
+    @action(
+        detail=True,
+        name="Available VLAN IDs",
+        url_path="available-vlans",
+        methods=["get", "post"],
+        permission_classes=[AvailableVLANPermissions],
+        filterset_class=None,
+    )
+    def available_vlans(self, request, pk=None):
+        """
+        A convenience method for listing available VLAN IDs within a VLANGroup.
+        By default, the number of VIDs returned will be equivalent to PAGINATE_COUNT.
+        An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed, however results will not be paginated.
+        """
+        vlan_group = get_object_or_404(self.queryset, pk=pk)
+
+        if request.method == "POST":
+            with cache.lock(
+                "nautobot.ipam.api.views.available_vlans", blocking_timeout=5, timeout=settings.REDIS_LOCK_TIMEOUT
+            ):
+                # Normalize to a list of objects
+                serializer = serializers.VLANAllocationSerializer(
+                    data=request.data if isinstance(request.data, list) else [request.data],
+                    many=True,
+                    context={
+                        "request": request,
+                        "vlan_group": vlan_group,
+                    },
+                )
+                serializer.is_valid(raise_exception=True)
+                requested_vlans = serializer.validated_data
+
+                # Determine if the requested number of VLANs is available
+                available_vids = vlan_group.available_vids
+                if len(available_vids) < len(requested_vlans):
+                    return Response(
+                        {
+                            "detail": (
+                                f"An insufficient number of VLANs are available within the VLANGroup {vlan_group} "
+                                f"({len(requested_vlans)} requested, {len(available_vids)} available)"
+                            )
+                        },
+                        status=status.HTTP_204_NO_CONTENT,
+                    )
+
+                # Prioritise and check for explicitly requested VIDs. Remove them from available_vids
+                for requested_vlan in requested_vlans:
+                    # Check requested `vid` for availability.
+                    # This will also catch if same `vid` was requested multiple times in a request.
+                    if "vid" in requested_vlan and requested_vlan["vid"] not in available_vids:
+                        return Response(
+                            {"detail": f"VLAN {requested_vlan['vid']} is not available within the VLANGroup."},
+                            status=status.HTTP_204_NO_CONTENT,
+                        )
+                    elif "vid" in requested_vlan and requested_vlan["vid"] in available_vids:
+                        available_vids.remove(requested_vlan["vid"])
+
+                # Assign VLAN IDs from the list of VLANGroup's available VLAN IDs.
+                # Available_vids now does not contain explicitly requested vids.
+                _available_vids = iter(available_vids)
+
+                for requested_vlan in requested_vlans:
+                    if "vid" not in requested_vlan:
+                        requested_vlan["vid"] = next(_available_vids)
+
+                    # Check requested `vlan_group`
+                    if "vlan_group" in requested_vlan and requested_vlan["vlan_group"] != vlan_group:
+                        return Response(
+                            {
+                                "detail": f"Invalid VLAN Group requested: {requested_vlan['vlan_group']}. "
+                                f"Only VLAN Group {vlan_group} is permitted."
+                            },
+                            status=status.HTTP_204_NO_CONTENT,
+                        )
+                    else:
+                        requested_vlan["vlan_group"] = vlan_group.pk
+
+                    # Rewrite custom field data
+                    requested_vlan["custom_fields"] = requested_vlan.pop("_custom_field_data", {})
+
+                # Initialize the serializer with a list or a single object depending on what was requested
+                context = {"request": request, "depth": 0}
+
+                if isinstance(request.data, list):
+                    serializer = serializers.VLANSerializer(data=requested_vlans, many=True, context=context)
+                else:
+                    serializer = serializers.VLANSerializer(data=requested_vlans[0], context=context)
+
+                # Create the new VLANs
+                serializer.is_valid(raise_exception=True)
+                serializer.save()
+
+                data = serializer.data
+
+                return Response(
+                    data={
+                        "count": len(data),
+                        "next": None,
+                        "previous": None,
+                        "results": data,
+                    },
+                    status=status.HTTP_201_CREATED,
+                )
+
+        else:
+            try:
+                limit = int(request.query_params.get("limit", get_settings_or_config("PAGINATE_COUNT")))
+            except ValueError:
+                limit = get_settings_or_config("PAGINATE_COUNT")
+
+            if get_settings_or_config("MAX_PAGE_SIZE"):
+                limit = min(limit, get_settings_or_config("MAX_PAGE_SIZE"))
+
+            if isinstance(limit, int) and limit >= 0:
+                vids = vlan_group.available_vids[0:limit]
+            else:
+                vids = vlan_group.available_vids
+
+            serializer = ListSerializer(
+                child=IntegerField(),
+                data=vids,
+            )
+            serializer.is_valid(raise_exception=True)
+            data = serializer.validated_data
+
+            return Response(
+                {
+                    "count": len(data),
+                    "next": None,
+                    "previous": None,
+                    "results": data,
+                }
+            )
+
 
 #
 # VLANs

nautobot/ipam/filters.py

@@ -539,7 +539,7 @@ class IPAddressToInterfaceFilterSet(NautobotFilterSet):
 class VLANGroupFilterSet(NautobotFilterSet, LocatableModelFilterSetMixin, NameSearchFilterSet):
     class Meta:
         model = VLANGroup
-        fields = ["id", "name", "description"]
+        fields = ["id", "name", "description", "tags"]
 
 
 class VLANFilterSet(

nautobot/ipam/forms.py

@@ -727,7 +727,9 @@ class VLANGroupForm(LocatableModelFormMixin, NautobotModelForm):
         fields = [
             "location",
             "name",
+            "range",
             "description",
+            "tags",
         ]
 
 

nautobot/ipam/migrations/0050_vlangroup_range.py

@@ -0,0 +1,24 @@
+# Generated by Django 4.2.16 on 2024-10-02 17:14
+
+from django.db import migrations
+
+import nautobot.core.models.fields
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("ipam", "0049_vrf_data_migration"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="vlangroup",
+            name="range",
+            field=nautobot.core.models.fields.PositiveRangeNumberTextField(default="1-4094"),
+        ),
+        migrations.AddField(
+            model_name="vlangroup",
+            name="tags",
+            field=nautobot.core.models.fields.TagsField(through="extras.TaggedItem", to="extras.Tag"),
+        ),
+    ]