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

nautobot/core/jobs/bulk_actions.py

@@ -0,0 +1,285 @@
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import (
+    FieldDoesNotExist,
+    ObjectDoesNotExist,
+    PermissionDenied,
+    ValidationError,
+)
+from django.db.models import ManyToManyField, ProtectedError
+
+from nautobot.core import exceptions
+from nautobot.core.forms.utils import restrict_form_fields
+from nautobot.core.utils.filtering import get_filterset_field
+from nautobot.core.utils.lookup import get_filterset_for_model, get_form_for_model
+from nautobot.extras.context_managers import deferred_change_logging_for_bulk_operation
+from nautobot.extras.jobs import (
+    BooleanVar,
+    Job,
+    JSONVar,
+    ObjectVar,
+    RunJobTaskFailed,
+)
+from nautobot.extras.utils import bulk_delete_with_bulk_change_logging, remove_prefix_from_cf_key
+
+name = "System Jobs"
+
+
+class BulkEditObjects(Job):
+    """System Job to bulk Edit objects."""
+
+    content_type = ObjectVar(
+        model=ContentType,
+        description="Type of objects to update",
+    )
+    form_data = JSONVar(description="BulkEditForm data")
+    edit_all = BooleanVar(description="Bulk Edit all object / all filtered objects", required=False)
+    filter_query_params = JSONVar(label="Filter Query Params", required=False)
+
+    class Meta:
+        name = "Bulk Edit Objects"
+        description = "Bulk edit objects."
+        has_sensitive_variables = False
+        soft_time_limit = 1800
+        time_limit = 2000
+
+    def _update_objects(self, model, form, filter_query_params, edit_all, nullified_fields):
+        with deferred_change_logging_for_bulk_operation():
+            base_queryset = model.objects.restrict(self.user, "change")
+            updated_objects_pk = []
+            filterset_cls = get_filterset_for_model(model)
+
+            if filter_query_params:
+                if not filterset_cls:
+                    self.logger.error(f"Filterset not found for {model._meta.verbose_name}")
+                    raise RunJobTaskFailed(
+                        f"Filter query provided but {model._meta.verbose_name} does not have a filterset."
+                    )
+
+                # Discarding non-filter query params
+                new_filter_query_params = {}
+
+                for key, value in filter_query_params.items():
+                    try:
+                        get_filterset_field(filterset_cls(), key)
+                        new_filter_query_params[key] = value
+                    except exceptions.FilterSetFieldNotFound:
+                        self.logger.debug(
+                            f"Query parameter `{key}` not found in filterset for `{filterset_cls}`, discarding it"
+                        )
+
+                filter_query_params = new_filter_query_params
+
+            if edit_all:
+                if filter_query_params:
+                    queryset = filterset_cls(filter_query_params).qs.restrict(self.user, "change")
+                else:
+                    queryset = model.objects.restrict(self.user, "change")
+            else:
+                queryset = model.objects.restrict(self.user, "change").filter(pk__in=form.cleaned_data["pk"])
+
+            form_custom_fields = getattr(form, "custom_fields", [])
+            form_relationships = getattr(form, "relationships", [])
+            standard_fields = [
+                field
+                for field in form.fields
+                if field not in form_custom_fields + form_relationships + ["pk"] + ["object_note"]
+            ]
+
+            self.logger.debug(f"Performing update on {queryset.count()} {model._meta.verbose_name_plural}")
+            for obj in queryset.iterator():
+                # Update standard fields. If a field is listed in _nullify, delete its value.
+                for field_name in standard_fields:
+                    try:
+                        model_field = model._meta.get_field(field_name)
+                    except FieldDoesNotExist:
+                        # This form field is used to modify a field rather than set its value directly
+                        model_field = None
+
+                    # Handle nullification
+                    if nullified_fields:
+                        if field_name in form.nullable_fields and field_name in nullified_fields:
+                            if isinstance(model_field, ManyToManyField):
+                                getattr(obj, field_name).set([])
+                            else:
+                                setattr(obj, field_name, None if model_field is not None and model_field.null else "")
+
+                    # ManyToManyFields
+                    elif isinstance(model_field, ManyToManyField):
+                        if form.cleaned_data[field_name]:
+                            getattr(obj, field_name).set(form.cleaned_data[field_name])
+                    # Normal fields
+                    elif form.cleaned_data[field_name] not in (None, ""):
+                        setattr(obj, field_name, form.cleaned_data[field_name])
+
+                # Update custom fields
+                for field_name in form_custom_fields:
+                    if field_name in form.nullable_fields and nullified_fields and field_name in nullified_fields:
+                        obj.cf[remove_prefix_from_cf_key(field_name)] = None
+                    elif form.cleaned_data.get(field_name) not in (None, "", []):
+                        obj.cf[remove_prefix_from_cf_key(field_name)] = form.cleaned_data[field_name]
+
+                obj.full_clean()
+                obj.save()
+                updated_objects_pk.append(obj.pk)
+                form.post_save(obj)
+
+                if hasattr(form, "save_relationships") and callable(form.save_relationships):
+                    # Add/remove relationship associations
+                    form.save_relationships(instance=obj, nullified_fields=nullified_fields)
+
+                if hasattr(form, "save_note") and callable(form.save_note):
+                    form.save_note(instance=obj, user=self.user)
+            total_updated_objs = len(updated_objects_pk)
+            # Enforce object-level permissions
+            if base_queryset.filter(pk__in=updated_objects_pk).count() != total_updated_objs:
+                raise ObjectDoesNotExist
+            return total_updated_objs
+
+    def _process_valid_form(self, model, form, filter_query_params, edit_all, nullified_fields):
+        try:
+            total_updated_objs = self._update_objects(model, form, filter_query_params, edit_all, nullified_fields)
+            msg = f"Updated {total_updated_objs} {model._meta.verbose_name_plural}"
+            self.logger.info(msg)
+            return msg
+        except ValidationError as e:
+            self.logger.error(str(e))
+        except ObjectDoesNotExist:
+            msg = "Object update failed due to object-level permissions violation"
+            self.logger.error(msg)
+        raise RunJobTaskFailed("Bulk Edit not fully successful, see logs")
+
+    def run(  # pylint: disable=arguments-differ
+        self, *, content_type, form_data, edit_all=False, filter_query_params=None
+    ):
+        if not self.user.has_perm(f"{content_type.app_label}.change_{content_type.model}"):
+            self.logger.error('User "%s" does not have permission to update %s objects', self.user, content_type.model)
+            raise PermissionDenied("User does not have change permissions on the requested content-type")
+
+        model = content_type.model_class()
+        if model is None:
+            self.logger.error(
+                'Could not find the "%s.%s" data model. Perhaps an app is uninstalled?',
+                content_type.app_label,
+                content_type.model,
+            )
+            raise RunJobTaskFailed("Model not found")
+        try:
+            form_cls = get_form_for_model(model, form_prefix="BulkEdit")
+        except Exception:
+            self.logger.debug(
+                'Could not find the "%s.%s" data bulk edit form. Unable to process Bulk Edit for this model.',
+                content_type.app_label,
+                content_type.model,
+            )
+            raise
+        form = form_cls(model, form_data, edit_all=edit_all)
+        restrict_form_fields(form, self.user)
+
+        if form.is_valid():
+            self.logger.debug("Form validation was successful")
+            nullified_fields = form_data.get("_nullify")
+            return self._process_valid_form(model, form, filter_query_params, edit_all, nullified_fields)
+        else:
+            self.logger.error(f"Form validation unsuccessful: {form.errors.as_json()}")
+
+        raise RunJobTaskFailed("Updating Jobs Failed")
+
+
+class BulkDeleteObjects(Job):
+    """
+    System job to bulk delete objects.
+    """
+
+    content_type = ObjectVar(
+        model=ContentType,
+        description="Type of objects to delete",
+    )
+    pk_list = JSONVar(description="List of objects pks to delete", required=False)
+    delete_all = BooleanVar(description="Delete all (filtered) objects instead of a list of PKs", required=False)
+    filter_query_params = JSONVar(label="Filter Query Params", required=False)
+
+    class Meta:
+        name = "Bulk Delete Objects"
+        description = "Bulk delete objects."
+        has_sensitive_variables = False
+        soft_time_limit = 1800
+        time_limit = 2000
+
+    def run(  # pylint: disable=arguments-differ
+        self, *, content_type, pk_list=None, delete_all=False, filter_query_params=None
+    ):
+        if not self.user.has_perm(f"{content_type.app_label}.delete_{content_type.model}"):
+            self.logger.error('User "%s" does not have permission to delete %s objects', self.user, content_type.model)
+            raise PermissionDenied("User does not have delete permissions on the requested content-type")
+
+        model = content_type.model_class()
+        if model is None:
+            self.logger.error(
+                'Could not find the "%s.%s" data model. Perhaps an app is uninstalled?',
+                content_type.app_label,
+                content_type.model,
+            )
+            raise RunJobTaskFailed("Model not found")
+
+        filterset_cls = get_filterset_for_model(model)
+
+        if filter_query_params:
+            if not filterset_cls:
+                self.logger.error(f"Filterset not found for {model._meta.verbose_name}")
+                raise RunJobTaskFailed(
+                    f"Filter query provided but {model._meta.verbose_name} does not have a filterset."
+                )
+
+            # Discarding non-filter query params
+            new_filter_query_params = {}
+
+            for key, value in filter_query_params.items():
+                try:
+                    get_filterset_field(filterset_cls(), key)
+                    new_filter_query_params[key] = value
+                except exceptions.FilterSetFieldNotFound:
+                    self.logger.debug(f"Query parameter `{key}` not found in `{filterset_cls}`, discarding it")
+
+            filter_query_params = new_filter_query_params
+
+        if delete_all:
+            # Case for selecting all objects (or all filtered objects) to delete
+            if filter_query_params:
+                # If there is filter query params, we need to apply it to the queryset
+                queryset = filterset_cls(filter_query_params).qs.restrict(self.user, "delete")
+                # We take this approach because filterset.qs has already applied .distinct(),
+                # and performing a .delete directly on a queryset with .distinct applied is not allowed.
+                queryset = model.objects.filter(pk__in=queryset)
+            else:
+                # If there is not, we can just restrict the queryset to the user's permissions
+                queryset = model.objects.restrict(self.user, "delete")
+        elif pk_list:
+            # Case for selecting specific objects to delete, delete_all overrides this option
+            queryset = model.objects.restrict(self.user, "delete").filter(pk__in=pk_list)
+            if queryset.count() < len(pk_list):
+                # We do not check ObjectPermission error for `delete_all` case because user is trying to
+                # delete all objs they have permission to which would not raise any issue.
+                self.logger.error("You do not have permissions to delete some of the objects provided in `pk_list`.")
+                raise RunJobTaskFailed("Caught ObjectPermission error while attempting to delete objects")
+        elif not pk_list and not delete_all:
+            self.logger.error("You must select at least one object instance to delete.")
+            raise RunJobTaskFailed("Either `pk_list` or `delete_all` is required.")
+
+        verbose_name_plural = model._meta.verbose_name_plural
+
+        # Currently the only purpose of a bulk delete form is to perform a `pre_delete` operation
+        if form_cls := get_form_for_model(model, form_prefix="BulkDelete"):
+            form = form_cls(model, {"pk": pk_list}, delete_all=delete_all)
+            if hasattr(form, "perform_pre_delete"):
+                form.perform_pre_delete(queryset)
+
+        try:
+            self.logger.info(f"Deleting {queryset.count()} {verbose_name_plural}...")
+            _, deleted_info = bulk_delete_with_bulk_change_logging(queryset)
+            deleted_count = deleted_info.get(model._meta.label, 0)
+        except ProtectedError as err:
+            # TODO this error message needs to be cleaner, ideally using a variant of handle_protectederror
+            self.logger.error(f"Caught ProtectedError while attempting to delete objects: `{err}`")
+            raise RunJobTaskFailed("Caught ProtectedError while attempting to delete objects")
+        msg = f"Deleted {deleted_count} {model._meta.verbose_name_plural}"
+        self.logger.info(msg)

nautobot/core/jobs/cleanup.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
 
 from django.core.exceptions import PermissionDenied
+from django.db.models import CASCADE
 from django.db.models.signals import pre_delete
 from django.utils import timezone
 
@@ -48,7 +49,28 @@ class LogsCleanup(Job):
         description = "Delete ObjectChange and/or JobResult/JobLogEntry records older than a specified cutoff."
         has_sensitive_variables = False
 
-    def run(self, *, cleanup_types, max_age=None):
+    def recursive_delete_with_cascade(self, queryset, deletion_summary):
+        """
+        Recursively deletes all related objects with CASCADE for a given queryset.
+
+        Args:
+            queryset (QuerySet): The queryset of objects to delete.
+            deletion_summary (dict): A dictionary to store the count of deleted objects for each model.
+        """
+        related_objects = queryset.model._meta.related_objects
+        queryset = queryset.only("id")
+
+        for related_object in related_objects:
+            if related_object.on_delete is CASCADE:
+                related_model = related_object.related_model
+                related_field_name = related_object.field.name
+                cascade_queryset = related_model.objects.filter(**{f"{related_field_name}__id__in": queryset})
+                self.recursive_delete_with_cascade(cascade_queryset, deletion_summary)
+        _, deleted_dict = queryset.delete()
+        deletion_summary.update(deleted_dict)
+        return deletion_summary
+
+    def run(self, *, cleanup_types, max_age=None):  # pylint: disable=arguments-differ
         if max_age in (None, ""):
             max_age = get_settings_or_config("CHANGELOG_RETENTION", fallback=90)
             if max_age == 0:
@@ -77,22 +99,36 @@ class LogsCleanup(Job):
 
             if CleanupTypes.JOB_RESULT in cleanup_types:
                 self.logger.info("Deleting JobResult records prior to %s", cutoff)
-                _, deleted_dict = JobResult.objects.restrict(self.user, "delete").filter(date_done__lt=cutoff).delete()
+                queryset = JobResult.objects.restrict(self.user, "delete").filter(date_done__lt=cutoff)
+                deletion_summary = {}
+                self.recursive_delete_with_cascade(queryset, deletion_summary)
                 result.setdefault("extras.JobResult", 0)
                 result.setdefault("extras.JobLogEntry", 0)
-                result.update(**deleted_dict)
-                self.logger.info(
-                    "Deleted %d JobResult records and their associated %d JobLogEntry records",
-                    result["extras.JobResult"],
-                    result["extras.JobLogEntry"],
-                )
+                result.update(deletion_summary)
+
+                for modelname, count in deletion_summary.items():
+                    self.logger.info(
+                        "As part of deleting %d JobResult records, also deleted %d related %s records",
+                        result["extras.JobResult"],
+                        count,
+                        modelname,
+                    )
 
             if CleanupTypes.OBJECT_CHANGE in cleanup_types:
                 self.logger.info("Deleting ObjectChange records prior to %s", cutoff)
-                deleted_count, _ = ObjectChange.objects.restrict(self.user, "delete").filter(time__lt=cutoff).delete()
-                self.logger.info("Deleted %d ObjectChange records", deleted_count)
-                result["extras.ObjectChange"] = deleted_count
-
+                queryset = ObjectChange.objects.restrict(self.user, "delete").filter(time__lt=cutoff)
+                deletion_summary = {}
+                self.recursive_delete_with_cascade(queryset, deletion_summary)
+                result.setdefault("extras.ObjectChange", 0)
+                result.update(deletion_summary)
+
+                for modelname, count in deletion_summary.items():
+                    self.logger.info(
+                        "As part of deleting %d ObjectChange records, also deleted %d related %s records",
+                        result["extras.ObjectChange"],
+                        count,
+                        modelname,
+                    )
             return result
         finally:
             # Be sure to clean up after ourselves!

nautobot/core/jobs/groups.py

@@ -24,7 +24,7 @@ class RefreshDynamicGroupCaches(Job):
         description = "Re-calculate and re-cache the membership lists of Dynamic Groups."
         has_sensitive_variables = False
 
-    def run(self, single_group=None):
+    def run(self, single_group=None):  # pylint: disable=arguments-differ
         groups = DynamicGroup.objects.restrict(self.user, "view").exclude(
             group_type=DynamicGroupTypeChoices.TYPE_STATIC
         )

nautobot/core/management/commands/validate_models.py

@@ -63,7 +63,7 @@ class Command(BaseCommand):
         for model in models:
             model_name = f"{model._meta.app_label}.{model.__name__}"
             # Most swap out for user_model
-            if model_name == "auth.User":
+            if model_name == "auth.User":  # pylint: disable=hard-coded-auth-user
                 model = get_user_model()
             # Skip models that aren't actually in the database
             if not model._meta.managed:

nautobot/core/models/__init__.py

@@ -248,6 +248,8 @@ class BaseModel(models.Model):
         Unlike `get_natural_key_def()`, this doesn't auto-exclude all AutoField and BigAutoField fields,
         but instead explicitly discounts the `id` field (only) as a candidate.
         """
+        if cls != cls._meta.concrete_model:
+            return cls._meta.concrete_model.natural_key_field_lookups
         # First, figure out which local fields comprise the natural key:
         natural_key_field_names = []
         if hasattr(cls, "natural_key_field_names"):
@@ -270,7 +272,7 @@ class BaseModel(models.Model):
 
         if not natural_key_field_names:
             raise AttributeError(
-                f"Unable to identify an intrinsic natural-key definition for {cls.__name__}. "
+                f"Unable to identify an intrinsic natural-key definition for {cls.__name__}. "  # pylint: disable=no-member
                 "If there isn't at least one UniqueConstraint, unique_together, or field with unique=True, "
                 "you probably need to explicitly declare the 'natural_key_field_names' for this model, "
                 "or potentially override the default 'natural_key_field_lookups' implementation for this model."

nautobot/core/models/query_functions.py

@@ -69,7 +69,7 @@ class JSONSet(Func):
         }
         return c
 
-    def as_sql(self, compiler, connection, function=None, **extra_context):
+    def as_sql(self, compiler, connection, function=None, **extra_context):  # pylint:disable=arguments-differ
         """
         MySQL implementation based on https://github.com/django/django/pull/18489/files.
 
@@ -138,7 +138,7 @@ class JSONRemove(Func):
         self.path = path
         super().__init__(expression)
 
-    def as_sql(self, compiler, connection, function=None, **extra_context):
+    def as_sql(self, compiler, connection, function=None, **extra_context):  # pylint:disable=arguments-differ
         """
         MySQL implementation based on https://github.com/django/django/pull/18489/files.
 

nautobot/core/models/tree_queries.py

@@ -111,12 +111,15 @@ class TreeModel(TreeNode):
         if display_str:
             return display_str
         try:
-            if self.parent is not None:
-                display_str = self.parent.display + " → "
+            if self.parent_id is not None:
+                parent_display_str = cache.get(cache_key.replace(str(self.id), str(self.parent_id)), "")
+                if not parent_display_str:
+                    parent_display_str = self.parent.display  # pylint: disable=no-member
+                display_str = parent_display_str + " → "
         except self.DoesNotExist:
             # Expected to occur at times during bulk-delete operations
             pass
-        display_str += self.name
+        display_str += self.name  # pylint: disable=no-member  # we checked with hasattr() above
         cache.set(cache_key, display_str, 5)
         return display_str
 

nautobot/core/settings.py

@@ -1,3 +1,4 @@
+import datetime
 import os
 import os.path
 import platform
@@ -163,6 +164,16 @@ NAPALM_PASSWORD = os.getenv("NAUTOBOT_NAPALM_PASSWORD", "")
 NAPALM_TIMEOUT = int(os.getenv("NAUTOBOT_NAPALM_TIMEOUT", "30"))
 NAPALM_USERNAME = os.getenv("NAUTOBOT_NAPALM_USERNAME", "")
 
+# Expiration date (YYYY-MM-DD) for an active Nautobot support contract with Network to Code.
+# Displayed in the About page.
+if (
+    "NAUTOBOT_NTC_SUPPORT_CONTRACT_EXPIRATION_DATE" in os.environ
+    and os.environ["NAUTOBOT_NTC_SUPPORT_CONTRACT_EXPIRATION_DATE"] != ""
+):
+    NTC_SUPPORT_CONTRACT_EXPIRATION_DATE = datetime.date.fromisoformat(
+        os.environ["NAUTOBOT_NTC_SUPPORT_CONTRACT_EXPIRATION_DATE"]
+    )
+
 # Default number of objects to display per page of the UI and REST API. Default is 50
 if "NAUTOBOT_PAGINATE_COUNT" in os.environ and os.environ["NAUTOBOT_PAGINATE_COUNT"] != "":
     PAGINATE_COUNT = int(os.environ["NAUTOBOT_PAGINATE_COUNT"])
@@ -180,6 +191,9 @@ PLUGINS_CONFIG = {}
 if "NAUTOBOT_PREFER_IPV4" in os.environ and os.environ["NAUTOBOT_PREFER_IPV4"] != "":
     PREFER_IPV4 = is_truthy(os.environ["NAUTOBOT_PREFER_IPV4"])
 
+# Publish a simple "no-index" robots.txt for Nautobot?
+PUBLISH_ROBOTS_TXT = is_truthy(os.getenv("NAUTOBOT_PUBLISH_ROBOTS_TXT", "True"))
+
 # Default height and width in pixels of a single rack unit in rendered rack elevations. Defaults are 22 and 220
 if (
     "NAUTOBOT_RACK_ELEVATION_DEFAULT_UNIT_HEIGHT" in os.environ
@@ -232,7 +246,7 @@ if SSO_ENABLE_GROUP_SYNC:
         "social_core.pipeline.social_auth.associate_user",
         "social_core.pipeline.social_auth.load_extra_data",
         "social_core.pipeline.user.user_details",
-        "nautobot.extras.group_sync",
+        "nautobot.extras.group_sync.group_sync",
     )
 # OAuth2/OIDC claim where the list of groups the authenticating user is a part of
 SSO_CLAIMS_GROUP = os.getenv("NAUTOBOT_SSO_CLAIMS_GROUP", "groups")
@@ -718,6 +732,13 @@ CONSTANCE_ADDITIONAL_FIELDS = {
             "required": False,
         },
     ],
+    "optional_date_field": [
+        "django.forms.DateField",
+        {
+            "widget": "nautobot.core.forms.widgets.DatePicker",
+            "required": False,
+        },
+    ],
 }
 
 CONSTANCE_CONFIG = {
@@ -803,6 +824,12 @@ CONSTANCE_CONFIG = {
         # Use custom field type defined above
         field_type="optional_json_field",
     ),
+    "NTC_SUPPORT_CONTRACT_EXPIRATION_DATE": ConstanceConfigItem(
+        default="",
+        help_text="Expiration date for an active Nautobot support contract with Network to Code. "
+        "This value is displayed in the About page to provide additional support information.",
+        field_type="optional_date_field",
+    ),
     "PREFER_IPV4": ConstanceConfigItem(
         default=False,
         help_text="Whether to prefer IPv4 primary addresses over IPv6 primary addresses for devices.",
@@ -856,7 +883,7 @@ CONSTANCE_CONFIG_FIELDSETS = {
         "RACK_ELEVATION_UNIT_TWO_DIGIT_FORMAT",
     ],
     "Release Checking": ["RELEASE_CHECK_URL", "RELEASE_CHECK_TIMEOUT"],
-    "User Interface": ["SUPPORT_MESSAGE"],
+    "User Interface": ["SUPPORT_MESSAGE", "NTC_SUPPORT_CONTRACT_EXPIRATION_DATE"],
     "Debugging": ["ALLOW_REQUEST_PROFILING"],
 }
 

nautobot/core/settings.yaml

@@ -6,6 +6,8 @@ definitions:
     type: "string"
   callable:
     type: "string"
+  date:
+    type: "string"
   regex:
     type: "string"
   relative_path:
@@ -1491,6 +1493,17 @@ properties:
     is_constance_config: true
     type: "object"
     version_added: "1.6.0"
+  NTC_SUPPORT_CONTRACT_EXPIRATION_DATE:
+    "$ref": "#/definitions/date"
+    default: ""
+    description: >-
+      Expiration date for an active Nautobot support contract with Network to Code.
+      This value is displayed in the "About" page to provide additional support information.
+    details: >-
+      If specified as an environment variable, use ISO 8601 (`YYYY-MM-DD`) format.
+    environment_variable: "NAUTOBOT_NTC_SUPPORT_CONTRACT_EXPIRATION_DATE"
+    is_constance_config: true
+    version_added: "2.4.0"
   PAGINATE_COUNT:
     default: 50
     description: >-
@@ -1559,6 +1572,14 @@ properties:
     environment_variable: "NAUTOBOT_PREFER_IPV4"
     is_constance_config: true
     type: "boolean"
+  PUBLISH_ROBOTS_TXT:
+    default: true
+    description: >-
+        Setting this to true causes Nautobot to publish a `robots.txt` that discourages indexing by web crawlers.
+        Irrelevant if deployed behind a firewall.
+    environment_variable: "NAUTOBOT_PUBLISH_ROBOTS_TXT"
+    type: "boolean"
+    version_added: "2.3.15"
   RACK_ELEVATION_DEFAULT_UNIT_HEIGHT:
     default: 22
     description: >-