nautobot 2.3.7__py3-none-any.whl → 2.3.9__py3-none-any.whl

nautobot/dcim/utils.py

@@ -139,12 +139,14 @@ def validate_interface_tagged_vlans(instance, model, pk_set):
         )
 
     # Filter the model objects based on the primary keys passed in kwargs and exclude the ones that have
-    # a location that is not the parent's location or None
-    # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to add a VLAN
-    # belongs to the parent Location or the child location of the parent device to the `tagged_vlan` field of the interface?
-    device_location = getattr(instance.parent, "location", None)
+    # a location that is not the parent's location, or parent's location's ancestors, or None
+    location = getattr(instance.parent, "location", None)
+    if location:
+        location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+    else:
+        location_ids = []
     tagged_vlans = (
-        model.objects.filter(pk__in=pk_set).exclude(locations__isnull=True).exclude(locations__in=[device_location])
+        model.objects.filter(pk__in=pk_set).exclude(locations__isnull=True).exclude(locations__in=location_ids)
     )
 
     if tagged_vlans.count():
@@ -152,7 +154,8 @@ def validate_interface_tagged_vlans(instance, model, pk_set):
             {
                 "tagged_vlans": (
                     f"Tagged VLAN with names {list(tagged_vlans.values_list('name', flat=True))} must all belong to the "
-                    f"same location as the interface's parent device, or it must be global."
+                    "same location as the interface's parent device, "
+                    "one of the parent locations of the interface's parent device's location, or it must be global."
                 )
             }
         )

nautobot/extras/context_managers.py

@@ -180,7 +180,7 @@ def web_request_context(
         Valid choices are in `nautobot.extras.choices.ObjectChangeEventContextChoices`.
     :param request: Optional web request instance, one will be generated if not supplied
     """
-    from nautobot.extras.jobs import enqueue_job_hooks, get_jobs  # prevent circular import
+    from nautobot.extras.jobs import enqueue_job_hooks  # prevent circular import
 
     valid_contexts = {
         ObjectChangeEventContextChoices.CONTEXT_JOB: JobChangeContext,
@@ -203,15 +203,14 @@ def web_request_context(
         with change_logging(change_context):
             yield request
     finally:
-        jobs_refreshed = False
+        jobs_reloaded = False
         # enqueue jobhooks and webhooks, use change_context.change_id in case change_id was not supplied
-        for object_change in ObjectChange.objects.filter(request_id=change_context.change_id).iterator():
+        for object_change in (
+            ObjectChange.objects.filter(request_id=change_context.change_id).order_by("time").iterator()
+        ):
             if context != ObjectChangeEventContextChoices.CONTEXT_JOB_HOOK:
-                # Make sure JobHooks are up to date (once) before calling them
-                if not jobs_refreshed:
-                    get_jobs(reload=True)
-                    jobs_refreshed = True
-                enqueue_job_hooks(object_change)
+                # Make sure JobHooks are up to date (only once) before calling them
+                jobs_reloaded |= enqueue_job_hooks(object_change, may_reload_jobs=(not jobs_reloaded))
             enqueue_webhooks(object_change)
 
 

nautobot/extras/datasources/__init__.py

@@ -4,6 +4,7 @@ from .git import (
     ensure_git_repository,
     get_repo_access_url,
     git_repository_dry_run,
+    refresh_job_code_from_repository,
 )
 from .registry import (
     get_datasource_content_choices,
@@ -20,4 +21,5 @@ __all__ = (
     "get_repo_access_url",
     "git_repository_dry_run",
     "refresh_datasource_content",
+    "refresh_job_code_from_repository",
 )

nautobot/extras/datasources/git.py

@@ -96,8 +96,11 @@ def get_repo_access_url(repository_record):
                 obj=repository_record,
             )
         except ObjectDoesNotExist:
-            # No defined secret, fall through to legacy behavior
-            pass
+            logger.warning(
+                "HTTP Token not found for secrets group %s associated with repository %s",
+                repository_record.secrets_group,
+                repository_record,
+            )
         try:
             user = repository_record.secrets_group.get_secret_value(
                 SecretsGroupAccessTypeChoices.TYPE_HTTP,
@@ -105,8 +108,12 @@ def get_repo_access_url(repository_record):
                 obj=repository_record,
             )
         except ObjectDoesNotExist:
-            # No defined secret, fall through to legacy behavior
-            pass
+            # May not be needed for this repository, so just log as debug rather than warning
+            logger.debug(
+                "HTTP Username not found for secrets group %s associated with repository %s",
+                repository_record.secrets_group,
+                repository_record,
+            )
 
     if token and token not in from_url:
         # Some git repositories require a user as well as a token.
@@ -147,7 +154,7 @@ def ensure_git_repository(repository_record, logger=None, head=None):  # pylint:
         (bool): Whether any change to the local repo actually occurred.
     """
     # We want to check if the repo is already checked out at head. We also want to avoid calling
-    # get_repo_from_utl_to_path_and_from_branch, because it will cause the URL to be rebuilt causing calls to a secrets
+    # get_repo_from_url_to_path_and_from_branch, because it will cause the URL to be rebuilt causing calls to a secrets
     # backend. As such, if head is None, we can't perform these checks.
     if head is not None:
         # If the repo exists and has HEAD already checked out, the repo is present and has the correct branch selected.
@@ -205,7 +212,6 @@ def git_repository_dry_run(repository_record, logger):  # pylint: disable=redefi
                 logger.info("%s - `%s`", item.status, item.text)
         else:
             logger.info("Repository has no changes")
-
     except Exception as exc:
         logger.error(str(exc))
         raise
@@ -435,19 +441,12 @@ def import_config_context(context_data, repository_record, job_result):
         created = False
         modified = False
         save_needed = False
-        try:
-            context_record = ConfigContext.objects.get(
-                name=context_metadata.get("name"),
-                owner_content_type=git_repository_content_type,
-                owner_object_id=repository_record.pk,
-            )
-        except ConfigContext.DoesNotExist:
-            context_record = ConfigContext(
-                name=context_metadata.get("name"),
-                owner_content_type=git_repository_content_type,
-                owner_object_id=repository_record.pk,
-            )
-            created = True
+        context_record, created = ConfigContext.objects.get_or_create(
+            name=context_metadata.get("name"),
+            owner_content_type=git_repository_content_type,
+            owner_object_id=repository_record.pk,
+            defaults={"data": {}},
+        )
 
         for field in ("weight", "description", "is_active"):
             new_value = context_metadata[field]
@@ -662,20 +661,12 @@ def import_config_context_schema(context_schema_data, repository_record, job_res
 
     schema_metadata = context_schema_data["_metadata"]
 
-    try:
-        schema_record = ConfigContextSchema.objects.get(
-            name=schema_metadata["name"],
-            owner_content_type=git_repository_content_type,
-            owner_object_id=repository_record.pk,
-        )
-    except ConfigContextSchema.DoesNotExist:
-        schema_record = ConfigContextSchema(
-            name=schema_metadata["name"],
-            owner_content_type=git_repository_content_type,
-            owner_object_id=repository_record.pk,
-            data_schema=context_schema_data["data_schema"],
-        )
-        created = True
+    schema_record, created = ConfigContextSchema.objects.get_or_create(
+        name=schema_metadata["name"],
+        owner_content_type=git_repository_content_type,
+        owner_object_id=repository_record.pk,
+        defaults={"data_schema": context_schema_data["data_schema"]},
+    )
 
     if schema_record.description != schema_metadata.get("description", ""):
         schema_record.description = schema_metadata.get("description", "")
@@ -868,22 +859,12 @@ def update_git_export_templates(repository_record, job_result):
             # To reduce noise until the base issue is fixed, we need to explicitly detect object changes:
             created = False
             modified = False
-            try:
-                template_record = ExportTemplate.objects.get(
-                    content_type=model_content_type,
-                    name=file_name,
-                    owner_content_type=git_repository_content_type,
-                    owner_object_id=repository_record.pk,
-                )
-            except ExportTemplate.DoesNotExist:
-                template_record = ExportTemplate(
-                    content_type=model_content_type,
-                    name=file_name,
-                    owner_content_type=git_repository_content_type,
-                    owner_object_id=repository_record.pk,
-                )
-                created = True
-                modified = True
+            template_record, created = ExportTemplate.objects.get_or_create(
+                content_type=model_content_type,
+                name=file_name,
+                owner_content_type=git_repository_content_type,
+                owner_object_id=repository_record.pk,
+            )
 
             if template_record.template_code != template_content:
                 template_record.template_code = template_content

nautobot/extras/datasources/registry.py

@@ -32,7 +32,7 @@ def refresh_datasource_content(model_name, record, user, job_result, delete=Fals
         job_result (JobResult): Passed through to the callback functions to use with logging their actions.
         delete (bool): True if the record is being deleted; False if it is being created/updated.
     """
-    job_result.log(f"Refreshing data provided by {record}...", level_choice=LogLevelChoices.LOG_INFO)
+    job_result.log(f"Refreshing data provided by {record}...", level_choice=LogLevelChoices.LOG_INFO, obj=record)
 
     for entry in get_datasource_contents(model_name):
         job_result.log(f"Refreshing {entry.name}...", level_choice=LogLevelChoices.LOG_INFO)
@@ -54,4 +54,4 @@ def refresh_datasource_content(model_name, record, user, job_result, delete=Fals
         raise RuntimeError(msg)
 
     # Otherwise, log a friendly info message.
-    job_result.log(f"Data refresh from {record} complete!", level_choice=LogLevelChoices.LOG_INFO)
+    job_result.log(f"Data refresh from {record} complete!", level_choice=LogLevelChoices.LOG_INFO, obj=record)

nautobot/extras/jobs.py

@@ -1144,20 +1144,23 @@ def run_job(self, job_class_path, *args, **kwargs):
         raise
 
 
-def enqueue_job_hooks(object_change):
+def enqueue_job_hooks(object_change, may_reload_jobs=True):
     """
-    Find job hook(s) assigned to this changed object type + action and enqueue them
-    to be processed
+    Find job hook(s) assigned to this changed object type + action and enqueue them to be processed.
+
+    Returns:
+        jobs_reloaded (bool): whether Jobs were reloaded to make this happen
     """
+    jobs_reloaded = False
 
     # Job hooks cannot trigger other job hooks
     if object_change.change_context == ObjectChangeEventContextChoices.CONTEXT_JOB_HOOK:
-        return
+        return jobs_reloaded
 
     # Determine whether this type of object supports job hooks
     content_type = object_change.changed_object_type
     if content_type not in change_logged_models_queryset():
-        return
+        return jobs_reloaded
 
     # Retrieve any applicable job hooks
     action_flag = {
@@ -1167,7 +1170,14 @@ def enqueue_job_hooks(object_change):
     }[object_change.action]
     job_hooks = JobHook.objects.filter(content_types=content_type, enabled=True, **{action_flag: True})
 
+    if not job_hooks.exists():
+        return jobs_reloaded
+
     # Enqueue the jobs related to the job_hooks
+    if may_reload_jobs:
+        get_jobs(reload=True)
+        jobs_reloaded = True
+
     for job_hook in job_hooks:
         job_model = job_hook.job
         if not job_model.installed or not job_model.enabled:
@@ -1178,3 +1188,5 @@ def enqueue_job_hooks(object_change):
             logger.error("JobHook %s is enabled, but the underlying Job implementation is missing", job_hook)
         else:
             JobResult.enqueue_job(job_model, object_change.user, object_change=object_change.pk)
+
+    return jobs_reloaded

nautobot/extras/models/datasources.py

@@ -115,6 +115,12 @@ class GitRepository(PrimaryModel):
                     "provides contents overlapping with this repository."
                 )
 
+        # Changing branch or remote_url invalidates current_head
+        if self.present_in_database:
+            past = GitRepository.objects.get(id=self.id)
+            if self.remote_url != past.remote_url or self.branch != past.branch:
+                self.current_head = ""
+
     def get_latest_sync(self):
         """
         Return a `JobResult` for the latest sync operation.

nautobot/extras/models/groups.py

@@ -8,6 +8,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.core.serializers.json import DjangoJSONEncoder
 from django.db import models
+from django.db.models.signals import pre_delete
 from django.utils.functional import cached_property
 import django_filters
 
@@ -319,24 +320,18 @@ class DynamicGroup(PrimaryModel):
         if isinstance(value, models.QuerySet):
             if value.model != self.model:
                 raise TypeError(f"QuerySet does not contain {self.model._meta.label_lower} objects")
-            to_remove = self.members.exclude(pk__in=value.values_list("pk", flat=True))
+            to_remove = self.members.only("id").difference(value.only("id"))
             self._remove_members(to_remove)
-            to_add = value.exclude(pk__in=self.members.values_list("pk", flat=True))
+            to_add = value.only("id").difference(self.members.only("id"))
             self._add_members(to_add)
         else:
             for obj in value:
                 if not isinstance(obj, self.model):
                     raise TypeError(f"{obj} is not a {self.model._meta.label_lower}")
-            to_remove = []
-            for member in self.members:
-                if member not in value:
-                    to_remove.append(member)
+            existing_members = self.members
+            to_remove = [obj for obj in existing_members if obj not in value]
             self._remove_members(to_remove)
-            to_add = []
-            members = self.members
-            for candidate in value:
-                if candidate not in members:
-                    to_add.append(candidate)
+            to_add = [obj for obj in value if obj not in existing_members]
             self._add_members(to_add)
 
         return self.members
@@ -345,63 +340,81 @@ class DynamicGroup(PrimaryModel):
         """Add the given list or QuerySet of objects to this staticly defined group."""
         if self.group_type != DynamicGroupTypeChoices.TYPE_STATIC:
             raise ValidationError(f"Group {self} is not staticly defined, adding members directly is not permitted.")
-        return self._add_members(objects_to_add)
-
-    def _add_members(self, objects_to_add):
-        """Internal API for adding the given list or QuerySet of objects to the cached/static members of this group."""
         if isinstance(objects_to_add, models.QuerySet):
             if objects_to_add.model != self.model:
                 raise TypeError(f"QuerySet does not contain {self.model._meta.label_lower} objects")
+            objects_to_add = objects_to_add.only("id").difference(self.members.only("id"))
         else:
             for obj in objects_to_add:
                 if not isinstance(obj, self.model):
                     raise TypeError(f"{obj} is not a {self.model._meta.label_lower}")
+            existing_members = self.members
+            objects_to_add = [obj for obj in objects_to_add if obj not in existing_members]
+        return self._add_members(objects_to_add)
 
+    def _add_members(self, objects_to_add):
+        """
+        Internal API for adding the given list or QuerySet of objects to the cached/static members of this group.
+
+        Assumes that objects_to_add has already been filtered to exclude any existing member objects.
+        """
         if self.group_type == DynamicGroupTypeChoices.TYPE_STATIC:
             for obj in objects_to_add:
                 # We don't use `.bulk_create()` currently because we want change logging for these creates.
                 # Might be a good future performance improvement though.
-                StaticGroupAssociation.all_objects.get_or_create(
+                StaticGroupAssociation.all_objects.create(
                     dynamic_group=self, associated_object_type=self.content_type, associated_object_id=obj.pk
                 )
         else:
             # Cached/hidden static group associations, so we can use bulk-create to bypass change logging.
-            existing_members = self.members
             sgas = [
                 StaticGroupAssociation(
                     dynamic_group=self, associated_object_type=self.content_type, associated_object_id=obj.pk
                 )
                 for obj in objects_to_add
-                if obj not in existing_members
             ]
-            StaticGroupAssociation.all_objects.bulk_create(sgas)
+            StaticGroupAssociation.all_objects.bulk_create(sgas, batch_size=1000)
 
     def remove_members(self, objects_to_remove):
         """Remove the given list or QuerySet of objects from this staticly defined group."""
         if self.group_type != DynamicGroupTypeChoices.TYPE_STATIC:
             raise ValidationError(f"Group {self} is not staticly defined, removing members directly is not permitted.")
-        return self._remove_members(objects_to_remove)
-
-    def _remove_members(self, objects_to_remove):
-        """Internal API for removing the given list or QuerySet from the cached/static members of this Group."""
         if isinstance(objects_to_remove, models.QuerySet):
             if objects_to_remove.model != self.model:
                 raise TypeError(f"QuerySet does not contain {self.model._meta.label_lower} objects")
-            StaticGroupAssociation.all_objects.filter(
-                dynamic_group=self,
-                associated_object_type=self.content_type,
-                associated_object_id__in=objects_to_remove.values_list("pk", flat=True),
-            ).delete()
         else:
-            pks_to_remove = set()
             for obj in objects_to_remove:
                 if not isinstance(obj, self.model):
                     raise TypeError(f"{obj} is not a {self.model._meta.label_lower}")
-                pks_to_remove.add(obj.pk)
+        return self._remove_members(objects_to_remove)
 
-            StaticGroupAssociation.all_objects.filter(
-                dynamic_group=self, associated_object_type=self.content_type, associated_object_id__in=pks_to_remove
-            ).delete()
+    def _remove_members(self, objects_to_remove):
+        """Internal API for removing the given list or QuerySet from the cached/static members of this Group."""
+        from nautobot.extras.signals import _handle_deleted_object  # avoid circular import
+
+        # For non-static groups, we aren't going to change log the StaticGroupAssociation deletes anyway,
+        # so save some performance on signals -- important especially when we're dealing with thousands of records
+        if self.group_type != DynamicGroupTypeChoices.TYPE_STATIC:
+            logger.debug("Temporarily disconnecting the _handle_deleted_object signal for performance")
+            pre_delete.disconnect(_handle_deleted_object)
+        try:
+            if isinstance(objects_to_remove, models.QuerySet):
+                StaticGroupAssociation.all_objects.filter(
+                    dynamic_group=self,
+                    associated_object_type=self.content_type,
+                    associated_object_id__in=objects_to_remove.values_list("id", flat=True),
+                ).delete()
+            else:
+                pks_to_remove = [obj.id for obj in objects_to_remove]
+                StaticGroupAssociation.all_objects.filter(
+                    dynamic_group=self,
+                    associated_object_type=self.content_type,
+                    associated_object_id__in=pks_to_remove,
+                ).delete()
+        finally:
+            if self.group_type != DynamicGroupTypeChoices.TYPE_STATIC:
+                logger.debug("Re-connecting the _handle_deleted_object signal")
+                pre_delete.connect(_handle_deleted_object)
 
     @property
     @method_deprecated("Members are now cached in the database via StaticGroupAssociations rather than in Redis.")
@@ -430,6 +443,7 @@ class DynamicGroup(PrimaryModel):
             else:
                 raise RuntimeError(f"Unknown/invalid group_type {self.group_type}")
 
+        logger.debug("Refreshing members cache for %s", self)
         self._set_members(members)
         logger.debug("Refreshed cache for %s, now with %d members", self, self.count)
 

nautobot/extras/models/jobs.py

@@ -754,7 +754,7 @@ class JobResult(BaseModel, CustomFieldModel):
         grouping="main",
     ):
         """
-        General-purpose API for storing log messages in a JobResult's 'data' field.
+        General-purpose API for creating JobLogEntry records associated with a JobResult.
 
         message (str): Message to log (an attempt will be made to sanitize sensitive information from this message)
         obj (object): Object associated with this message, if any

nautobot/extras/plugins/__init__.py

@@ -94,6 +94,7 @@ class NautobotAppConfig(NautobotConfig):
     metrics = "metrics.metrics"
     menu_items = "navigation.menu_items"
     secrets_providers = "secrets.secrets_providers"
+    table_extensions = "table_extensions.table_extensions"
     template_extensions = "template_content.template_extensions"
     override_views = "views.override_views"
 
@@ -211,6 +212,9 @@ class NautobotAppConfig(NautobotConfig):
                 )
             register_override_views(override_views, self.name)
 
+        # Register tables extensions (if any).
+        self._register_table_extensions()
+
     @classmethod
     def validate(cls, user_config, nautobot_version):
         """Validate the user_config for baseline correctness."""
@@ -262,6 +266,13 @@ class NautobotAppConfig(NautobotConfig):
             if setting not in user_config and setting not in cls.constance_config:
                 user_config[setting] = value
 
+    def _register_table_extensions(self):
+        """Register tables extensions (if any)."""
+        table_extensions = import_object(f"{self.__module__}.{self.table_extensions}")
+        if table_extensions is not None:
+            register_table_extensions(table_extensions, self.name)
+            self.features["table_extensions"] = get_table_extension_features(table_extensions)
+
 
 @class_deprecated_in_favor_of(NautobotAppConfig)
 class PluginConfig(NautobotAppConfig):
@@ -491,6 +502,160 @@ def register_filter_extensions(filter_extensions, plugin_name):
                 )
 
 
+#
+# Table Extensions
+#
+
+
+class TableExtension:
+    """Template class for extending Tables.
+
+    An app can override the default columns for a table by either:
+    - Extending the original default columns to include custom columns.
+        - add_to_default_columns = ("my_app_name_new_column",)
+    - Removing native columns from the default columns.
+        - remove_from_default_columns = ("tenant",)
+    """
+
+    model = None
+    table_columns = {}
+    add_to_default_columns = ()
+    remove_from_default_columns = ()
+
+    @classmethod
+    def alter_queryset(cls, queryset):
+        """Alter the View class QuerySet.
+
+        This is a good place to add `prefetch_related` to the view queryset.
+        example:
+            return queryset.prefetch_related("my_model_set")
+        """
+        return queryset
+
+    @classmethod
+    def _get_table_columns_registrations(cls):
+        """Return a list of register labels fro each column."""
+        if not cls.table_columns:
+            return []
+        return [f"{cls.model} -> {column_name}" for column_name in cls.table_columns]
+
+    @classmethod
+    def _get_add_to_default_columns_registrations(cls):
+        """Return a list of register labels for each column added to defaults."""
+        if not cls.add_to_default_columns:
+            return []
+        return [f"{cls.model} -> {cls.add_to_default_columns}"]
+
+    @classmethod
+    def _get_remove_from_default_columns_registrations(cls):
+        """Return a list of register labels for each column removed from defaults."""
+        if not cls.remove_from_default_columns:
+            return []
+        return [f"{cls.model} -> {cls.remove_from_default_columns}"]
+
+
+def get_table_extension_features(table_extensions):
+    """Return a dictionary of TableExtension features for the App detail view."""
+    return {
+        "columns": [
+            label
+            for table_extension in table_extensions
+            for label in table_extension._get_table_columns_registrations()
+        ],
+        "add_to_default_columns": [
+            label
+            for table_extension in table_extensions
+            for label in table_extension._get_add_to_default_columns_registrations()
+        ],
+        "remove_from_default_columns": [
+            label
+            for table_extension in table_extensions
+            for label in table_extension._get_remove_from_default_columns_registrations()
+        ],
+    }
+
+
+def register_table_extensions(table_extensions, app_name):
+    """Register a list of TableExtension classes."""
+    for table_extension in table_extensions:
+        _validate_is_subclass_of_table_extension(table_extension)
+        _add_columns_into_model_table(table_extension, app_name)
+        _modify_default_table_columns(table_extension, app_name)
+        _alter_table_view_queryset(table_extension, app_name)
+
+
+def _add_columns_into_model_table(table_extension, app_name):
+    """Inject each new column into the Model Table."""
+    from nautobot.core.utils.lookup import get_table_for_model
+
+    if not isinstance(table_extension.table_columns, dict):
+        error = f"{app_name} TableExtension: 'table_columns' attribute must be of type 'dict'."
+        logger.error(error)
+        return
+
+    table = get_table_for_model(table_extension.model)
+    for name, column in table_extension.table_columns.items():
+        _validate_table_column_name_is_prefixed_with_app_name(name, app_name)
+        _add_column_to_table_base_columns(table, name, column, app_name)
+
+
+def _add_column_to_table_base_columns(table, column_name, column, app_name):
+    """Attach a column to an existing table."""
+    import django_tables2
+
+    if not isinstance(column, django_tables2.Column):
+        raise TypeError(f"Custom column `{column_name}` is not an instance of django_tables2.Column.")
+
+    if column_name in table.base_columns:
+        logger.error(
+            f"{app_name}: There was a name conflict with existing table column `{column_name}`, the custom column was ignored."
+        )
+    else:
+        table.base_columns[column_name] = column
+
+
+def _alter_table_view_queryset(table_extension, app_name):
+    """Replace the model view queryset with an optimized queryset from the app."""
+    from nautobot.core.utils.lookup import get_view_for_model
+
+    # TODO: Investigate if there is a more targeted way to patch only the list view queryset
+    # when targeting a subclass of `NautobotUIViewSet`.
+    view = get_view_for_model(table_extension.model, view_type="List")
+    view.queryset = table_extension.alter_queryset(view.queryset)
+
+
+def _modify_default_table_columns(table_extension, app_name):
+    """Add or remove columns from the table default columns."""
+    from nautobot.core.utils.lookup import get_table_for_model
+
+    table = get_table_for_model(table_extension.model)
+    message = (
+        f"{app_name}: Cannot {{action}} column `{{column_name}}` {{preposition}} the default columns for `{table}`."
+    )
+
+    for column_name in table_extension.add_to_default_columns:
+        if column_name in table.base_columns:
+            table.Meta.default_columns = (*table.Meta.default_columns, column_name)
+        else:
+            logger.debug(message.format(action="add", column_name=column_name, preposition="to"))
+
+    for column_name in table_extension.remove_from_default_columns:
+        if column_name in table.Meta.default_columns:
+            table.Meta.default_columns = tuple(name for name in table.Meta.default_columns if name != column_name)
+        else:
+            logger.debug(message.format(action="remove", column_name=column_name, preposition="from"))
+
+
+def _validate_is_subclass_of_table_extension(table_extension):
+    if not issubclass(table_extension, TableExtension):
+        raise TypeError(f"{table_extension} is not a subclass of nautobot.apps.filters.TableExtension!")
+
+
+def _validate_table_column_name_is_prefixed_with_app_name(name, app_name):
+    if not name.startswith(f"{app_name}_"):
+        raise ValueError(f"Attempted to create a custom table column `{name}` that did not start with `{app_name}`")
+
+
 #
 # Navigation menu links
 #