nautobot 2.3.8__py3-none-any.whl → 2.3.10__py3-none-any.whl

nautobot/dcim/templates/dcim/modulebay_create.html

@@ -0,0 +1,39 @@
+{% extends 'dcim/device_component_add.html' %}
+
+{% block javascript %}
+{{ block.super }}
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    var position_field = document.getElementById('id_position_pattern');
+    var source_arr = position_field.getAttribute('source').split(" ");
+    var length = position_field.getAttribute('maxlength');
+    position_field.setAttribute('_changed', Boolean(position_field.value))
+    position_field.addEventListener('change', function() {
+        position_field.setAttribute('_changed', Boolean(position_field.value))
+    });
+    function repopulate() {
+        let str = "";
+        for (source_str of source_arr) {
+            if (str != "") {
+                str += " ";
+            }
+            let source_id = 'id_' + source_str;
+            let source = document.getElementById(source_id)
+            str += source.value;
+        }
+        position_field.value = str.slice(0, length ? length : 255);
+    };
+    for (source_str of source_arr) {
+        let source_id = 'id_' + source_str;
+        let source = document.getElementById(source_id);
+        source.addEventListener('keyup', function() {
+            if (position_field && position_field.getAttribute('_changed')=="false") {
+                repopulate();
+            }
+        });
+    }
+    document.getElementsByClassName('reslugify')[0].addEventListener('click', repopulate);
+    document.getElementsByClassName('reslugify')[0].setAttribute('data-original-title', "Regenerate position");
+});
+</script>
+{% endblock javascript %}

nautobot/dcim/templates/dcim/modulebay_update.html

@@ -0,0 +1,39 @@
+{% extends 'generic/object_create.html' %}
+
+{% block javascript %}
+{{ block.super }}
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    var position_field = document.getElementById('id_position');
+    var source_arr = position_field.getAttribute('source').split(" ");
+    var length = position_field.getAttribute('maxlength');
+    position_field.setAttribute('_changed', Boolean(position_field.value))
+    position_field.addEventListener('change', function() {
+        position_field.setAttribute('_changed', Boolean(position_field.value))
+    });
+    function repopulate() {
+        let str = "";
+        for (source_str of source_arr) {
+            if (str != "") {
+                str += " ";
+            }
+            let source_id = 'id_' + source_str;
+            let source = document.getElementById(source_id)
+            str += source.value;
+        }
+        position_field.value = str.slice(0, length ? length : 255);
+    };
+    for (source_str of source_arr) {
+        let source_id = 'id_' + source_str;
+        let source = document.getElementById(source_id);
+        source.addEventListener('keyup', function() {
+            if (position_field && position_field.getAttribute('_changed')=="false") {
+                repopulate();
+            }
+        });
+    }
+    document.getElementsByClassName('reslugify')[0].addEventListener('click', repopulate);
+    document.getElementsByClassName('reslugify')[0].setAttribute('data-original-title', "Regenerate position");
+});
+</script>
+{% endblock javascript %}

nautobot/dcim/tests/test_models.py

@@ -2849,6 +2849,22 @@ class ModuleBayTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         self.assertIsNone(child_module_bay.parent)
         self.assertIsNone(grandchild_module_bay.parent)
 
+    def test_position_value_auto_population(self):
+        """
+        Assert that the value of the module bay position is auto-populated by its name if position is not provided by the user.
+        """
+
+        module_bay = ModuleBay.objects.create(
+            parent_device=self.device,
+            name="1111",
+        )
+        module_bay.validated_save()
+        self.assertEqual(module_bay.position, module_bay.name)
+        # Test the default value is overriden if the user provides a position value.
+        module_bay.position = "1222"
+        module_bay.validated_save()
+        self.assertEqual(module_bay.position, "1222")
+
 
 class ModuleBayTemplateTestCase(ModularDeviceComponentTemplateTestCaseMixin, ModelTestCases.BaseModelTestCase):
     model = ModuleBayTemplate

nautobot/dcim/views.py

@@ -3241,7 +3241,7 @@ class ModuleBayUIViewSet(ModuleBayCommonViewSetMixin, NautobotUIViewSet):
     model_form_class = forms.ModuleBayForm
     serializer_class = serializers.ModuleBaySerializer
     table_class = tables.ModuleBayTable
-    create_template_name = "dcim/device_component_add.html"
+    create_template_name = "dcim/modulebay_create.html"
 
     def get_extra_context(self, request, instance):
         if instance:

nautobot/extras/api/customfields.py

@@ -40,15 +40,7 @@ class CustomFieldDefaultValues:
 class CustomFieldsDataField(Field):
     @property
     def custom_field_keys(self):
-        """
-        Cache CustomField keys assigned to this model to avoid redundant database queries
-        """
-        if not hasattr(self, "_custom_field_keys"):
-            content_type = ContentType.objects.get_for_model(self.parent.Meta.model)
-            self._custom_field_keys = CustomField.objects.filter(content_types=content_type).values_list(
-                "key", flat=True
-            )
-        return self._custom_field_keys
+        return CustomField.objects.keys_for_model(self.parent.Meta.model)
 
     def to_representation(self, obj):
         return {key: obj.get(key) for key in self.custom_field_keys}
@@ -58,7 +50,8 @@ class CustomFieldsDataField(Field):
 
         # Discard any entries in data that do not align with actual CustomFields - this matches the REST API behavior
         # for top-level serializer fields that do not exist or are not writable
-        data = {key: value for key, value in data.items() if key in self.custom_field_keys}
+        custom_field_keys = self.custom_field_keys
+        data = {key: value for key, value in data.items() if key in custom_field_keys}
 
         # If updating an existing instance, start with existing _custom_field_data
         if self.parent.instance:

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,16 +203,35 @@ def web_request_context(
         with change_logging(change_context):
             yield request
     finally:
-        jobs_refreshed = False
+        jobs_reloaded = False
+        # In bulk operations, we are performing the same action (create/update/delete) on the same content-type.
+        # Save some repeated database queries by reusing the same evaluated querysets where applicable:
+        jobhook_queryset = None
+        webhook_queryset = None
+        last_action = None
+        last_content_type = None
         # 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.select_related("changed_object_type", "user")
+            .filter(request_id=change_context.change_id)
+            .order_by("time")  # default ordering is -time but we want oldest first not newest first
+            .iterator()
+        ):
+            if object_change.action != last_action or object_change.changed_object_type != last_content_type:
+                jobhook_queryset = None
+                webhook_queryset = None
+
             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)
-            enqueue_webhooks(object_change)
+                # Make sure JobHooks are up to date (only once) before calling them
+                did_reload_jobs, jobhook_queryset = enqueue_job_hooks(
+                    object_change, may_reload_jobs=(not jobs_reloaded), jobhook_queryset=jobhook_queryset
+                )
+                if did_reload_jobs:
+                    jobs_reloaded = True
+
+            webhook_queryset = enqueue_webhooks(object_change, webhook_queryset=webhook_queryset)
+            last_action = object_change.action
+            last_content_type = object_change.changed_object_type
 
 
 @contextmanager

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,31 +1144,47 @@ 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, jobhook_queryset=None):
     """
-    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.
+
+    Args:
+        object_change (ObjectChange): The change that may trigger JobHooks to execute.
+        may_reload_jobs (bool): Whether to reload JobHook source code from disk to guarantee up-to-date code.
+        jobhook_queryset (QuerySet): Previously retrieved set of JobHooks to potentially enqueue
+
+    Returns:
+        result (tuple[bool, QuerySet]): whether Jobs were reloaded here, and the jobhooks that were considered
     """
+    jobs_reloaded = False
 
     # Job hooks cannot trigger other job hooks
     if object_change.change_context == ObjectChangeEventContextChoices.CONTEXT_JOB_HOOK:
-        return
+        return jobs_reloaded, jobhook_queryset
 
     # 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, jobhook_queryset
 
     # Retrieve any applicable job hooks
-    action_flag = {
-        ObjectChangeActionChoices.ACTION_CREATE: "type_create",
-        ObjectChangeActionChoices.ACTION_UPDATE: "type_update",
-        ObjectChangeActionChoices.ACTION_DELETE: "type_delete",
-    }[object_change.action]
-    job_hooks = JobHook.objects.filter(content_types=content_type, enabled=True, **{action_flag: True})
+    if jobhook_queryset is None:
+        action_flag = {
+            ObjectChangeActionChoices.ACTION_CREATE: "type_create",
+            ObjectChangeActionChoices.ACTION_UPDATE: "type_update",
+            ObjectChangeActionChoices.ACTION_DELETE: "type_delete",
+        }[object_change.action]
+        jobhook_queryset = JobHook.objects.filter(content_types=content_type, enabled=True, **{action_flag: True})
+
+    if not jobhook_queryset:  # not .exists() as we *want* to populate the queryset cache
+        return jobs_reloaded, jobhook_queryset
 
     # Enqueue the jobs related to the job_hooks
-    for job_hook in job_hooks:
+    if may_reload_jobs:
+        get_jobs(reload=True)
+        jobs_reloaded = True
+
+    for job_hook in jobhook_queryset:
         job_model = job_hook.job
         if not job_model.installed or not job_model.enabled:
             logger.warning(
@@ -1178,3 +1194,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, jobhook_queryset

nautobot/extras/models/customfields.py

@@ -391,6 +391,18 @@ class CustomFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
 
     get_for_model.cache_key_prefix = "nautobot.extras.customfield.get_for_model"
 
+    def keys_for_model(self, model):
+        """Return list of all keys for CustomFields assigned to the given model."""
+        concrete_model = model._meta.concrete_model
+        cache_key = f"{self.keys_for_model.cache_key_prefix}.{concrete_model._meta.label_lower}"
+        keys = cache.get(cache_key)
+        if keys is None:
+            keys = list(self.get_for_model(model).values_list("key", flat=True))
+            cache.set(cache_key, keys)
+        return keys
+
+    keys_for_model.cache_key_prefix = "nautobot.extras.customfield.keys_for_model"
+
 
 @extras_features("webhooks")
 class CustomField(

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