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

nautobot/cloud/views.py

@@ -100,16 +100,6 @@ class CloudNetworkUIViewSet(NautobotUIViewSet):
 
         return context
 
-    def extra_post_save_action(self, obj, form):
-        if form.cleaned_data.get("add_prefixes", None):
-            obj.prefixes.add(*form.cleaned_data["add_prefixes"])
-        if form.cleaned_data.get("remove_prefixes", None):
-            obj.prefixes.remove(*form.cleaned_data["remove_prefixes"])
-        if form.cleaned_data.get("add_cloud_services", None):
-            obj.cloud_services.add(*form.cleaned_data["add_cloud_services"])
-        if form.cleaned_data.get("remove_cloud_services", None):
-            obj.cloud_services.remove(*form.cleaned_data["remove_cloud_services"])
-
 
 class CloudResourceTypeUIViewSet(NautobotUIViewSet):
     queryset = CloudResourceType.objects.all()
@@ -173,9 +163,3 @@ class CloudServiceUIViewSet(NautobotUIViewSet):
             )
 
         return context
-
-    def extra_post_save_action(self, obj, form):
-        if form.cleaned_data.get("add_cloud_networks", None):
-            obj.cloud_networks.add(*form.cleaned_data["add_cloud_networks"])
-        if form.cleaned_data.get("remove_cloud_networks", None):
-            obj.cloud_networks.remove(*form.cleaned_data["remove_cloud_networks"])

nautobot/core/api/constants.py

@@ -0,0 +1,11 @@
+# Query parameters that are *not* filterset filters
+NON_FILTER_QUERY_PARAMS = (
+    "api_version",  # used to select the Nautobot API version
+    "depth",  # nested levels of the serializers default to depth=0
+    "exclude_m2m",  # used to exclude many-to-many fields from the REST API
+    "format",  # "json" or "api", used in the interactive HTML REST API views
+    "include",  # used to include computed fields, relationships, config-contexts, etc. (excluded by default)
+    "limit",  # pagination
+    "offset",  # pagination
+    "sort",  # sorting of results
+)

nautobot/core/api/fields.py

@@ -53,10 +53,10 @@ class ChoiceField(serializers.Field):
                 data = ""
         return super().validate_empty_values(data)
 
-    def to_representation(self, obj):
-        if obj == "":
+    def to_representation(self, value):
+        if value == "":
             return None
-        return OrderedDict([("value", obj), ("label", self._choices[obj])])
+        return OrderedDict([("value", value), ("label", self._choices[value])])
 
     def to_internal_value(self, data):
         if data == "":
@@ -123,8 +123,8 @@ class ContentTypeField(RelatedField):
             self.fail("invalid")
         return None
 
-    def to_representation(self, obj):
-        return f"{obj.app_label}.{obj.model}"
+    def to_representation(self, value):
+        return f"{value.app_label}.{value.model}"
 
 
 class LaxURLField(URLField):

nautobot/core/api/filter_backends.py

@@ -2,6 +2,8 @@ from django_filters.rest_framework.backends import DjangoFilterBackend
 from rest_framework.filters import OrderingFilter
 from tree_queries.models import TreeNode
 
+from nautobot.core.api.constants import NON_FILTER_QUERY_PARAMS
+
 
 class NautobotFilterBackend(DjangoFilterBackend):
     """Custom filtering backend for use with django-rest-framework and django-filters."""
@@ -17,15 +19,7 @@ class NautobotFilterBackend(DjangoFilterBackend):
         # The default 'data' is a reference to request.GET, which is immutable; copies of this data are mutable
         data = kwargs["data"].copy()
 
-        for non_filter_param in (
-            "api_version",  # used to select the Nautobot API version
-            "depth",  # nested levels of the serializers default to depth=0
-            "format",  # "json" or "api", used in the interactive HTML REST API views
-            "include",  # used to include computed fields, relationships, config-contexts, etc. (excluded by default)
-            "limit",  # pagination
-            "offset",  # pagination
-            "sort",  # sorting of results
-        ):
+        for non_filter_param in NON_FILTER_QUERY_PARAMS:
             data.pop(non_filter_param, None)
 
         kwargs["data"] = data

nautobot/core/api/schema.py

@@ -112,13 +112,13 @@ class NautobotAutoSchema(AutoSchema):
                 "required": True,
             }
 
-        # Inject a custom description for the "id" parameter since ours has custom lookup behavior.
         if operation is not None and "parameters" in operation:
             for param in operation["parameters"]:
+                # Inject a custom description for the "id" parameter since ours has custom lookup behavior.
                 if param["name"] == "id" and "description" not in param:
                     param["description"] = "Unique object identifier, either a UUID primary key or a composite key."
             if self.method == "GET":
-                if "depth" not in operation["parameters"]:
+                if not any(param["name"] == "depth" for param in operation["parameters"]):
                     operation["parameters"].append(
                         {
                             "in": "query",
@@ -128,6 +128,17 @@ class NautobotAutoSchema(AutoSchema):
                             "schema": {"type": "integer", "minimum": 0, "maximum": 10, "default": 1},
                         }
                     )
+                if not any(param["name"] == "exclude_m2m" for param in operation["parameters"]):
+                    operation["parameters"].append(
+                        {
+                            "in": "query",
+                            "name": "exclude_m2m",
+                            "required": False,
+                            "description": "Exclude many-to-many fields from the response",
+                            "schema": {"type": "boolean", "default": False},
+                        }
+                    )
+                # TODO: add "include" parameter to the schema where relevant - nautobot/nautobot#685
         return operation
 
     def get_operation_id(self):

nautobot/core/api/serializers.py

@@ -33,6 +33,7 @@ from nautobot.core.api.utils import (
 from nautobot.core.models.fields import LaxURLField as LaxURLModelField
 from nautobot.core.models.managers import TagsManager
 from nautobot.core.models.utils import construct_composite_key, construct_natural_slug
+from nautobot.core.settings_funcs import is_truthy
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.core.utils.requests import normalize_querydict
 from nautobot.extras.api.customfields import CustomFieldDefaultValues, CustomFieldsDataField
@@ -46,8 +47,9 @@ logger = logging.getLogger(__name__)
 
 class OptInFieldsMixin:
     """
-    A serializer mixin that takes an additional `opt_in_fields` argument that controls
-    which fields should be displayed.
+    Serializer mixin that adjusts its fields based on the `include` and `exclude_m2m` query parameters in a request.
+
+    The serializer's `Meta.opt_in_fields` controls which fields are influenced by `include`.
     """
 
     def __init__(self, *args, **kwargs):
@@ -57,8 +59,11 @@ class OptInFieldsMixin:
     @property
     def fields(self):
         """
-        Removes all serializer fields specified in a serializers `opt_in_fields` list that aren't specified in the
-        `include` query parameter.
+        Dynamically adjust the dictionary of fields attributed to this serializer instance.
+
+        - Removes all serializer fields specified in `Meta.opt_in_fields` list that aren't specified in the
+          `include` query parameter. (applies to GET requests only)
+        - If the `exclude_m2m` query parameter is truthy, remove all many-to-many serializer fields for performance.
 
         As an example, if the serializer specifies that `opt_in_fields = ["computed_fields"]`
         but `computed_fields` is not specified in the `?include` query parameter, `computed_fields` will be popped
@@ -66,12 +71,7 @@ class OptInFieldsMixin:
         """
         if self.__pruned_fields is None:
             fields = dict(super().fields)
-            serializer_opt_in_fields = getattr(self.Meta, "opt_in_fields", None)
-
-            if not serializer_opt_in_fields:
-                # This serializer has no defined opt_in_fields, so we never need to go further than this
-                self.__pruned_fields = fields
-                return self.__pruned_fields
+            serializer_opt_in_fields = getattr(self.Meta, "opt_in_fields", [])
 
             if not hasattr(self, "_context"):
                 # We are being called before a request cycle
@@ -83,24 +83,29 @@ class OptInFieldsMixin:
                 # No available request?
                 return fields
 
-            # opt-in fields only applies on GET requests, for other methods we support these fields regardless
-            if request is not None and request.method != "GET":
-                return fields
-
             # NOTE: drf test framework builds a request object where the query
             # parameters are found under the GET attribute.
             params = normalize_querydict(getattr(request, "query_params", getattr(request, "GET", None)))
 
-            try:
-                user_opt_in_fields = params.get("include", [])
-            except AttributeError:
-                # include parameter was not specified
-                user_opt_in_fields = []
-
-            # Drop any fields that are not specified in the users opt in fields
-            for field in serializer_opt_in_fields:
-                if field not in user_opt_in_fields:
-                    fields.pop(field, None)
+            # opt-in fields only applies on GET requests, for other methods we support these fields regardless
+            if request is None or request.method == "GET":
+                try:
+                    user_opt_in_fields = params.get("include", [])
+                except AttributeError:
+                    # include parameter was not specified
+                    user_opt_in_fields = []
+
+                # Drop any fields that are not specified in the users opt in fields
+                for field in serializer_opt_in_fields:
+                    if field not in user_opt_in_fields:
+                        fields.pop(field, None)
+
+            # If exclude_m2m is present and truthy, mark any many-to-many fields as write-only so they
+            # don't get included in the response.
+            if is_truthy(params.get("exclude_m2m", "false")):
+                for field_instance in fields.values():
+                    if isinstance(field_instance, (serializers.ManyRelatedField, serializers.ListSerializer)):
+                        field_instance.write_only = True
 
             self.__pruned_fields = fields
 
@@ -131,6 +136,7 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
 
     serializer_related_field = NautobotHyperlinkedRelatedField
 
+    id = serializers.UUIDField(read_only=False, default=serializers.CreateOnlyDefault(uuid.uuid4))
     display = serializers.SerializerMethodField(read_only=True, help_text="Human friendly display value")
     object_type = ObjectTypeField()
     # composite_key = serializers.SerializerMethodField()  # TODO: Revisit if we reintroduce composite keys
@@ -525,27 +531,27 @@ class ValidatedModelSerializer(BaseModelSerializer):
     validation. (DRF does not do this by default; see https://github.com/encode/django-rest-framework/issues/3144)
     """
 
-    def validate(self, data):
+    def validate(self, attrs):
         # Remove custom fields data and tags (if any) prior to model validation
-        attrs = data.copy()
-        attrs.pop("custom_fields", None)
-        attrs.pop("relationships", None)
-        attrs.pop("tags", None)
+        local_attrs = attrs.copy()
+        local_attrs.pop("custom_fields", None)
+        local_attrs.pop("relationships", None)
+        local_attrs.pop("tags", None)
 
         # Skip ManyToManyFields
         for field in self.Meta.model._meta.get_fields():
             if isinstance(field, models.ManyToManyField):
-                attrs.pop(field.name, None)
+                local_attrs.pop(field.name, None)
 
         # Run clean() on an instance of the model
         if self.instance is None:
-            instance = self.Meta.model(**attrs)
+            instance = self.Meta.model(**local_attrs)
         else:
             instance = self.instance
-            for k, v in attrs.items():
+            for k, v in local_attrs.items():
                 setattr(instance, k, v)
         instance.full_clean()
-        return data
+        return attrs
 
 
 class WritableNestedSerializer(BaseModelSerializer):
@@ -591,7 +597,7 @@ class WritableNestedSerializer(BaseModelSerializer):
         pk = None
 
         if isinstance(self.Meta.model._meta.pk, models.AutoField):
-            # PK is an int for this model. This is usually the User model
+            # PK is an int for this model. This is usually the Group or Content-Type model
             try:
                 pk = int(data)
             except (TypeError, ValueError):

nautobot/core/api/views.py

@@ -7,9 +7,11 @@ from django import __version__ as DJANGO_VERSION, forms
 from django.apps import apps
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.core.exceptions import FieldDoesNotExist, ObjectDoesNotExist, ValidationError
 from django.db import transaction
 from django.db.models import ProtectedError
+from django.db.models.fields.related import ForeignKey, ManyToManyField, RelatedField
+from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel
 from django.http.response import HttpResponseBadRequest
 from django.shortcuts import get_object_or_404, redirect
 from drf_spectacular.plumbing import get_relative_url, set_query_parameters
@@ -23,7 +25,7 @@ from graphql.execution import ExecutionResult
 from graphql.execution.middleware import MiddlewareManager
 from graphql.type.schema import GraphQLSchema
 import redis.exceptions
-from rest_framework import routers, status
+from rest_framework import routers, serializers as drf_serializers, status
 from rest_framework.exceptions import APIException, ParseError, PermissionDenied
 from rest_framework.generics import GenericAPIView
 from rest_framework.permissions import IsAuthenticated
@@ -38,9 +40,11 @@ from nautobot.core.api.exceptions import SerializerNotFound
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.celery import app as celery_app
 from nautobot.core.exceptions import FilterSetFieldNotFound
+from nautobot.core.models.fields import TagsField
 from nautobot.core.utils.data import is_uuid, render_jinja2
 from nautobot.core.utils.filtering import get_all_lookup_expr_for_field, get_filterset_parameter_form_field
 from nautobot.core.utils.lookup import get_form_for_model
+from nautobot.core.utils.querysets import maybe_prefetch_related, maybe_select_related
 from nautobot.core.utils.requests import ensure_content_type_and_field_name_in_query_params
 from nautobot.core.views.utils import get_csv_form_fields_from_serializer_class
 
@@ -232,6 +236,53 @@ class ModelViewSetMixin:
 
         return context
 
+    def get_queryset(self):
+        """
+        Attempt to optimize the queryset based on the fields present in the associated serializer.
+
+        See similar logic in nautobot.core.tables.BaseTable.
+        """
+        queryset = super().get_queryset()
+        model = queryset.model
+        serializer = self.get_serializer()
+
+        select_fields = []
+        prefetch_fields = []
+
+        for field_instance in serializer.fields.values():
+            if field_instance.write_only:
+                continue
+            if field_instance.source == "*":
+                continue
+            if "." in field_instance.source:
+                # DRF uses `field.nested_field` instead of `field__nested_field`
+                # TODO: We don't currently attempt to optimize nested lookups.
+                continue
+            if isinstance(field_instance, (drf_serializers.ManyRelatedField, drf_serializers.ListSerializer)):
+                # ListSerializer with depth > 0, ManyRelatedField with depth 0
+                try:
+                    model_field = model._meta.get_field(field_instance.source)
+                except FieldDoesNotExist:
+                    continue
+                if isinstance(model_field, (ManyToManyField, ManyToManyRel, RelatedField, ManyToOneRel, TagsField)):
+                    prefetch_fields.append(field_instance.source)
+            elif isinstance(field_instance, (drf_serializers.RelatedField, drf_serializers.Serializer)):
+                # Serializer with depth > 0, RelatedField with depth 0
+                try:
+                    model_field = model._meta.get_field(field_instance.source)
+                except FieldDoesNotExist:
+                    continue
+                if isinstance(model_field, ForeignKey):
+                    select_fields.append(field_instance.source)
+
+        if select_fields:
+            queryset = maybe_select_related(queryset, select_fields)
+
+        if prefetch_fields:
+            queryset = maybe_prefetch_related(queryset, prefetch_fields)
+
+        return queryset
+
     def restrict_queryset(self, request, *args, **kwargs):
         """
         Restrict the view's queryset to allow only the permitted objects for the given request.
@@ -370,7 +421,7 @@ class APIRootView(AuthenticatedAPIRootView):
     name = "API Root"
 
     @extend_schema(exclude=True)
-    def get(self, request, format=None):  # pylint: disable=redefined-builtin
+    def get(self, request, *args, format=None, **kwargs):  # pylint: disable=redefined-builtin
         return Response(
             OrderedDict(
                 (
@@ -577,12 +628,13 @@ class GraphQLDRFAPIView(NautobotAPIVersionMixin, APIView):
     middleware = None
     root_value = None
 
-    def __init__(self, schema=None, executor=None, middleware=None, root_value=None, backend=None):
+    def __init__(self, schema=None, executor=None, middleware=None, root_value=None, backend=None, **kwargs):
         self.schema = schema
         self.executor = executor
         self.middleware = middleware
         self.root_value = root_value
         self.backend = backend
+        super().__init__(**kwargs)
 
     def get_root_value(self, request):
         return self.root_value

nautobot/core/celery/log.py

@@ -11,6 +11,10 @@ class NautobotDatabaseHandler(logging.Handler):
         if current_task is None:
             return
 
+        # Skip recording the log entry if it has been marked as such
+        if getattr(record, "skip_db_logging", False):
+            return
+
         from nautobot.extras.models.jobs import JobResult
 
         try:
@@ -24,10 +28,6 @@ class NautobotDatabaseHandler(logging.Handler):
                 # JobResult.DoesNotExist - because we might not have a JobResult with that ID
                 return
 
-            # Skip recording the log entry if it has been marked as such
-            if getattr(record, "skip_db_logging", False):
-                return
-
             job_result.log(
                 message=record.message,
                 level_choice=record.levelname.lower(),

nautobot/core/celery/schedulers.py

@@ -25,7 +25,7 @@ class NautobotScheduleEntry(ModelEntry):
     nautobot.extras.models.ScheduledJob model
     """
 
-    def __init__(self, model, app=None):
+    def __init__(self, model, app=None):  # pylint:disable=super-init-not-called  # we must copy-and-paste from super
         """Initialize the model entry."""
         # copy-paste from django_celery_beat.schedulers
         self.app = app or current_app._get_current_object()
@@ -128,7 +128,7 @@ class NautobotDatabaseScheduler(DatabaseScheduler):
                 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:
+                if job_queue is not None and job_queue.queue_type == JobQueueTypeChoices.TYPE_KUBERNETES:
                     job_result = JobResult.objects.create(
                         name=scheduled_job.job_model.name,
                         job_model=scheduled_job.job_model,

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/events/__init__.py

@@ -107,10 +107,10 @@ def publish_event(*, topic, payload):
 
 
 __all__ = (
-    "deregister_event_broker",
     "EventBroker",
-    "publish_event",
     "RedisEventBroker",
-    "register_event_broker",
     "SyslogEventBroker",
+    "deregister_event_broker",
+    "publish_event",
+    "register_event_broker",
 )