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

nautobot/cloud/views.py

@@ -100,6 +100,16 @@ 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()
@@ -163,3 +173,9 @@ 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/fields.py

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

nautobot/core/api/filter_backends.py

@@ -2,8 +2,6 @@ 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."""
@@ -19,7 +17,15 @@ 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 NON_FILTER_QUERY_PARAMS:
+        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
+        ):
             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 not any(param["name"] == "depth" for param in operation["parameters"]):
+                if "depth" not in operation["parameters"]:
                     operation["parameters"].append(
                         {
                             "in": "query",
@@ -128,17 +128,6 @@ 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,7 +33,6 @@ 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
@@ -47,9 +46,8 @@ logger = logging.getLogger(__name__)
 
 class OptInFieldsMixin:
     """
-    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`.
+    A serializer mixin that takes an additional `opt_in_fields` argument that controls
+    which fields should be displayed.
     """
 
     def __init__(self, *args, **kwargs):
@@ -59,11 +57,8 @@ class OptInFieldsMixin:
     @property
     def fields(self):
         """
-        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.
+        Removes all serializer fields specified in a serializers `opt_in_fields` list that aren't specified in the
+        `include` query parameter.
 
         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
@@ -71,7 +66,12 @@ class OptInFieldsMixin:
         """
         if self.__pruned_fields is None:
             fields = dict(super().fields)
-            serializer_opt_in_fields = getattr(self.Meta, "opt_in_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
 
             if not hasattr(self, "_context"):
                 # We are being called before a request cycle
@@ -83,29 +83,24 @@ 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)))
 
-            # 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
+            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)
 
             self.__pruned_fields = fields
 
@@ -136,7 +131,6 @@ 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
@@ -531,27 +525,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, attrs):
+    def validate(self, data):
         # Remove custom fields data and tags (if any) prior to model validation
-        local_attrs = attrs.copy()
-        local_attrs.pop("custom_fields", None)
-        local_attrs.pop("relationships", None)
-        local_attrs.pop("tags", None)
+        attrs = data.copy()
+        attrs.pop("custom_fields", None)
+        attrs.pop("relationships", None)
+        attrs.pop("tags", None)
 
         # Skip ManyToManyFields
         for field in self.Meta.model._meta.get_fields():
             if isinstance(field, models.ManyToManyField):
-                local_attrs.pop(field.name, None)
+                attrs.pop(field.name, None)
 
         # Run clean() on an instance of the model
         if self.instance is None:
-            instance = self.Meta.model(**local_attrs)
+            instance = self.Meta.model(**attrs)
         else:
             instance = self.instance
-            for k, v in local_attrs.items():
+            for k, v in attrs.items():
                 setattr(instance, k, v)
         instance.full_clean()
-        return attrs
+        return data
 
 
 class WritableNestedSerializer(BaseModelSerializer):
@@ -597,7 +591,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 Group or Content-Type model
+            # PK is an int for this model. This is usually the User model
             try:
                 pk = int(data)
             except (TypeError, ValueError):

nautobot/core/api/views.py

@@ -7,11 +7,9 @@ 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 FieldDoesNotExist, ObjectDoesNotExist, ValidationError
+from django.core.exceptions import 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
@@ -25,7 +23,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, serializers as drf_serializers, status
+from rest_framework import routers, status
 from rest_framework.exceptions import APIException, ParseError, PermissionDenied
 from rest_framework.generics import GenericAPIView
 from rest_framework.permissions import IsAuthenticated
@@ -40,11 +38,9 @@ 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
 
@@ -236,53 +232,6 @@ 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.
@@ -421,7 +370,7 @@ class APIRootView(AuthenticatedAPIRootView):
     name = "API Root"
 
     @extend_schema(exclude=True)
-    def get(self, request, *args, format=None, **kwargs):  # pylint: disable=redefined-builtin
+    def get(self, request, format=None):  # pylint: disable=redefined-builtin
         return Response(
             OrderedDict(
                 (
@@ -628,13 +577,12 @@ class GraphQLDRFAPIView(NautobotAPIVersionMixin, APIView):
     middleware = None
     root_value = None
 
-    def __init__(self, schema=None, executor=None, middleware=None, root_value=None, backend=None, **kwargs):
+    def __init__(self, schema=None, executor=None, middleware=None, root_value=None, backend=None):
         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,10 +11,6 @@ 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:
@@ -28,6 +24,10 @@ 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):  # pylint:disable=super-init-not-called  # we must copy-and-paste from super
+    def __init__(self, model, app=None):
         """Initialize the model entry."""
         # copy-paste from django_celery_beat.schedulers
         self.app = app or current_app._get_current_object()

nautobot/core/choices.py

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

nautobot/core/events/__init__.py

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

nautobot/core/filters.py

@@ -618,7 +618,6 @@ class BaseFilterSet(django_filters.FilterSet):
     @staticmethod
     def _get_filter_lookup_dict(existing_filter):
         # Choose the lookup expression map based on the filter type
-
         if isinstance(
             existing_filter,
             (
@@ -638,7 +637,6 @@ class BaseFilterSet(django_filters.FilterSet):
             (
                 django_filters.ModelChoiceFilter,
                 django_filters.ModelMultipleChoiceFilter,
-                MultiValueUUIDFilter,
                 TagFilter,
                 TreeNodeMultipleChoiceFilter,
             ),
@@ -668,7 +666,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", "iexact"]:
+        if filter_field.method is not None or filter_field.lookup_expr not in ["exact", "in"]:
             return magic_filters
 
         # Choose the lookup expression map based on the filter type
@@ -679,7 +677,7 @@ class BaseFilterSet(django_filters.FilterSet):
 
         # Get properties of the existing filter for later use
         field_name = filter_field.field_name
-        field = get_model_field(cls._meta.model, field_name)  # pylint: disable=no-member
+        field = get_model_field(cls._meta.model, field_name)
 
         # If there isn't a model field, return.
         if field is None:
@@ -696,7 +694,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"}:  # pylint: disable=no-member
+                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
@@ -727,10 +725,7 @@ 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,  # pylint: disable=no-member
-                filter_field.field_name,
-                filter_field.lookup_expr,
-                filter_field.exclude,
+                cls.Meta.model, 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]
@@ -753,22 +748,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:  # pylint: disable=no-member
+        if new_filter_name in cls.base_filters:
             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  # pylint: disable=no-member
+        cls.base_filters[new_filter_name] = new_filter_field
         # django-filters has no concept of "abstract" filtersets, so we have to fake it
-        if cls._meta.model is not None:  # pylint: disable=no-member
-            cls.base_filters.update(  # pylint: disable=no-member
+        if cls._meta.model is not None:
+            cls.base_filters.update(
                 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):  # pylint: disable=no-member
+        if "id" not in fields and (cls._meta.exclude is None or "id" not in cls._meta.exclude):
             # Add "id" as the first key in the `fields` dict
             fields = {"id": [django_filters.conf.settings.DEFAULT_LOOKUP_EXPR], **fields}
         return fields
@@ -785,7 +780,7 @@ class BaseFilterSet(django_filters.FilterSet):
             if filter_name.startswith("_"):
                 del filters[filter_name]
 
-        if getattr(cls._meta.model, "is_contact_associable_model", False):  # pylint: disable=no-member
+        if getattr(cls._meta.model, "is_contact_associable_model", False):
             # Add "contacts" and "teams" filters
             from nautobot.extras.models import Contact, Team
 
@@ -805,13 +800,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):  # pylint: disable=no-member
-            if not hasattr(cls._meta.model, "static_group_association_set"):  # pylint: disable=no-member
+        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"):
                 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,  # pylint: disable=no-member
+                    cls._meta.model,
                 )
             else:
                 # Add "dynamic_groups" field as the last key
@@ -821,14 +816,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},  # pylint: disable=no-member
+                    query_params={"content_type": cls._meta.model._meta.label_lower},
                     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:  # pylint: disable=no-member
+        if cls._meta.model is not None:
             if "tags" in filters and isinstance(filters["tags"], TagFilter):
-                filters["tags"].extra["query_params"] = {"content_types": [cls._meta.model._meta.label_lower]}  # pylint: disable=no-member
+                filters["tags"].extra["query_params"] = {"content_types": [cls._meta.model._meta.label_lower]}
 
             new_filters = {}
             for existing_filter_name, existing_filter in filters.items():

nautobot/core/fixtures/user-data.json

@@ -0,0 +1,59 @@
+[
+    {
+        "model": "users.user",
+        "pk": "90798182-9d19-479a-899f-a415fc2c62fe",
+        "fields": {
+            "password": "pbkdf2_sha256$216000$TtNpNWboQq6C$6vh6qqRXUGSuLZlwvvGRbz35BS6avrdEFudnjJv2HXY=",
+            "last_login": null,
+            "is_superuser": false,
+            "username": "alice",
+            "first_name": "",
+            "last_name": "",
+            "email": "alice@localhost",
+            "is_staff": false,
+            "is_active": true,
+            "date_joined": "2021-05-25T23:49:55.008Z",
+            "config_data": {},
+            "groups": [],
+            "user_permissions": []
+        }
+    },
+    {
+        "model": "users.user",
+        "pk": "90798182-9d19-479a-899f-a415fc2c62fd",
+        "fields": {
+            "password": "pbkdf2_sha256$216000$TtNpNWboQq6C$6vh6qqRXUGSuLZlwvvGRbz35BS6avrdEFudnjJv2HXY=",
+            "last_login": null,
+            "is_superuser": true,
+            "username": "bob",
+            "first_name": "",
+            "last_name": "",
+            "email": "bob@localhost",
+            "is_staff": true,
+            "is_active": true,
+            "date_joined": "2021-05-25T23:49:55.008Z",
+            "config_data": {},
+            "groups": [],
+            "user_permissions": []
+        }
+    },
+    {
+        "model": "users.user",
+        "pk": "90798182-9d19-479a-899f-a415fc2c62ff",
+        "fields": {
+            "password": "pbkdf2_sha256$216000$TtNpNWboQq6C$6vh6qqRXUGSuLZlwvvGRbz35BS6avrdEFudnjJv2HXY=",
+            "last_login": null,
+            "is_superuser": false,
+            "username": "charlie",
+            "first_name": "",
+            "last_name": "",
+            "email": "charlie@localhost",
+            "is_staff": false,
+            "is_active": true,
+            "date_joined": "2021-05-25T23:49:55.008Z",
+            "config_data": {},
+            "groups": [],
+            "user_permissions": []
+        }
+    }
+]