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

nautobot/core/filters.py

@@ -13,6 +13,7 @@ from django_filters.constants import EMPTY_VALUES
 from django_filters.utils import get_model_field, label_for_filter, resolve_field, verbose_lookup_expr
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema_field
+import timezone_field
 
 from nautobot.core import constants, forms
 from nautobot.core.forms import widgets
@@ -612,12 +613,16 @@ class BaseFilterSet(django_filters.FilterSet):
             models.UUIDField: {"filter_class": MultiValueUUIDFilter},
             core_fields.MACAddressCharField: {"filter_class": MultiValueMACAddressFilter},
             core_fields.TagsField: {"filter_class": TagFilter},
+            timezone_field.TimeZoneField: {"filter_class": MultiValueCharFilter},
         }
     )
 
+    USE_CHAR_FILTER_FOR_LOOKUPS = [django_filters.MultipleChoiceFilter]
+
     @staticmethod
     def _get_filter_lookup_dict(existing_filter):
         # Choose the lookup expression map based on the filter type
+
         if isinstance(
             existing_filter,
             (
@@ -637,6 +642,7 @@ class BaseFilterSet(django_filters.FilterSet):
             (
                 django_filters.ModelChoiceFilter,
                 django_filters.ModelMultipleChoiceFilter,
+                MultiValueUUIDFilter,
                 TagFilter,
                 TreeNodeMultipleChoiceFilter,
             ),
@@ -666,7 +672,7 @@ class BaseFilterSet(django_filters.FilterSet):
         the form `<field_name>__<lookup_expr>`
         """
         magic_filters = {}
-        if filter_field.method is not None or filter_field.lookup_expr not in ["exact", "in"]:
+        if filter_field.method is not None or filter_field.lookup_expr not in ["exact", "in", "iexact"]:
             return magic_filters
 
         # Choose the lookup expression map based on the filter type
@@ -676,8 +682,7 @@ class BaseFilterSet(django_filters.FilterSet):
             return magic_filters
 
         # Get properties of the existing filter for later use
-        field_name = filter_field.field_name
-        field = get_model_field(cls._meta.model, field_name)
+        field = get_model_field(cls._meta.model, filter_field.field_name)  # pylint: disable=no-member
 
         # If there isn't a model field, return.
         if field is None:
@@ -694,25 +699,7 @@ class BaseFilterSet(django_filters.FilterSet):
             new_filter_name = f"{filter_name}__{lookup_name}"
 
             try:
-                if filter_name in cls.declared_filters and lookup_expr not in {"isnull"}:
-                    # The filter field has been explicitly defined on the filterset class so we must manually
-                    # create the new filter with the same type because there is no guarantee the defined type
-                    # is the same as the default type for the field. This does not apply if the filter
-                    # should retain the original lookup_expr type, such as `isnull` using a boolean field on a
-                    # char or date object.
-                    resolve_field(field, lookup_expr)  # Will raise FieldLookupError if the lookup is invalid
-                    new_filter = type(filter_field)(
-                        field_name=field_name,
-                        lookup_expr=lookup_expr,
-                        label=filter_field.label,
-                        exclude=filter_field.exclude,
-                        distinct=filter_field.distinct,
-                        **filter_field.extra,
-                    )
-                else:
-                    # The filter field is listed in Meta.fields so we can safely rely on default behavior
-                    # Will raise FieldLookupError if the lookup is invalid
-                    new_filter = cls.filter_for_field(field, field_name, lookup_expr)
+                new_filter = cls._get_new_filter(filter_field, field, filter_name, lookup_expr)
             except django_filters.exceptions.FieldLookupError:
                 # The filter could not be created because the lookup expression is not supported on the field
                 continue
@@ -725,7 +712,10 @@ class BaseFilterSet(django_filters.FilterSet):
             # If the base filter_field has a custom label, django_filters won't adjust it for the new_filter lookup,
             # so we have to do it.
             if filter_field.label and filter_field.label != label_for_filter(
-                cls.Meta.model, filter_field.field_name, filter_field.lookup_expr, filter_field.exclude
+                cls._meta.model,  # pylint: disable=no-member
+                filter_field.field_name,
+                filter_field.lookup_expr,
+                filter_field.exclude,
             ):
                 # Lightly adjusted from label_for_filter() implementation:
                 verbose_expression = ["exclude", filter_field.label] if new_filter.exclude else [filter_field.label]
@@ -738,6 +728,45 @@ class BaseFilterSet(django_filters.FilterSet):
 
         return magic_filters
 
+    @classmethod
+    def _should_use_char_filter_for_lookups(cls, filter_field):
+        return type(filter_field) in cls.USE_CHAR_FILTER_FOR_LOOKUPS
+
+    @classmethod
+    def _get_new_filter(cls, filter_field, field, filter_name, lookup_expr):
+        if cls._should_use_char_filter_for_lookups(filter_field):
+            # For some cases like `MultiValueChoiceFilter(django_filters.MultipleChoiceFilter)`
+            # we want to have choices field with no lookups and standard char field for lookups filtering.
+            # Using a `choice` field for lookups blocks us from using `__re`, `__iew` or other "partial" filters.
+            resolve_field(field, lookup_expr)  # Will raise FieldLookupError if the lookup is invalid
+            return MultiValueCharFilter(
+                field_name=filter_field.field_name,
+                lookup_expr=lookup_expr,
+                label=filter_field.label,
+                exclude=filter_field.exclude,
+                distinct=filter_field.distinct,
+            )
+
+        if filter_name in cls.declared_filters and lookup_expr not in {"isnull"}:  # pylint: disable=no-member
+            # The filter field has been explicitly defined on the filterset class so we must manually
+            # create the new filter with the same type because there is no guarantee the defined type
+            # is the same as the default type for the field. This does not apply if the filter
+            # should retain the original lookup_expr type, such as `isnull` using a boolean field on a
+            # char or date object.
+            resolve_field(field, lookup_expr)  # Will raise FieldLookupError if the lookup is invalid
+            return type(filter_field)(
+                field_name=filter_field.field_name,
+                lookup_expr=lookup_expr,
+                label=filter_field.label,
+                exclude=filter_field.exclude,
+                distinct=filter_field.distinct,
+                **filter_field.extra,
+            )
+
+        # The filter field is listed in Meta.fields so we can safely rely on default behavior
+        # Will raise FieldLookupError if the lookup is invalid
+        return cls.filter_for_field(field, filter_field.field_name, lookup_expr)
+
     @classmethod
     def add_filter(cls, new_filter_name, new_filter_field):
         """
@@ -748,22 +777,22 @@ class BaseFilterSet(django_filters.FilterSet):
         if not isinstance(new_filter_field, django_filters.Filter):
             raise TypeError(f"Tried to add filter ({new_filter_name}) which is not an instance of Django Filter")
 
-        if new_filter_name in cls.base_filters:
+        if new_filter_name in cls.base_filters:  # pylint: disable=no-member
             raise AttributeError(
                 f"There was a conflict with filter `{new_filter_name}`, the custom filter was ignored."
             )
 
-        cls.base_filters[new_filter_name] = new_filter_field
+        cls.base_filters[new_filter_name] = new_filter_field  # pylint: disable=no-member
         # django-filters has no concept of "abstract" filtersets, so we have to fake it
-        if cls._meta.model is not None:
-            cls.base_filters.update(
+        if cls._meta.model is not None:  # pylint: disable=no-member
+            cls.base_filters.update(  # pylint: disable=no-member
                 cls._generate_lookup_expression_filters(filter_name=new_filter_name, filter_field=new_filter_field)
             )
 
     @classmethod
     def get_fields(cls):
         fields = super().get_fields()
-        if "id" not in fields and (cls._meta.exclude is None or "id" not in cls._meta.exclude):
+        if "id" not in fields and (cls._meta.exclude is None or "id" not in cls._meta.exclude):  # pylint: disable=no-member
             # Add "id" as the first key in the `fields` dict
             fields = {"id": [django_filters.conf.settings.DEFAULT_LOOKUP_EXPR], **fields}
         return fields
@@ -780,7 +809,7 @@ class BaseFilterSet(django_filters.FilterSet):
             if filter_name.startswith("_"):
                 del filters[filter_name]
 
-        if getattr(cls._meta.model, "is_contact_associable_model", False):
+        if getattr(cls._meta.model, "is_contact_associable_model", False):  # pylint: disable=no-member
             # Add "contacts" and "teams" filters
             from nautobot.extras.models import Contact, Team
 
@@ -800,13 +829,13 @@ class BaseFilterSet(django_filters.FilterSet):
                     label="Teams (name or ID)",
                 )
 
-        if "dynamic_groups" not in filters and getattr(cls._meta.model, "is_dynamic_group_associable_model", False):
-            if not hasattr(cls._meta.model, "static_group_association_set"):
+        if "dynamic_groups" not in filters and getattr(cls._meta.model, "is_dynamic_group_associable_model", False):  # pylint: disable=no-member
+            if not hasattr(cls._meta.model, "static_group_association_set"):  # pylint: disable=no-member
                 logger.warning(
                     "Model %s has 'is_dynamic_group_associable_model = True' but lacks "
                     "a 'static_group_association_set' attribute. Perhaps this is due to it inheriting from "
                     "the deprecated DynamicGroupMixin class instead of the preferred DynamicGroupsModelMixin?",
-                    cls._meta.model,
+                    cls._meta.model,  # pylint: disable=no-member
                 )
             else:
                 # Add "dynamic_groups" field as the last key
@@ -816,14 +845,14 @@ class BaseFilterSet(django_filters.FilterSet):
                     queryset=DynamicGroup.objects.all(),
                     field_name="static_group_association_set__dynamic_group",
                     to_field_name="name",
-                    query_params={"content_type": cls._meta.model._meta.label_lower},
+                    query_params={"content_type": cls._meta.model._meta.label_lower},  # pylint: disable=no-member
                     label="Dynamic groups (name or ID)",
                 )
 
         # django-filters has no concept of "abstract" filtersets, so we have to fake it
-        if cls._meta.model is not None:
+        if cls._meta.model is not None:  # pylint: disable=no-member
             if "tags" in filters and isinstance(filters["tags"], TagFilter):
-                filters["tags"].extra["query_params"] = {"content_types": [cls._meta.model._meta.label_lower]}
+                filters["tags"].extra["query_params"] = {"content_types": [cls._meta.model._meta.label_lower]}  # pylint: disable=no-member
 
             new_filters = {}
             for existing_filter_name, existing_filter in filters.items():
@@ -845,7 +874,10 @@ class BaseFilterSet(django_filters.FilterSet):
         Note: Any CharField or IntegerField with choices set is a ChoiceField.
         """
         if lookup_type == "exact" and getattr(field, "choices", None):
+            if isinstance(field, timezone_field.TimeZoneField):
+                return django_filters.MultipleChoiceFilter, {"choices": ((str(v), n) for v, n in field.choices)}
             return django_filters.MultipleChoiceFilter, {"choices": field.choices}
+
         return super().filter_for_lookup(field, lookup_type)
 
     def __init__(self, data=None, queryset=None, *, request=None, prefix=None):

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

@@ -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",
@@ -102,13 +102,13 @@ class CSVFileField(django_forms.FileField):
                 "in double quotes."
             )
 
-    def to_python(self, file):
+    def to_python(self, data):
         """For parity with CSVDataField, this returns the CSV text rather than an UploadedFile object."""
-        if file is None:
+        if data is None:
             return None
 
-        file = super().to_python(file)
-        return file.read().decode("utf-8-sig").strip()
+        data = super().to_python(data)
+        return data.read().decode("utf-8-sig").strip()
 
 
 class CSVChoiceField(django_forms.ChoiceField):
@@ -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
 
@@ -819,7 +822,7 @@ class MultiMatchModelMultipleChoiceField(DynamicModelChoiceMixin, django_filters
         self.natural_key = kwargs.setdefault("to_field_name", "slug")
         super().__init__(*args, **kwargs)
 
-    def _check_values(self, values):
+    def _check_values(self, values):  # pylint:disable=arguments-renamed
         """
         This method overloads the grandparent method in `django.forms.models.ModelMultipleChoiceField`,
         re-using some of that method's existing logic and adding support for coupling this field with

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/graphql/types.py

@@ -10,7 +10,7 @@ class OptimizedNautobotObjectType(gql_optimizer.OptimizedDjangoObjectType):
     url = graphene.String()
 
     def resolve_url(self, info):
-        return self.get_absolute_url(api=True)
+        return self.get_absolute_url(api=True)  # pylint: disable=no-member
 
     class Meta:
         abstract = True

nautobot/core/jobs/__init__.py

@@ -4,7 +4,9 @@ from io import BytesIO
 
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
-from django.core.exceptions import PermissionDenied
+from django.core.exceptions import (
+    PermissionDenied,
+)
 from django.db import transaction
 from django.http import QueryDict
 from rest_framework import exceptions as drf_exceptions
@@ -15,6 +17,7 @@ from nautobot.core.api.renderers import NautobotCSVRenderer
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.celery import app, register_jobs
 from nautobot.core.exceptions import AbortTransaction
+from nautobot.core.jobs.bulk_actions import BulkDeleteObjects, BulkEditObjects
 from nautobot.core.jobs.cleanup import LogsCleanup
 from nautobot.core.jobs.groups import RefreshDynamicGroupCaches
 from nautobot.core.utils.lookup import get_filterset_for_model
@@ -25,7 +28,16 @@ from nautobot.extras.datasources import (
     refresh_datasource_content,
     refresh_job_code_from_repository,
 )
-from nautobot.extras.jobs import BooleanVar, ChoiceVar, FileVar, Job, ObjectVar, RunJobTaskFailed, StringVar, TextVar
+from nautobot.extras.jobs import (
+    BooleanVar,
+    ChoiceVar,
+    FileVar,
+    Job,
+    ObjectVar,
+    RunJobTaskFailed,
+    StringVar,
+    TextVar,
+)
 from nautobot.extras.models import ExportTemplate, GitRepository
 
 name = "System Jobs"
@@ -47,7 +59,7 @@ class GitRepositorySync(Job):
         description = "Clone and/or pull a Git repository, then refresh data sourced from this repository."
         has_sensitive_variables = False
 
-    def run(self, repository):
+    def run(self, repository):  # pylint:disable=arguments-differ
         job_result = self.job_result
         user = job_result.user
 
@@ -88,7 +100,7 @@ class GitRepositoryDryRun(Job):
         description = "Dry run of Git repository sync - will not update data sourced from this repository."
         has_sensitive_variables = False
 
-    def run(self, repository):
+    def run(self, repository):  # pylint:disable=arguments-differ
         job_result = self.job_result
         self.logger.info(f'Performing a Dry Run on Git repository "{repository.name}"...')
 
@@ -138,7 +150,7 @@ class ExportObjectList(Job):
         soft_time_limit = 1800
         time_limit = 2000
 
-    def run(self, *, content_type, query_string="", export_format="csv", export_template=None):
+    def run(self, *, content_type, query_string="", export_format="csv", export_template=None):  # pylint:disable=arguments-differ
         if not self.user.has_perm(f"{content_type.app_label}.view_{content_type.model}"):
             self.logger.error('User "%s" does not have permission to view %s objects', self.user, content_type.model)
             raise PermissionDenied("User does not have view permissions on the requested content-type")
@@ -286,7 +298,7 @@ class ImportObjects(Job):
                     self.logger.error("Row %d: `%s`: `%s`", row, field, err[0])
         return new_objs, validation_failed
 
-    def run(self, *, content_type, csv_data=None, csv_file=None, roll_back_if_error=False):
+    def run(self, *, content_type, csv_data=None, csv_file=None, roll_back_if_error=False):  # pylint:disable=arguments-differ
         if not self.user.has_perm(f"{content_type.app_label}.add_{content_type.model}"):
             self.logger.error('User "%s" does not have permission to create %s objects', self.user, content_type.model)
             raise PermissionDenied("User does not have create permissions on the requested content-type")
@@ -347,5 +359,14 @@ class ImportObjects(Job):
             raise RunJobTaskFailed("CSV import not fully successful, see logs")
 
 
-jobs = [ExportObjectList, GitRepositorySync, GitRepositoryDryRun, ImportObjects, LogsCleanup, RefreshDynamicGroupCaches]
+jobs = [
+    BulkDeleteObjects,
+    BulkEditObjects,
+    ExportObjectList,
+    GitRepositorySync,
+    GitRepositoryDryRun,
+    ImportObjects,
+    LogsCleanup,
+    RefreshDynamicGroupCaches,
+]
 register_jobs(*jobs)