nautobot 2.2.1__tar.gz → 2.2.3__tar.gz

nautobot-2.2.3/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.1
+Name: nautobot
+Version: 2.2.3
+Summary: Source of truth and network automation platform.
+Home-page: https://nautobot.com
+License: Apache-2.0
+Keywords: Nautobot
+Author: Network to Code
+Author-email: opensource@networktocode.com
+Requires-Python: >=3.8,<3.12
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Provides-Extra: all
+Provides-Extra: ldap
+Provides-Extra: mysql
+Provides-Extra: napalm
+Provides-Extra: remote-storage
+Provides-Extra: sso
+Requires-Dist: Django (>=3.2.25,<3.3.0)
+Requires-Dist: GitPython (>=3.1.43,<3.2.0)
+Requires-Dist: Jinja2 (>=3.1.3,<3.2.0)
+Requires-Dist: Markdown (>=3.5.2,<3.6.0)
+Requires-Dist: MarkupSafe (>=2.1.5,<2.2.0)
+Requires-Dist: Pillow (>=10.3.0,<10.4.0)
+Requires-Dist: PyYAML (>=6.0,<6.1)
+Requires-Dist: celery (>=5.3.1,<5.4.0)
+Requires-Dist: django-ajax-tables (>=1.1.1,<1.2.0)
+Requires-Dist: django-auth-ldap (>=4.7.0,<4.8.0) ; extra == "all" or extra == "ldap"
+Requires-Dist: django-celery-beat (>=2.6.0,<2.7.0)
+Requires-Dist: django-celery-results (>=2.5.1,<2.6.0)
+Requires-Dist: django-constance[database] (>=2.9.1,<2.10.0)
+Requires-Dist: django-cors-headers (>=4.3.1,<4.4.0)
+Requires-Dist: django-db-file-storage (>=0.5.5,<0.6.0)
+Requires-Dist: django-extensions (>=3.2.3,<3.3.0)
+Requires-Dist: django-filter (>=23.5,<23.6)
+Requires-Dist: django-health-check (>=3.18.1,<3.19.0)
+Requires-Dist: django-jinja (>=2.11.0,<2.12.0)
+Requires-Dist: django-prometheus (>=2.3.1,<2.4.0)
+Requires-Dist: django-redis (>=5.4.0,<5.5.0)
+Requires-Dist: django-silk (>=5.1.0,<5.2.0)
+Requires-Dist: django-storages (>=1.14.2,<1.15.0) ; extra == "all" or extra == "remote-storage"
+Requires-Dist: django-tables2 (>=2.7.0,<2.8.0)
+Requires-Dist: django-taggit (>=4.0.0,<4.1.0)
+Requires-Dist: django-timezone-field (>=5.1,<5.2)
+Requires-Dist: django-tree-queries (>=0.17.0,<0.18.0)
+Requires-Dist: django-webserver (>=1.2.0,<1.3.0)
+Requires-Dist: djangorestframework (>=3.15.1,<3.16.0)
+Requires-Dist: drf-react-template-framework (>=0.0.17,<0.0.18)
+Requires-Dist: drf-spectacular[sidecar] (>=0.26.5,<0.27.0)
+Requires-Dist: emoji (>=2.11.0,<2.12.0)
+Requires-Dist: graphene-django (>=2.16.0,<2.17.0)
+Requires-Dist: graphene-django-optimizer (>=0.8.0,<0.9.0)
+Requires-Dist: jsonschema (>=4.7.0,<5.0.0)
+Requires-Dist: mysqlclient (>=2.2.3,<2.3.0) ; extra == "all" or extra == "mysql"
+Requires-Dist: napalm (>=4.1.0,<4.2.0) ; extra == "all" or extra == "napalm"
+Requires-Dist: netaddr (>=0.10.1,<0.11.0)
+Requires-Dist: netutils (>=1.6.0,<2.0.0)
+Requires-Dist: nh3 (>=0.2.15,<0.3.0)
+Requires-Dist: packaging (>=23.1)
+Requires-Dist: prometheus-client (>=0.20.0,<0.21.0)
+Requires-Dist: psycopg2-binary (>=2.9.9,<2.10.0)
+Requires-Dist: python-slugify (>=8.0.3,<8.1.0)
+Requires-Dist: pyuwsgi (>=2.0.23,<2.1.0)
+Requires-Dist: social-auth-app-django (>=5.4.1,<5.5.0)
+Requires-Dist: social-auth-core[saml] (>=4.5.3,<4.6.0) ; extra == "all" or extra == "sso"
+Requires-Dist: svgwrite (>=1.4.2,<1.5.0)
+Project-URL: Documentation, https://docs.nautobot.com
+Project-URL: Repository, https://github.com/nautobot/nautobot
+Description-Content-Type: text/markdown
+
+# Nautobot
+
+![Nautobot](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/nautobot_logo.svg "Nautobot logo")
+
+Nautobot is a Network Source of Truth and Network Automation Platform built as a web application atop the [Django](https://www.djangoproject.com/) Python framework with a
+[PostgreSQL](https://www.postgresql.org/) or [MySQL](https://www.mysql.com) database.
+
+## Key Use Cases
+
+**1. Flexible Source of Truth for Networking** - Nautobot core data models are used to define the intended state of network infrastructure enabling it as a Source of Truth. While a baseline set of models are provided (such as IP networks and addresses, devices and racks, circuits and cable, etc.) it is Nautobot's goal to offer maximum data model flexibility. This is enabled through features such as user-defined relationships, custom fields on any model, and data validation that permits users to codify everything from naming standards to having automated tests run before data can be populated into Nautobot.
+
+**2. Extensible Data Platform for Automation** - Nautobot has a rich feature set to seamlessly integrate with network automation solutions. Nautobot offers GraphQL and native Git integration along with REST APIs and webhooks. Git integration dynamically loads YAML data files as Nautobot config contexts. Nautobot also has an evolving plugin system that enables users to create custom models, APIs, and UI elements. The plugin system is also used to unify and aggregate disparate data sources creating a Single Source of Truth to streamline data management for network automation.
+
+**3. Platform for Network Automation Apps** - The Nautobot plugin system enables users to create Network Automation Apps. Apps can be as lightweight or robust as needed based on user needs. Using Nautobot for creating custom applications saves up to 70% development time by re-using features such as authentication, permissions, webhooks, GraphQL, change logging, etc. all while having access to the data already stored in Nautobot. Some production ready applications include:
+
+The complete documentation for Nautobot can be found at [Read the Docs](https://docs.nautobot.com/).
+
+Questions? Comments? Start by perusing our [GitHub discussions](https://github.com/nautobot/nautobot/discussions) for the topic you have in mind, or join the **#nautobot** channel on [Network to Code's Slack community](https://slack.networktocode.com/)!
+
+## Build Status
+
+| Branch      | Status |
+|-------------|------------|
+| **[main](https://github.com/nautobot/nautobot/tree/main)** | [![Build Status](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml/badge.svg?branch=main)](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml) |
+| **[develop](https://github.com/nautobot/nautobot/tree/develop)** | [![Build Status](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml/badge.svg?branch=develop)](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml) |
+| **[next](https://github.com/nautobot/nautobot/tree/next)** | [![Build Status](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml/badge.svg?branch=next)](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml) |
+
+## Screenshots
+
+![Gif of main page](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_mainpage.gif?raw=true "Main page")
+
+---
+
+![Gif of config contexts](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_config_context.gif?raw=true "Config Contexts")
+
+---
+
+![Gif of prefix hierarchy](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_prefix_hierarchy.gif?raw=true "Prefix hierarchy")
+
+---
+
+![Gif of GraphQL](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_graphql.gif?raw=true "GraphQL API")
+
+---
+
+![Gif of Modes](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_modes.gif?raw=true "Modes")
+
+## Installation
+
+Please see [the documentation](https://docs.nautobot.com/projects/core/en/stable/user-guide/administration/installation/) for instructions on installing Nautobot.
+
+## Application Stack
+
+Below is a simplified overview of the Nautobot application stack for reference:
+
+![Application stack diagram](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_application_stack_high_level.png "Application stack diagram")
+
+## Plugins and Extensibility
+
+Nautobot offers the ability to customize your setup to better align with your direct business needs. It does so through the use of various plugins that have been developed for network automation, and are designed to be used in environments where needed.
+
+There are many plugins available within the Nautobot Apps ecosystem. The below screenshots are an example of some popular ones that are currently available.
+
+### Plugin Screenshots
+
+#### Golden Config Plugin
+
+![Gif of golden config](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_golden_config.gif?raw=true "Golden config")
+
+#### ChatOps Plugin
+
+![Gif of chatops](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_chatops.gif?raw=true "ChatOps")
+
+#### Device Lifecycle Management Plugin
+
+![Gif of DLM](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_device_lifecycle_management.gif?raw=true "Device Lifecycle Management")
+
+## Providing Feedback
+
+The best platform for general feedback, assistance, and other discussion is our [GitHub discussions](https://github.com/nautobot/nautobot/discussions). To report a bug or request a specific feature, please open a GitHub issue using the [appropriate template](https://github.com/nautobot/nautobot/issues/new/choose).
+
+If you are interested in contributing to the development of Nautobot, please read our [contributing guide](https://docs.nautobot.com/projects/core/en/stable/development/core/#contributing) prior to beginning any work.
+
+## Related projects
+
+Please check out [the GitHub `nautobot` topic](https://github.com/topics/nautobot) for a list of relevant community projects.
+
+## Notices
+
+> Nautobot was initially developed as a fork of NetBox (v2.10.4).  NetBox was originally developed by Jeremy Stretch at DigitalOcean and the NetBox Community.
+

nautobot-2.2.3/nautobot/apps/jobs.py

@@ -0,0 +1,66 @@
+"""Nautobot Jobs API."""
+
+from nautobot.core.celery import register_jobs
+from nautobot.core.celery.encoders import NautobotKombuJSONEncoder
+from nautobot.core.jobs import GitRepositoryDryRun, GitRepositorySync
+from nautobot.extras.jobs import (
+    BaseJob,
+    BooleanVar,
+    ChoiceVar,
+    DatabaseFileField,
+    DryRunVar,
+    enqueue_job_hooks,
+    FileVar,
+    get_job,
+    get_jobs,
+    IntegerVar,
+    IPAddressVar,
+    IPAddressWithMaskVar,
+    IPNetworkVar,
+    is_job,
+    is_variable,
+    Job,
+    JobButtonReceiver,
+    JobHookReceiver,
+    JSONVar,
+    MultiChoiceVar,
+    MultiObjectVar,
+    ObjectVar,
+    RunJobTaskFailed,
+    ScriptVariable,
+    StringVar,
+    TextVar,
+)
+
+__all__ = (
+    "BaseJob",
+    "BooleanVar",
+    "ChoiceVar",
+    "DatabaseFileField",
+    "DryRunVar",
+    "enqueue_job_hooks",
+    "FileVar",
+    "get_job",
+    "get_jobs",
+    "GitRepositoryDryRun",
+    "GitRepositorySync",
+    "IntegerVar",
+    "IPAddressVar",
+    "IPAddressWithMaskVar",
+    "IPNetworkVar",
+    "is_job",
+    "is_variable",
+    "Job",
+    "JobButtonReceiver",
+    "JobHookReceiver",
+    "JSONVar",
+    "MultiChoiceVar",
+    "MultiObjectVar",
+    "NautobotKombuJSONEncoder",
+    "ObjectVar",
+    "register_jobs",
+    "RunJobTaskFailed",
+    "ScriptVariable",
+    "StringVar",
+    "TextVar",
+)

nautobot-2.2.3/nautobot/core/api/utils.py

@@ -0,0 +1,366 @@
+from collections import namedtuple
+import logging
+import platform
+import sys
+
+from django.apps import apps
+from django.conf import settings
+from django.http import JsonResponse
+from django.urls import reverse
+from rest_framework import serializers, status
+from rest_framework.utils import formatting
+from rest_framework.utils.field_mapping import get_nested_relation_kwargs
+from rest_framework.utils.model_meta import _get_to_field, RelationInfo
+
+from nautobot.core.api import exceptions
+
+logger = logging.getLogger(__name__)
+
+
+def dict_to_filter_params(d, prefix=""):
+    """
+    Translate a dictionary of attributes to a nested set of parameters suitable for QuerySet filtering. For example:
+
+        {
+            "name": "Foo",
+            "rack": {
+                "facility_id": "R101"
+            }
+        }
+
+    Becomes:
+
+        {
+            "name": "Foo",
+            "rack__facility_id": "R101"
+        }
+
+    And can be employed as filter parameters:
+
+        Device.objects.filter(**dict_to_filter(attrs_dict))
+    """
+    params = {}
+    for key, val in d.items():
+        k = prefix + key
+        if isinstance(val, dict):
+            params.update(dict_to_filter_params(val, k + "__"))
+        else:
+            params[k] = val
+    return params
+
+
+def dynamic_import(name):
+    """
+    Dynamically import a class from an absolute path string
+    """
+    components = name.split(".")
+    mod = __import__(components[0])
+    for comp in components[1:]:
+        mod = getattr(mod, comp)
+    return mod
+
+
+# namedtuple accepts versions(list of API versions) and serializer(Related Serializer for versions).
+SerializerForAPIVersions = namedtuple("SerializersVersions", ("versions", "serializer"))
+
+
+def get_api_version_serializer(serializer_choices, api_version):
+    """Returns the serializer of an api_version
+
+    Args:
+        serializer_choices (tuple): list of SerializerVersions
+        api_version (str): Request API version
+
+    Returns:
+        (Serializer): the serializer for the api_version if found in serializer_choices else None
+    """
+    for versions, serializer in serializer_choices:
+        if api_version in versions:
+            return serializer
+    return None
+
+
+def versioned_serializer_selector(obj, serializer_choices, default_serializer):
+    """Returns appropriate serializer class depending on request api_version, and swagger_fake_view
+
+    Args:
+        obj (ViewSet instance):
+        serializer_choices (tuple): Tuple of SerializerVersions
+        default_serializer (Serializer): Default Serializer class
+    """
+    if not getattr(obj, "swagger_fake_view", False) and hasattr(obj.request, "major_version"):
+        api_version = f"{obj.request.major_version}.{obj.request.minor_version}"
+        serializer = get_api_version_serializer(serializer_choices, api_version)
+        if serializer is not None:
+            return serializer
+    return default_serializer
+
+
+def get_serializer_for_model(model, prefix=""):
+    """
+    Dynamically resolve and return the appropriate serializer for a model.
+
+    Raises:
+        SerializerNotFound: if the requested serializer cannot be located.
+    """
+    app_label, model_name = model._meta.label.split(".")
+    if app_label == "contenttypes" and model_name == "ContentType":
+        app_path = "nautobot.extras"
+    # Serializers for Django's auth models are in the users app
+    elif app_label == "auth":
+        app_path = "nautobot.users"
+    else:
+        app_path = apps.get_app_config(app_label).name
+    serializer_name = f"{app_path}.api.serializers.{prefix}{model_name}Serializer"
+    try:
+        return dynamic_import(serializer_name)
+    except AttributeError as exc:
+        raise exceptions.SerializerNotFound(
+            f"Could not determine serializer for {app_label}.{model_name} with prefix '{prefix}'"
+        ) from exc
+
+
+def nested_serializers_for_models(models, prefix=""):
+    """
+    Dynamically resolve and return the appropriate nested serializers for a list of models.
+
+    Unlike get_serializer_for_model, this will skip any models for which an appropriate serializer cannot be found,
+    logging a message instead of raising the SerializerNotFound exception.
+
+    Used exclusively in OpenAPI schema generation.
+    """
+    serializer_classes = []
+    for model in models:
+        try:
+            serializer_classes.append(get_serializer_for_model(model, prefix=prefix))
+        except exceptions.SerializerNotFound as exc:
+            logger.error("%s", exc)
+            continue
+
+    nested_serializer_classes = []
+    for serializer_class in serializer_classes:
+        nested_serializer_name = f"Nested{serializer_class.__name__}"
+        if nested_serializer_name in NESTED_SERIALIZER_CACHE:
+            nested_serializer_classes.append(NESTED_SERIALIZER_CACHE[nested_serializer_name])
+        else:
+
+            class NautobotNestedSerializer(serializer_class):
+                class Meta(serializer_class.Meta):
+                    fields = ["id", "object_type", "url"]
+
+                def get_field_names(self, declared_fields, info):
+                    """Don't auto-add any other fields to the field_names!"""
+                    return serializers.HyperlinkedModelSerializer.get_field_names(self, declared_fields, info)
+
+            NautobotNestedSerializer.__name__ = nested_serializer_name
+            NESTED_SERIALIZER_CACHE[nested_serializer_name] = NautobotNestedSerializer
+            nested_serializer_classes.append(NautobotNestedSerializer)
+
+    return nested_serializer_classes
+
+
+def is_api_request(request):
+    """
+    Return True of the request is being made via the REST API.
+    """
+    api_path = reverse("api-root")
+    return request.path_info.startswith(api_path)
+
+
+def get_view_name(view):
+    """
+    Derive the view name from its associated model, if it has one. Fall back to DRF's built-in `get_view_name`.
+    """
+    if hasattr(view, "name") and view.name:
+        return view.name
+    elif hasattr(view, "queryset"):
+        # Determine the model name from the queryset.
+        if hasattr(view, "detail") and view.detail:
+            name = view.queryset.model._meta.verbose_name
+        else:
+            name = view.queryset.model._meta.verbose_name_plural
+        name = " ".join([w[0].upper() + w[1:] for w in name.split()])  # Capitalize each word
+
+    else:
+        # Replicate DRF's built-in behavior.
+        name = view.__class__.__name__
+        name = formatting.remove_trailing_string(name, "View")
+        name = formatting.remove_trailing_string(name, "ViewSet")
+        name = formatting.camelcase_to_spaces(name)
+
+        # Suffix may be set by some Views, such as a ViewSet.
+        suffix = getattr(view, "suffix", None)
+        if suffix:
+            name += " " + suffix
+
+    return name
+
+
+def rest_api_server_error(request, *args, **kwargs):
+    """
+    Handle exceptions and return a useful error message for REST API requests.
+    """
+    type_, error, _traceback = sys.exc_info()
+    data = {
+        "error": str(error),
+        "exception": type_.__name__,
+        "nautobot_version": settings.VERSION,
+        "python_version": platform.python_version(),
+    }
+    return JsonResponse(data, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+# TODO: This is part of the drf-react-template work towards auto-generating create/edit form UI from the REST API.
+def format_output(field, field_value):
+    """TODO: docstring required."""
+    data = {
+        "field_name": field,  # Form field placeholder
+        "type": "others",  # Param type e.g select field, char field, datetime field etc.
+        "choices": [],  # Param choices for select fields
+        "help_text": None,  # Form field placeholder
+        "label": None,  # Form field placeholder
+        "required": False,  # Form field placeholder
+    }
+    # TODO: fix these local imports if at all possible
+    from rest_framework.fields import CharField, IntegerField
+    from rest_framework.serializers import ListSerializer
+
+    from nautobot.core.api import ChoiceField, WritableNestedSerializer
+
+    kwargs = {}
+    if isinstance(field_value, (WritableNestedSerializer, ListSerializer)):
+        kwargs = {
+            "type": "dynamic-choice-field",
+        }
+        extra_kwargs = {}
+
+        if isinstance(field_value, WritableNestedSerializer):
+            extra_kwargs = {
+                "label": getattr(field_value, "label", None) or field,
+                "required": field_value.required,
+                "help_text": field_value.help_text,
+            }
+        elif isinstance(field_value, ListSerializer):
+            extra_kwargs = {
+                "label": "Tags",
+                "required": False,
+            }
+        kwargs.update(extra_kwargs)
+    elif isinstance(field_value, ChoiceField):
+        kwargs = {
+            "type": "choice-field",
+            "label": getattr(field_value, "label", None) or field,
+            "required": field_value.required,
+            "help_text": field_value.help_text,
+            "choices": field_value.choices.items(),
+        }
+    elif isinstance(field_value, CharField):
+        kwargs = {
+            "type": "char-field",
+            "label": getattr(field_value, "label", None) or field,
+            "required": field_value.required,
+            "help_text": field_value.help_text,
+        }
+    elif isinstance(field_value, IntegerField):
+        kwargs = {
+            "type": "integer-field",
+            "label": getattr(field_value, "label", None) or field,
+            "required": field_value.required,
+            "help_text": field_value.help_text,
+        }
+    data.update(kwargs)
+    return data
+
+
+def get_relation_info_for_nested_serializers(model_class, related_model, field_name):
+    """Get the DRF RelationInfo object needed for build_nested_field()"""
+    relation_info = RelationInfo(
+        model_field=getattr(type(model_class), field_name),
+        related_model=type(related_model),
+        to_many=False,
+        has_through_model=False,
+        to_field=_get_to_field(getattr(type(model_class), field_name)),
+        reverse=False,
+    )
+    return relation_info
+
+
+def get_nested_serializer_depth(serializer):
+    """
+    Determine the correct depth value based on the request.
+    This method is used mostly in SerializerMethodField where
+    DRF does not automatically build a serializer for us because the field
+    is not a native model field.
+    """
+    request = serializer.context.get("request", None)
+    # If we do not have a request or request.method is not GET default depth to 0
+    if not request or request.method != "GET" or not hasattr(serializer.Meta, "depth"):
+        depth = 0
+    else:
+        depth = serializer.Meta.depth
+    return depth
+
+
+NESTED_SERIALIZER_CACHE = {}
+
+
+def nested_serializer_factory(relation_info, nested_depth):
+    """
+    Return a NestedSerializer representation of a serializer field.
+    This method should only be called in build_nested_field()
+    in which relation_info and nested_depth are already given.
+    """
+    nested_serializer_name = f"Nested{nested_depth}{relation_info.related_model.__name__}"
+    # If we already have built a suitable NestedSerializer we return the cached serializer.
+    # else we build a new one and store it in the cache for future use.
+    if nested_serializer_name in NESTED_SERIALIZER_CACHE:
+        field_class = NESTED_SERIALIZER_CACHE[nested_serializer_name]
+        field_kwargs = get_nested_relation_kwargs(relation_info)
+    else:
+        base_serializer_class = get_serializer_for_model(relation_info.related_model)
+
+        class NautobotNestedSerializer(base_serializer_class):
+            class Meta(base_serializer_class.Meta):
+                is_nested = True
+                depth = nested_depth - 1
+
+        NautobotNestedSerializer.__name__ = nested_serializer_name
+        NESTED_SERIALIZER_CACHE[nested_serializer_name] = NautobotNestedSerializer
+        field_class = NautobotNestedSerializer
+        field_kwargs = get_nested_relation_kwargs(relation_info)
+    return field_class, field_kwargs
+
+
+def return_nested_serializer_data_based_on_depth(serializer, depth, obj, obj_related_field, obj_related_field_name):
+    """
+    Handle serialization of GenericForeignKey fields at an appropriate depth.
+
+    When depth = 0, return a brief representation of the related object, containing URL, PK, and object_type.
+    When depth > 0, return the data for the appropriate nested serializer, plus a "generic_foreign_key = True" field.
+
+    Args:
+        serializer (BaseSerializer): BaseSerializer
+        depth (int): Levels of nested serialization
+        obj (BaseModel): Object needs to be serialized
+        obj_related_field (BaseModel): Related object needs to be serialized
+        obj_related_field_name (str): Object's field name that represents the related object.
+    """
+    if depth == 0:
+        url = obj_related_field.get_absolute_url(api=True)
+        if serializer.context.get("request"):
+            url = serializer.context.get("request").build_absolute_uri(url)
+
+        result = {
+            "id": obj_related_field.pk,
+            "object_type": obj_related_field._meta.label_lower,
+            "url": url,
+        }
+        return result
+    else:
+        relation_info = get_relation_info_for_nested_serializers(obj, obj_related_field, obj_related_field_name)
+        field_class, field_kwargs = serializer.build_nested_field(obj_related_field_name, relation_info, depth)
+        data = field_class(
+            obj_related_field, context={"request": serializer.context.get("request")}, **field_kwargs
+        ).data
+        data["generic_foreign_key"] = True
+        return data