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

nautobot/core/celery/schedulers.py

@@ -1,14 +1,20 @@
 from collections.abc import Mapping
 from datetime import datetime, timedelta
+import json
 import logging
 from pathlib import Path
+import sys
 
 from celery import current_app
+from celery.beat import _evaluate_entry_args, _evaluate_entry_kwargs, reraise, SchedulingError
+from celery.result import AsyncResult
 from django.conf import settings
 from django_celery_beat.schedulers import DatabaseScheduler, ModelEntry
 from kombu.utils.json import loads
 
-from nautobot.extras.models import ScheduledJob, ScheduledJobs
+from nautobot.extras.choices import JobQueueTypeChoices
+from nautobot.extras.models import JobResult, ScheduledJob, ScheduledJobs
+from nautobot.extras.utils import run_kubernetes_job_and_return_job_result
 
 logger = logging.getLogger(__name__)
 
@@ -111,7 +117,46 @@ class NautobotDatabaseScheduler(DatabaseScheduler):
 
         Ref: https://github.com/celery/django-celery-beat/issues/558#issuecomment-1162730008
         """
-        resp = super().apply_async(entry, producer=producer, advance=advance, **kwargs)
+        resp = None
+        entry = self.reserve(entry) if advance else entry
+        task = self.app.tasks.get(entry.task)
+
+        try:
+            entry_args = _evaluate_entry_args(entry.args)
+            entry_kwargs = _evaluate_entry_kwargs(entry.kwargs)
+            if task:
+                scheduled_job = entry.model
+                job_queue = scheduled_job.job_queue
+                # Distinguish between Celery and Kubernetes job queues
+                if job_queue.queue_type == JobQueueTypeChoices.TYPE_KUBERNETES:
+                    job_result = JobResult.objects.create(
+                        name=scheduled_job.job_model.name,
+                        job_model=scheduled_job.job_model,
+                        scheduled_job=scheduled_job,
+                        user=scheduled_job.user,
+                        task_name=scheduled_job.job_model.class_path,
+                        celery_kwargs=entry.options,
+                    )
+                    job_result = run_kubernetes_job_and_return_job_result(
+                        job_queue, job_result, json.dumps(entry_kwargs)
+                    )
+                    # Return an AsyncResult object to mimic the behavior of Celery tasks after the job is finished by Kubernetes Job Pod.
+                    resp = AsyncResult(job_result.id)
+                else:
+                    resp = task.apply_async(entry_args, entry_kwargs, producer=producer, **entry.options)
+            else:
+                resp = self.send_task(entry.task, entry_args, entry_kwargs, producer=producer, **entry.options)
+        except Exception as exc:  # pylint: disable=broad-except
+            reraise(
+                SchedulingError,
+                SchedulingError(f"Couldn't apply scheduled task {entry.name}: {exc}"),
+                sys.exc_info()[2],
+            )
+        finally:
+            self._tasks_since_sync += 1
+            if self.should_sync():
+                self._do_sync()
+
         if entry.total_run_count != entry.model.total_run_count:
             entry.total_run_count = entry.model.total_run_count
             entry.model.save()

nautobot/core/choices.py

@@ -182,14 +182,14 @@ class ButtonActionColorChoices(ChoiceSet):
     Map standard button actions to Bootstrap color classes.
     """
 
-    ADD = "info"
+    ADD = "primary"
     CANCEL = "default"
     CLONE = "success"
     CONFIGURE = "default"
     CONNECT = "success"
     DEFAULT = "default"
     DELETE = "danger"
-    DISCONNECT = "info"
+    DISCONNECT = "danger"
     EDIT = "warning"
     EXPORT = "success"
     IMPORT = "primary"

nautobot/core/cli/__init__.py

@@ -13,6 +13,7 @@ from django.core.management import CommandError, CommandParser, execute_from_com
 from django.core.management.utils import get_random_secret_key
 from jinja2 import BaseLoader, Environment
 
+from nautobot.core.events import load_event_brokers
 from nautobot.core.settings_funcs import is_truthy
 from nautobot.extras.plugins.utils import load_plugins
 
@@ -44,6 +45,7 @@ def _preprocess_settings(settings, config_path):
     - Set up 'job_logs' database mirror
     - Handle our custom `STORAGE_BACKEND` setting.
     - Load plugins based on settings.PLUGINS (potentially affecting INSTALLED_APPS, MIDDLEWARE, and CONSTANCE_CONFIG)
+    - Load event brokers based on settings.EVENT_BROKERS
     """
     settings.SETTINGS_PATH = config_path
 
@@ -124,6 +126,12 @@ def _preprocess_settings(settings, config_path):
     # passed in.
     load_plugins(settings)
 
+    #
+    # Event Broker
+    #
+
+    load_event_brokers(settings.EVENT_BROKERS)
+
 
 def load_settings(config_path):
     """Load nautobot_config.py or its equivalent into memory as a `nautobot_config` pseudo-module."""

nautobot/core/constants.py

@@ -110,6 +110,10 @@ CONFIG_SETTING_SEPARATOR = ","
 
 CHARFIELD_MAX_LENGTH = 255
 
+# Default values for pagination settings.
+MAX_PAGE_SIZE_DEFAULT = 1000
+PAGINATE_COUNT_DEFAULT = 50
+
 # Models excluded from the global search list
 GLOBAL_SEARCH_EXCLUDE_LIST = [
     "anotherexamplemodel",
@@ -146,12 +150,15 @@ GLOBAL_SEARCH_EXCLUDE_LIST = [
     "interfaceredundancygroup",
     "interfaceredundancygroupassociation",
     "interfacetemplate",
+    "interfacevdcassignment",
     "inventoryitem",
     "ipaddresstointerface",
     "job",
     "jobbutton",
     "jobhook",
     "joblogentry",
+    "jobqueue",
+    "jobqueueassignment",
     "jobresult",
     "locationtype",
     "manufacturer",

nautobot/core/events/__init__.py

@@ -0,0 +1,116 @@
+"""Module providing for the publication of event notifications via mechanisms such as Redis, Kafka, syslog, etc."""
+
+import fnmatch
+import json
+import logging
+
+from django.utils.module_loading import import_string
+
+from nautobot.core.celery import NautobotKombuJSONEncoder
+from nautobot.core.events.exceptions import EventBrokerImproperlyConfigured, EventBrokerNotFound
+
+from .base import EventBroker
+from .redis_broker import RedisEventBroker
+from .syslog_broker import SyslogEventBroker
+
+_EVENT_BROKERS = []
+
+
+logger = logging.getLogger(__name__)
+
+
+def load_event_brokers(event_broker_configs):
+    """Process plugins and log errors if they can't be loaded."""
+    for broker_name, broker in event_broker_configs.items():
+        options = broker.get("OPTIONS", {})
+        topics = broker.get("TOPICS", {})
+        if not isinstance(topics, dict):
+            raise EventBrokerImproperlyConfigured(
+                f"{broker_name} Malformed Event Broker Settings: Expected `TOPICS` to be a 'dict', instead a '{type(topics).__name__}' was provided"
+            )
+        include_topics = topics.get("INCLUDE")
+        if include_topics and not isinstance(include_topics, (list, tuple)):
+            raise EventBrokerImproperlyConfigured(
+                f"{broker_name} Malformed Event Broker Settings: Expected `INCLUDE` to be a 'list' or 'tuple', instead a '{type(include_topics).__name__}' was provided"
+            )
+        exclude_topics = topics.get("EXCLUDE", [])
+        if exclude_topics and not isinstance(exclude_topics, (list, tuple)):
+            raise EventBrokerImproperlyConfigured(
+                f"{broker_name} Malformed Event Broker Settings: Expected `EXCLUDE` to be a 'list' or 'tuple', instead a '{type(exclude_topics).__name__}' was provided"
+            )
+        options.update({"include_topics": include_topics, "exclude_topics": exclude_topics})
+
+        try:
+            event_broker_class = import_string(broker["CLASS"])
+            if not issubclass(event_broker_class, EventBroker):
+                raise EventBrokerImproperlyConfigured(
+                    f"{broker_name} Malformed Event Broker Settings: Broker provided is not an EventBroker"
+                )
+            event_broker = event_broker_class(**options)
+            register_event_broker(event_broker)
+        except ImportError as err:
+            raise EventBrokerNotFound(f"Unable to import Event Broker {broker_name}.") from err
+
+
+def register_event_broker(event_broker):
+    """
+    Register an `EventBroker` instance for use by Nautobot.
+
+    The `publish_event()` API will publish events to each registered broker.
+    The expectation/intent here, at least initially, is that a given deployment will instantiate zero or more
+    EventBrokers, then call `register_event_broker()` for each one, as part of Nautobot initial startup.
+
+    Args:
+        event_broker (EventBroker): The initialized/configured EventBroker instance to register.
+    """
+    if event_broker not in _EVENT_BROKERS:
+        _EVENT_BROKERS.append(event_broker)
+        logger.debug("Registered %s as an event broker", event_broker)
+    else:
+        logger.warning("Tried to register event broker %s but it was already registered", event_broker)
+
+
+def deregister_event_broker(event_broker):
+    """
+    Deregister a previously registered `EventBroker` instance so that it no longer receives published events.
+    """
+    try:
+        _EVENT_BROKERS.remove(event_broker)
+        logger.debug("Deregistered event broker %s", event_broker)
+    except ValueError:
+        logger.warning("Tried to deregister event broker %s but it wasn't previously registered", event_broker)
+
+
+def is_topic_match(topic, patterns):
+    return any(fnmatch.fnmatch(topic, pattern) for pattern in patterns)
+
+
+def publish_event(*, topic, payload):
+    """Publish the given event payload to the given topic via all registered `EventBroker` instances.
+
+    Args:
+        topic (str): Topic identifier.
+            Convention is to use snake_case and use periods to delineate related groups of topics,
+            similar to Python logger naming. For example, you might use `nautobot.create.dcim.device`,
+            `nautobot.update.dcim.device`, `nautobot.delete.dcim.device`, `nautobot.create.dcim.interface`,
+            `nautobot.create.ipam.ipaddress`, etc.
+        payload (dict): JSON-serializable structured data to publish.
+            While not all EventBrokers may actually use JSON as their data format, it makes for a reasonable
+            lowest common denominator for serializability.
+    """
+    for event_broker in _EVENT_BROKERS:
+        exclude_topics = event_broker.exclude_topics
+        include_topics = event_broker.include_topics
+        if is_topic_match(topic, include_topics) and not is_topic_match(topic, exclude_topics):
+            serialized_payload = json.dumps(payload, cls=NautobotKombuJSONEncoder)
+            event_broker.publish(topic=topic, payload=serialized_payload)
+
+
+__all__ = (
+    "EventBroker",
+    "RedisEventBroker",
+    "SyslogEventBroker",
+    "deregister_event_broker",
+    "publish_event",
+    "register_event_broker",
+)

nautobot/core/events/base.py

@@ -0,0 +1,27 @@
+"""Base classes for Nautobot event notification framework."""
+
+from abc import ABC, abstractmethod
+
+
+class EventBroker(ABC):
+    """Abstract base class for concrete implementations of event brokers such as syslog, Redis, Kafka, etc."""
+
+    def __init__(self, *args, include_topics=None, exclude_topics=None, **kwargs) -> None:
+        self.include_topics = include_topics or ["*"]
+        self.exclude_topics = exclude_topics or []
+        super().__init__(*args, **kwargs)
+
+    @abstractmethod
+    def publish(self, *, topic, payload):
+        """
+        Possibly publish the given data `payload` to the given event `topic`.
+
+        Args:
+            topic (str): Topic identifier.
+                Convention is to use snake_case and use periods to delineate related groups of topics,
+                similar to Python logger naming. For example, you might receive topics such as `create.dcim.device`,
+                `update.dcim.device`, `delete.dcim.device`, `create.dcim.interface`, `create.ipam.ipaddress`, etc.
+            payload (dict): JSON-serializable structured data to publish.
+                While not all EventBrokers may actually use JSON as their data format, it makes for a reasonable
+                lowest common denominator for serializability.
+        """

nautobot/core/events/exceptions.py

@@ -0,0 +1,10 @@
+class EventBrokerError(Exception):
+    """Base exception for all event-broker-related errors."""
+
+
+class EventBrokerNotFound(EventBrokerError):
+    """Raised when a specified event broker module cannot be found."""
+
+
+class EventBrokerImproperlyConfigured(EventBrokerError):
+    """Raised when a event is not properly configured."""

nautobot/core/events/redis_broker.py

@@ -0,0 +1,48 @@
+"""Simple EventBroker for publishing events to Redis.
+
+To verify that an instance of this broker is working, you can do the following in `nautobot-server nbshell`:
+
+```python
+import json
+
+import redis
+
+
+connection = redis.StrictRedis(host="redis", port=6379, db=2, password="...", charset="utf-8", decode_responses=True)
+
+
+def listen():
+    sub = connection.pubsub()
+    sub.psubscribe("nautobot.*")
+    for message in sub.listen():
+        if message["type"] == "pmessage":
+            print(f"Got a pmessage on channel {message['channel']}")
+            print(json.dumps(json.loads(message["data"]), indent=2))
+
+
+listen()
+```
+
+Then perform any action that triggers an event, such as creating or updating a record through the Nautobot UI.
+"""
+
+import redis
+
+from .base import EventBroker
+
+
+class RedisEventBroker(EventBroker):
+    """EventBroker for publishing events to Redis."""
+
+    def __init__(self, *args, url, **kwargs):
+        """Initialize and configure a RedisEventBroker.
+
+        Args:
+            url (str): The Redis URL to connect to.
+        """
+        self.url = url
+        self.connection = redis.StrictRedis.from_url(self.url)
+        super().__init__(*args, **kwargs)
+
+    def publish(self, *, topic, payload):
+        self.connection.publish(topic, payload)

nautobot/core/events/syslog_broker.py

@@ -0,0 +1,19 @@
+"""Simple EventBroker that just emits syslogs."""
+
+import json
+import logging
+
+from .base import EventBroker
+
+
+class SyslogEventBroker(EventBroker):
+    def __init__(self, *args, level=logging.INFO, **kwargs):
+        """Initialize a SyslogEventBroker that emits logs at the given level."""
+        super().__init__(*args, **kwargs)
+        self.level = level
+
+    def publish(self, *, topic, payload):
+        logger = logging.getLogger(f"nautobot.events.{topic}")
+        # Add an indent of 4 to payload
+        payload = json.dumps(json.loads(payload), indent=4)
+        logger.log(self.level, "%s", payload)

nautobot/core/exceptions.py

@@ -33,9 +33,3 @@ class FilterSetFieldNotFound(Exception):
     """
     An exception indicating that a filterset field could not be found.
     """
-
-
-class ViewConfigException(Exception):
-    """
-    An exception indicating that a detail view config is invalid.
-    """

nautobot/core/forms/__init__.py

@@ -76,24 +76,21 @@ from nautobot.core.forms.widgets import (
 )
 
 __all__ = (
-    "add_blank_choice",
-    "add_field_to_filter_form_class",
-    "AddressFieldMixin",
     "ALPHANUMERIC_EXPANSION_PATTERN",
+    "BOOLEAN_CHOICES",
+    "BOOLEAN_WITH_BLANK_CHOICES",
+    "IP4_EXPANSION_PATTERN",
+    "IP6_EXPANSION_PATTERN",
+    "NUMERIC_EXPANSION_PATTERN",
     "APISelect",
     "APISelectMultiple",
+    "AddressFieldMixin",
     "AutoPositionField",
     "AutoPositionPatternField",
-    "BOOLEAN_CHOICES",
-    "BOOLEAN_WITH_BLANK_CHOICES",
     "BootstrapMixin",
     "BulkEditForm",
     "BulkEditNullBooleanSelect",
     "BulkRenameForm",
-    "ColorSelect",
-    "CommentField",
-    "ConfirmationForm",
-    "ContentTypeSelect",
     "CSVChoiceField",
     "CSVContentTypeField",
     "CSVDataField",
@@ -102,34 +99,29 @@ __all__ = (
     "CSVModelForm",
     "CSVMultipleChoiceField",
     "CSVMultipleContentTypeField",
+    "ColorSelect",
+    "CommentField",
+    "ConfirmationForm",
+    "ContentTypeSelect",
     "DatePicker",
     "DateTimePicker",
     "DynamicFilterForm",
     "DynamicModelChoiceField",
     "DynamicModelMultipleChoiceField",
-    "expand_alphanumeric_pattern",
-    "expand_ipaddress_pattern",
     "ExpandableIPAddressField",
     "ExpandableNameField",
-    "form_from_model",
     "ImportForm",
-    "IP4_EXPANSION_PATTERN",
-    "IP6_EXPANSION_PATTERN",
     "JSONArrayFormField",
     "JSONField",
     "LaxURLField",
     "MACAddressField",
     "MultiMatchModelMultipleChoiceField",
-    "MultipleContentTypeField",
     "MultiValueCharField",
     "MultiValueCharInput",
+    "MultipleContentTypeField",
     "NullableDateField",
-    "NUMERIC_EXPANSION_PATTERN",
     "NumericArrayField",
-    "parse_alphanumeric_range",
-    "parse_numeric_range",
     "PrefixFieldMixin",
-    "restrict_form_fields",
     "ReturnURLForm",
     "SearchForm",
     "SelectWithDisabled",
@@ -142,4 +134,12 @@ __all__ = (
     "TableConfigForm",
     "TagFilterField",
     "TimePicker",
+    "add_blank_choice",
+    "add_field_to_filter_form_class",
+    "expand_alphanumeric_pattern",
+    "expand_ipaddress_pattern",
+    "form_from_model",
+    "parse_alphanumeric_range",
+    "parse_numeric_range",
+    "restrict_form_fields",
 )

nautobot/core/forms/fields.py

@@ -8,7 +8,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.contrib.postgres.forms import SimpleArrayField
 from django.core.exceptions import MultipleObjectsReturned, ObjectDoesNotExist, ValidationError
 from django.db.models import Q
-from django.forms.fields import BoundField, InvalidJSONInput, JSONField as _JSONField
+from django.forms.fields import BoundField, CallableChoiceIterator, InvalidJSONInput, JSONField as _JSONField
 from django.templatetags.static import static
 from django.urls import reverse
 from django.utils.html import format_html
@@ -22,7 +22,6 @@ from nautobot.core.models import validators
 from nautobot.core.utils import data as data_utils, lookup
 
 __all__ = (
-    "CommentField",
     "CSVChoiceField",
     "CSVContentTypeField",
     "CSVDataField",
@@ -30,16 +29,17 @@ __all__ = (
     "CSVModelChoiceField",
     "CSVMultipleChoiceField",
     "CSVMultipleContentTypeField",
+    "CommentField",
     "DynamicModelChoiceField",
     "DynamicModelMultipleChoiceField",
     "ExpandableIPAddressField",
     "ExpandableNameField",
-    "JSONField",
     "JSONArrayFormField",
+    "JSONField",
     "LaxURLField",
     "MACAddressField",
-    "MultipleContentTypeField",
     "MultiMatchModelMultipleChoiceField",
+    "MultipleContentTypeField",
     "NumericArrayField",
     "SlugField",
     "TagFilterField",
@@ -504,6 +504,8 @@ class DynamicModelChoiceMixin:
     ):
         self.display_field = display_field
         self.query_params = query_params or {}
+        # Default to "exclude_m2m=true" for improved performance, if not otherwise specified
+        self.query_params.setdefault("exclude_m2m", "true")
         self.initial_params = initial_params or {}
         self.null_option = null_option
         self.disabled_indicator = disabled_indicator
@@ -536,9 +538,10 @@ class DynamicModelChoiceMixin:
         # Toggle depth
         attrs["data-depth"] = self.depth
 
-        # Attach any static query parameters
-        for key, value in self.query_params.items():
-            widget.add_query_param(key, value)
+        # Attach any static query parameters if supported
+        if isinstance(widget, widgets.APISelect) or hasattr(widget, "add_query_param"):
+            for key, value in self.query_params.items():
+                widget.add_query_param(key, value)
 
         return attrs
 
@@ -660,11 +663,29 @@ class JSONArrayFormField(django_forms.JSONField):
     and each Array element is validated by `base_field` validators.
     """
 
-    def __init__(self, base_field, *, delimiter=",", **kwargs):
+    def __init__(self, base_field, *, choices=None, delimiter=",", **kwargs):
+        self.has_choices = False
+        if choices:
+            self.choices = choices
+            self.widget = widgets.StaticSelect2Multiple(choices=choices)
+            self.has_choices = True
         self.base_field = base_field
         self.delimiter = delimiter
         super().__init__(**kwargs)
 
+    # TODO: change this when we upgrade to Django 5, it uses a getter/setter for choices
+    def _get_choices(self):
+        return getattr(self, "_choices", None)
+
+    def _set_choices(self, value):
+        if callable(value):
+            value = CallableChoiceIterator(value)
+        else:
+            value = list(value)
+        self._choices = self.widget.choices = value
+
+    choices = property(_get_choices, _set_choices)
+
     def clean(self, value):
         """
         Validate `value` and return its "cleaned" value as an appropriate
@@ -677,10 +698,21 @@ class JSONArrayFormField(django_forms.JSONField):
         """
         Return a string of this value.
         """
-        if isinstance(value, list):
+        if self.has_choices:
+            if isinstance(value, list):
+                return value
+            return [value]
+        elif isinstance(value, list):
             return self.delimiter.join(str(self.base_field.prepare_value(v)) for v in value)
         return value
 
+    def bound_data(self, data, initial):
+        if data is None:
+            return None
+        if isinstance(data, list):
+            data = json.dumps(data)
+        return super().bound_data(data, initial)
+
     def to_python(self, value):
         """
         Convert `value` into JSON, raising django.core.exceptions.ValidationError
@@ -718,9 +750,25 @@ class JSONArrayFormField(django_forms.JSONField):
                 self.base_field.validate(item)
             except ValidationError as error:
                 errors.append(error)
+            if self.has_choices and not self.valid_value(item):
+                errors.append(ValidationError(f"{item} is not a valid choice"))
         if errors:
             raise ValidationError(errors)
 
+    def valid_value(self, value):
+        """Check to see if the provided value is a valid choice."""
+        text_value = str(value)
+        for k, v in self.choices:
+            if isinstance(v, (list, tuple)):
+                # This is an optgroup, so look inside the group for options
+                for k2, _ in v:
+                    if value == k2 or text_value == str(k2):
+                        return True
+            else:
+                if value == k or text_value == str(k):
+                    return True
+        return False
+
     def run_validators(self, value):
         """
         Runs all validators against `value` and raise ValidationError if necessary.

nautobot/core/forms/forms.py

@@ -1,8 +1,11 @@
+import contextlib
 import json
 import logging
 import re
 
 from django import forms
+from django.core.exceptions import FieldDoesNotExist
+from django.db.models.fields.related import ManyToManyField
 from django.forms import formset_factory
 from django.urls import reverse
 import yaml
@@ -15,8 +18,8 @@ __all__ = (
     "BootstrapMixin",
     "BulkEditForm",
     "BulkRenameForm",
-    "ConfirmationForm",
     "CSVModelForm",
+    "ConfirmationForm",
     "DynamicFilterForm",
     "ImportForm",
     "PrefixFieldMixin",
@@ -124,7 +127,35 @@ class BulkEditForm(forms.Form):
 
         if edit_all:
             self.fields["pk"].required = False
-            self.fields["_all"] = forms.BooleanField(widget=forms.HiddenInput(), required=True, initial=True)
+            self.fields["_all"] = forms.BooleanField(widget=forms.HiddenInput(), required=False, initial=True)
+
+    def _save_m2m_fields(self, obj):
+        """Save M2M fields"""
+        from nautobot.core.models.fields import TagsField  # Avoid circular dependency
+
+        m2m_field_names = []
+        # Handle M2M Save
+        for key in self.cleaned_data.keys():
+            if key.startswith(("add_", "remove_")):
+                field_name = key.lstrip("add_")
+                if field_name in m2m_field_names:
+                    continue
+                with contextlib.suppress(FieldDoesNotExist):
+                    field = obj._meta.get_field(field_name)
+                    is_m2m_field = isinstance(field, (ManyToManyField, TagsField))
+                    if is_m2m_field:
+                        m2m_field_names.append(field_name)
+
+        for field_name in m2m_field_names:
+            m2m_field = getattr(obj, field_name)
+            if self.cleaned_data.get(f"add_{field_name}", None):
+                m2m_field.add(*self.cleaned_data[f"add_{field_name}"])
+            if self.cleaned_data.get(f"remove_{field_name}", None):
+                m2m_field.remove(*self.cleaned_data[f"remove_{field_name}"])
+
+    def post_save(self, obj):
+        """Post save action"""
+        self._save_m2m_fields(obj)
 
 
 class BulkRenameForm(forms.Form):

nautobot/core/forms/utils.py

@@ -43,7 +43,8 @@ def parse_numeric_range(input_string, base=10):
             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 sorted(list(set(values)))
+    # Remove duplicates and sort
+    return sorted(set(values))
 
 
 def parse_alphanumeric_range(string):