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

nautobot/extras/jobs.py

@@ -18,6 +18,7 @@ from db_file_storage.form_widgets import DBClearableFileInput
 from django import forms
 from django.conf import settings
 from django.contrib.auth import get_user_model
+from django.core.cache import cache
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.files.base import ContentFile
 from django.core.files.uploadedfile import UploadedFile
@@ -67,15 +68,15 @@ User = get_user_model()
 
 
 __all__ = [
-    "Job",
     "BooleanVar",
     "ChoiceVar",
     "FileVar",
-    "IntegerVar",
     "IPAddressVar",
     "IPAddressWithMaskVar",
     "IPNetworkVar",
+    "IntegerVar",
     "JSONVar",
+    "Job",
     "MultiChoiceVar",
     "MultiObjectVar",
     "ObjectVar",
@@ -105,13 +106,16 @@ class BaseJob:
 
         - name (str)
         - description (str)
-        - hidden (bool)
-        - field_order (list)
         - approval_required (bool)
-        - soft_time_limit (int)
-        - time_limit (int)
+        - dryrun_default (bool)
+        - field_order (list)
         - has_sensitive_variables (bool)
+        - hidden (bool)
+        - soft_time_limit (int)
         - task_queues (list)
+        - template_name (str)
+        - time_limit (int)
+        - is_singleton (bool)
         """
 
     def __init__(self):
@@ -189,6 +193,31 @@ class BaseJob:
             )
             raise RunJobTaskFailed(f"Job {self.job_model} is not enabled to be run!")
 
+        ignore_singleton_lock = self.celery_kwargs.get("nautobot_job_ignore_singleton_lock", False)
+        if self.job_model.is_singleton:
+            is_running = cache.get(self.singleton_cache_key)
+            if is_running:
+                if ignore_singleton_lock:
+                    self.logger.info(
+                        "Job %s is a singleton and already running, but singleton will be ignored because"
+                        " `ignore_singleton_lock` is set.",
+                        self.job_model,
+                        extra={"object": self.job_model, "grouping": "initialization"},
+                    )
+                else:
+                    self.logger.error(
+                        "Job %s is a singleton and already running.",
+                        self.job_model,
+                        extra={"object": self.job_model, "grouping": "initialization"},
+                    )
+                    raise RunJobTaskFailed(f"Job '{self.job_model}' is a singleton and already running.")
+            cache_parameters = {
+                "key": self.singleton_cache_key,
+                "value": 1,
+                "timeout": self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT,
+            }
+            cache.set(**cache_parameters)
+
         soft_time_limit = self.job_model.soft_time_limit or settings.CELERY_TASK_SOFT_TIME_LIMIT
         time_limit = self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT
         if time_limit <= soft_time_limit:
@@ -282,6 +311,14 @@ class BaseJob:
         if status == JobResultStatusChoices.STATUS_SUCCESS:
             self.logger.success("Job completed", extra={"grouping": "post_run"})
 
+        cache.delete(self.singleton_cache_key)
+
+    @final
+    @classproperty
+    def singleton_cache_key(cls) -> str:  # pylint: disable=no-self-argument
+        """Cache key for singleton jobs."""
+        return f"nautobot.extras.jobs.running.{cls.class_path}"
+
     @final
     @classproperty
     def file_path(cls) -> str:  # pylint: disable=no-self-argument
@@ -300,7 +337,7 @@ class BaseJob:
         - my_plugin.jobs.MyPluginJob - App-provided Job
         - git_repository.jobs.myjob.MyJob - GitRepository Job
         """
-        return f"{cls.__module__}.{cls.__name__}"
+        return f"{cls.__module__}.{cls.__name__}"  # pylint: disable=no-member
 
     @final
     @classproperty
@@ -337,7 +374,7 @@ class BaseJob:
     @final
     @classproperty
     def name(cls) -> str:  # pylint: disable=no-self-argument
-        return cls._get_meta_attr_and_assert_type("name", cls.__name__, expected_type=str)
+        return cls._get_meta_attr_and_assert_type("name", cls.__name__, expected_type=str)  # pylint: disable=no-member
 
     @final
     @classproperty
@@ -401,6 +438,11 @@ class BaseJob:
     def task_queues(cls) -> list:  # pylint: disable=no-self-argument
         return cls._get_meta_attr_and_assert_type("task_queues", [], expected_type=(list, tuple))
 
+    @final
+    @classproperty
+    def is_singleton(cls) -> bool:  # pylint: disable=no-self-argument
+        return cls._get_meta_attr_and_assert_type("is_singleton", False, expected_type=bool)
+
     @final
     @classproperty
     def properties_dict(cls) -> dict:  # pylint: disable=no-self-argument
@@ -419,13 +461,14 @@ class BaseJob:
             "time_limit": cls.time_limit,
             "has_sensitive_variables": cls.has_sensitive_variables,
             "task_queues": cls.task_queues,
+            "is_singleton": cls.is_singleton,
         }
 
     @final
     @classproperty
     def registered_name(cls) -> str:  # pylint: disable=no-self-argument
         """Deprecated - use class_path classproperty instead."""
-        return f"{cls.__module__}.{cls.__name__}"
+        return f"{cls.__module__}.{cls.__name__}"  # pylint: disable=no-member
 
     @classmethod
     def _get_vars(cls):
@@ -486,11 +529,29 @@ class BaseJob:
             label="Profile job execution",
             help_text="Profiles the job execution using cProfile and outputs a report to /tmp/",
         )
+        # If the class already exists there may be overrides, so we have to check this.
+        try:
+            job_model = JobModel.objects.get(module_name=cls.__module__, job_class_name=cls.__name__)
+            is_singleton = job_model.is_singleton
+        except JobModel.DoesNotExist:
+            logger.warning("No Job instance found in the database corresponding to %s", cls.class_path)
+            job_model = None
+            is_singleton = cls.is_singleton
+
+        if is_singleton:
+            form.fields["_ignore_singleton_lock"] = forms.BooleanField(
+                required=False,
+                initial=False,
+                label="Ignore singleton lock",
+                help_text="Allow this singleton job to run even when another instance is already running",
+            )
 
-        job_model = JobModel.objects.get_for_class_path(cls.class_path)
-        dryrun_default = job_model.dryrun_default if job_model.dryrun_default_override else cls.dryrun_default
-        job_queue_queryset = JobQueue.objects.filter(jobs=job_model)
-        job_queue_params = {"jobs": [job_model.pk]}
+        if job_model is not None:
+            job_queue_queryset = JobQueue.objects.filter(jobs=job_model)
+            job_queue_params = {"jobs": [job_model.pk]}
+        else:
+            job_queue_queryset = JobQueue.objects.all()
+            job_queue_params = {}
 
         # Initialize job_queue choices
         form.fields["_job_queue"] = DynamicModelChoiceField(
@@ -500,8 +561,12 @@ class BaseJob:
             help_text="The job queue to route this job to",
             label="Job queue",
         )
-        # Populate the job queue field on the JobRun Form
-        form.fields["_job_queue"].initial = job_model.default_job_queue.pk
+
+        dryrun_default = cls.dryrun_default
+        if job_model is not None:
+            form.fields["_job_queue"].initial = job_model.default_job_queue.pk
+            if job_model.dryrun_default_override:
+                dryrun_default = job_model.dryrun_default
 
         if cls.supports_dryrun and (not initial or "dryrun" not in initial):
             # Set initial "dryrun" checkbox state based on the Meta parameter
@@ -519,7 +584,9 @@ class BaseJob:
                 field.disabled = True
 
         # Ensure non-Job-specific fields are still last after applying field_order
-        for field in ["_job_queue", "_profile"]:
+        for field in ["_job_queue", "_profile", "_ignore_singleton_lock"]:
+            if field not in form.fields:
+                continue
             value = form.fields.pop(field)
             form.fields[field] = value
 
@@ -1031,7 +1098,7 @@ class JobHookReceiver(Job):
 
     object_change = ObjectVar(model=ObjectChange)
 
-    def run(self, object_change):
+    def run(self, object_change):  # pylint: disable=arguments-differ
         """JobHookReceiver subclasses generally shouldn't need to override this method."""
         self.receive_job_hook(
             change=object_change,
@@ -1060,7 +1127,7 @@ class JobButtonReceiver(Job):
     object_pk = StringVar()
     object_model_name = StringVar()
 
-    def run(self, object_pk, object_model_name):
+    def run(self, object_pk, object_model_name):  # pylint: disable=arguments-differ
         """JobButtonReceiver subclasses generally shouldn't need to override this method."""
         model = get_model_from_name(object_model_name)
         obj = model.objects.get(pk=object_pk)

nautobot/extras/managers.py

@@ -22,8 +22,9 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
             return self.model(id=task_id)
 
     @transaction_retry(max_retries=2)
-    def store_result(
+    def store_result(  # pylint:disable=arguments-differ  # Nautobot adds kwargs like job_model_id and scheduled_job_id
         self,
+        *,
         task_id,
         result,
         status,
@@ -41,6 +42,7 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
         using=None,
         content_type=None,
         content_encoding=None,
+        **kwargs,
     ):
         """
         Store the result and status of a Celery task.

nautobot/extras/migrations/0018_joblog_data_migration.py

@@ -2,7 +2,6 @@ from collections import OrderedDict
 
 from django.db import migrations
 
-from nautobot.extras.choices import LogLevelChoices
 from nautobot.extras.constants import (
     JOB_LOG_MAX_ABSOLUTE_URL_LENGTH,
     JOB_LOG_MAX_GROUPING_LENGTH,
@@ -123,14 +122,13 @@ def reverse_migrate_params(apps, schema_editor):
                 ]
             )
 
-            if entry.log_level != LogLevelChoices.LOG_DEFAULT:
-                job_result.data[entry.grouping].setdefault(entry.log_level, 0)
-                job_result.data[entry.grouping][entry.log_level] += 1
-                if "total" not in job_result.data:
-                    job_result.data["total"] = _data_grouping_struct()
-                    del job_result.data["total"]["log"]
-                job_result.data["total"].setdefault(entry.log_level, 0)
-                job_result.data["total"][entry.log_level] += 1
+            job_result.data[entry.grouping].setdefault(entry.log_level, 0)
+            job_result.data[entry.grouping][entry.log_level] += 1
+            if "total" not in job_result.data:
+                job_result.data["total"] = _data_grouping_struct()
+                del job_result.data["total"]["log"]
+            job_result.data["total"].setdefault(entry.log_level, 0)
+            job_result.data["total"][entry.log_level] += 1
 
             job_result.save()
 

nautobot/extras/migrations/0120_job_is_singleton_job_is_singleton_override.py

@@ -0,0 +1,22 @@
+# Generated by Django 4.2.16 on 2024-11-11 07:04
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0119_remove_task_queues_from_job_and_queue_from_scheduled_job"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="job",
+            name="is_singleton",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="job",
+            name="is_singleton_override",
+            field=models.BooleanField(default=False),
+        ),
+    ]

nautobot/extras/migrations/0121_alter_team_contacts.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.16 on 2024-12-03 15:32
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0120_job_is_singleton_job_is_singleton_override"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="team",
+            name="contacts",
+            field=models.ManyToManyField(blank=True, related_name="teams", to="extras.contact"),
+        ),
+    ]

nautobot/extras/migrations/0122_add_graphqlquery_owner_content_type.py

@@ -0,0 +1,34 @@
+# Generated by Django 4.2.17 on 2025-01-08 16:59
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+import nautobot.extras.utils
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("contenttypes", "0002_remove_content_type_name"),
+        ("extras", "0121_alter_team_contacts"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="graphqlquery",
+            name="owner_content_type",
+            field=models.ForeignKey(
+                blank=True,
+                default=None,
+                limit_choices_to=nautobot.extras.utils.FeatureQuery("graphql_query_owners"),
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="graphql_queries",
+                to="contenttypes.contenttype",
+            ),
+        ),
+        migrations.AddField(
+            model_name="graphqlquery",
+            name="owner_object_id",
+            field=models.UUIDField(blank=True, default=None, null=True),
+        ),
+    ]

nautobot/extras/models/__init__.py

@@ -77,8 +77,8 @@ __all__ = (
     "ObjectChange",
     "ObjectMetadata",
     "Relationship",
-    "RelationshipModel",
     "RelationshipAssociation",
+    "RelationshipModel",
     "Role",
     "RoleField",
     "SavedView",

nautobot/extras/models/contacts.py

@@ -61,7 +61,7 @@ class Contact(ContactTeamSharedBase):
 class Team(ContactTeamSharedBase):
     """A group of Contacts, usable interchangeably with a single Contact in most cases."""
 
-    contacts = models.ManyToManyField(to=Contact, related_name="teams")
+    contacts = models.ManyToManyField(to=Contact, related_name="teams", blank=True)
 
     class Meta(ContactTeamSharedBase.Meta):
         abstract = False

nautobot/extras/models/customfields.py

@@ -370,11 +370,11 @@ class CustomFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
 
     def get_for_model(self, model, exclude_filter_disabled=False):
         """
-        Return all CustomFields assigned to the given model.
+        Return (and cache) all CustomFields assigned to the given model.
 
         Args:
-            model: The django model to which custom fields are registered
-            exclude_filter_disabled: Exclude any custom fields which have filter logic disabled
+            model (Model): The django model to which custom fields are registered
+            exclude_filter_disabled (bool): Exclude any custom fields which have filter logic disabled
         """
         concrete_model = model._meta.concrete_model
         cache_key = (
@@ -521,6 +521,26 @@ class CustomField(
     def __str__(self):
         return self.label
 
+    @property
+    def choices_cache_key(self):
+        return f"nautobot.extras.customfield.choices.{self.pk}"
+
+    @property
+    def choices(self) -> list[str]:
+        """
+        Cacheable shorthand for retrieving custom_field_choices values associated with this model.
+
+        Returns:
+            list[str]: List of choice values, ordered by weight.
+        """
+        if self.type not in [CustomFieldTypeChoices.TYPE_SELECT, CustomFieldTypeChoices.TYPE_MULTISELECT]:
+            return []
+        choices = cache.get(self.choices_cache_key)
+        if choices is None:
+            choices = list(self.custom_field_choices.order_by("weight", "value").values_list("value", flat=True))
+            cache.set(self.choices_cache_key, choices)
+        return choices
+
     def save(self, *args, **kwargs):
         self.clean()
         super().save(*args, **kwargs)
@@ -578,7 +598,13 @@ class CustomField(
             )
 
     def to_form_field(
-        self, set_initial=True, enforce_required=True, for_csv_import=False, simple_json_filter=False, label=None
+        self,
+        set_initial=True,
+        enforce_required=True,
+        for_csv_import=False,
+        simple_json_filter=False,
+        label=None,
+        for_filter_form=False,
     ):
         """
         Return a form field suitable for setting a CustomField's value for an object.
@@ -590,6 +616,7 @@ class CustomField(
                 this is *not* used for CSV imports since 2.0, but it *is* used for JSON/YAML import of DeviceTypes.
             simple_json_filter: Return a TextInput widget for JSON filtering instead of the default TextArea widget.
             label: Set the input label manually (if required); otherwise, defaults to field's __str__() implementation.
+            for_filter_form: If True return the relevant form field for filter form
         """
         initial = self.default if set_initial else None
         required = self.required if enforce_required else False
@@ -672,12 +699,11 @@ class CustomField(
 
         # Select or Multi-select
         else:
-            choices = [(cfc.value, cfc.value) for cfc in self.custom_field_choices.all()]
-            default_choice = self.custom_field_choices.filter(value=self.default).first()
+            choices = [(value, value) for value in self.choices]
 
             # Set the initial value to the first available choice (if any)
-            if self.type == CustomFieldTypeChoices.TYPE_SELECT:
-                if not required or default_choice is None:
+            if self.type == CustomFieldTypeChoices.TYPE_SELECT and not for_filter_form:
+                if not required or self.default not in self.choices:
                     choices = add_blank_choice(choices)
                 field_class = CSVChoiceField if for_csv_import else forms.ChoiceField
                 field = field_class(
@@ -704,16 +730,10 @@ class CustomField(
 
     def to_filter_form_field(self, lookup_expr="exact", *args, **kwargs):
         """Return a filter form field suitable for filtering a CustomField's value for an object."""
-        form_field = self.to_form_field(*args, **kwargs)
-        # We would handle type selection differently because:
-        # 1. We'd need to use StaticSelect2Multiple for lookup_type 'exact' because self.type `select` uses StaticSelect2 by default.
-        # 2. Remove the blank choice since StaticSelect2Multiple is always blank and interprets the blank choice as an extra option.
-        # 3. If lookup_type is not the same as exact, use MultiValueCharInput
+        form_field = self.to_form_field(*args, **kwargs, for_filter_form=True)
+        # We would handle type selection differently because: If lookup_type is not the same as exact, use MultiValueCharInput
         if self.type == CustomFieldTypeChoices.TYPE_SELECT:
-            if lookup_expr in ["exact", "contains"]:
-                choices = form_field.choices[1:]
-                form_field.widget = StaticSelect2Multiple(choices=choices)
-            else:
+            if lookup_expr not in ["exact", "contains"]:
                 form_field.widget = MultiValueCharInput()
         return form_field
 
@@ -778,17 +798,15 @@ class CustomField(
 
             # Validate selected choice
             elif self.type == CustomFieldTypeChoices.TYPE_SELECT:
-                if value not in self.custom_field_choices.values_list("value", flat=True):
-                    raise ValidationError(
-                        f"Invalid choice ({value}). Available choices are: {', '.join(self.custom_field_choices.values_list('value', flat=True))}"
-                    )
+                if value not in self.choices:
+                    raise ValidationError(f"Invalid choice ({value}). Available choices are: {', '.join(self.choices)}")
 
             elif self.type == CustomFieldTypeChoices.TYPE_MULTISELECT:
                 if isinstance(value, str):
                     value = value.split(",")
-                if not set(value).issubset(self.custom_field_choices.values_list("value", flat=True)):
+                if not set(value).issubset(self.choices):
                     raise ValidationError(
-                        f"Invalid choice(s) ({value}). Available choices are: {', '.join(self.custom_field_choices.values_list('value', flat=True))}"
+                        f"Invalid choice(s) ({value}). Available choices are: {', '.join(self.choices)}"
                     )
 
         elif self.required:

nautobot/extras/models/datasources.py

@@ -1,7 +1,11 @@
 """Models for representing external data sources."""
 
+from contextlib import contextmanager
 from importlib.util import find_spec
+import logging
 import os
+import shutil
+import tempfile
 
 from django.conf import settings
 from django.core.exceptions import ValidationError
@@ -12,12 +16,16 @@ from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.models.fields import AutoSlugField, LaxURLField, slugify_dashes_to_underscores
 from nautobot.core.models.generics import PrimaryModel
 from nautobot.core.models.validators import EnhancedURLValidator
+from nautobot.core.utils.git import GitRepo
 from nautobot.extras.utils import check_if_key_is_graphql_safe, extras_features
 
+logger = logging.getLogger(__name__)
+
 
 @extras_features(
     "config_context_owners",
     "export_template_owners",
+    "graphql_query_owners",
     "graphql",
     "job_results",
     "webhooks",
@@ -167,3 +175,80 @@ class GitRepository(PrimaryModel):
         if dry_run:
             return enqueue_git_repository_diff_origin_and_local(self, user)
         return enqueue_pull_git_repository_and_refresh_data(self, user)
+
+    @contextmanager
+    def clone_to_directory_context(self, path=None, branch=None, head=None, depth=0):
+        """
+        Context manager to perform a (shallow or full) clone of the Git repository in a temporary directory.
+
+        Args:
+            path (str, optional): The absolute directory path to clone into. If not specified, `tempfile.gettempdir()` will be used.
+            branch (str, optional): The branch to checkout. If not set, the GitRepository.branch will be used.
+            head (str, optional): Git commit hash to check out instead of pulling branch latest.
+            depth (int, optional): The depth of the clone. If set to 0, a full clone will be performed.
+
+        Returns:
+            Returns the absolute path of the cloned repo if clone was successful, otherwise returns None.
+        """
+
+        if branch and head:
+            raise ValueError("Cannot specify both branch and head")
+
+        path_name = None
+        try:
+            path_name = self.clone_to_directory(path=path, branch=branch, head=head, depth=depth)
+            yield path_name
+        finally:
+            # Cleanup the temporary directory
+            if path_name:
+                self.cleanup_cloned_directory(path_name)
+
+    def clone_to_directory(self, path=None, branch=None, head=None, depth=0):
+        """
+        Perform a (shallow or full) clone of the Git repository in a temporary directory.
+
+        Args:
+            path (str, optional): The absolute directory path to clone into. If not specified, `tempfile.gettempdir()` will be used.
+            branch (str, optional): The branch to checkout. If not set, the GitRepository.branch will be used.
+            head (str, optional): Git commit hash to check out instead of pulling branch latest.
+            depth (int, optional): The depth of the clone. If set to 0, a full clone will be performed.
+
+        Returns:
+            Returns the absolute path of the cloned repo if clone was successful, otherwise returns None.
+        """
+        if branch and head:
+            raise ValueError("Cannot specify both branch and head")
+
+        try:
+            path_name = tempfile.mkdtemp(dir=path, prefix=self.slug)
+        except PermissionError as e:
+            logger.error(f"Failed to create temporary directory at {path}: {e}")
+            raise e
+
+        if not branch:
+            branch = self.branch
+
+        try:
+            repo_helper = GitRepo(path_name, self.remote_url, depth=depth, branch=branch)
+            if head:
+                repo_helper.checkout(branch, head)
+        except Exception as e:
+            logger.error(f"Failed to clone repository {self.name} to {path_name}: {e}")
+            raise e
+
+        logger.info(f"Cloned repository {self.name} to {path_name}")
+        return path_name
+
+    def cleanup_cloned_directory(self, path):
+        """
+        Cleanup the cloned directory.
+
+        Args:
+            path (str): The absolute directory path to cleanup.
+        """
+
+        try:
+            shutil.rmtree(path)
+        except OSError as os_error:
+            # log error if the cleanup fails
+            logger.error(f"Failed to cleanup temporary directory at {path}: {os_error}")

nautobot/extras/models/groups.py

@@ -1,6 +1,7 @@
 """Dynamic Groups Models."""
 
 import logging
+from typing import Optional
 
 from django import forms
 from django.contrib.contenttypes.fields import GenericForeignKey
@@ -116,7 +117,7 @@ class DynamicGroup(PrimaryModel):
         return self._model
 
     @property
-    def filterset_class(self):
+    def filterset_class(self) -> Optional[type[django_filters.FilterSet]]:
         if getattr(self, "_filterset_class", None) is None:
             try:
                 self._filterset_class = get_filterset_for_model(self.model)
@@ -125,7 +126,7 @@ class DynamicGroup(PrimaryModel):
         return self._filterset_class
 
     @property
-    def filterform_class(self):
+    def filterform_class(self) -> Optional[type[forms.Form]]:
         if getattr(self, "_filterform_class", None) is None:
             try:
                 self._filterform_class = get_form_for_model(self.model, form_prefix="Filter")
@@ -134,7 +135,7 @@ class DynamicGroup(PrimaryModel):
         return self._filterform_class
 
     @property
-    def form_class(self):
+    def form_class(self) -> Optional[type[forms.Form]]:
         if getattr(self, "_form_class", None) is None:
             try:
                 self._form_class = get_form_for_model(self.model)
@@ -147,19 +148,19 @@ class DynamicGroup(PrimaryModel):
         """Return all FilterForm fields in a dictionary."""
 
         # Fail gracefully with an empty dict if nothing is working yet.
-        if not self.form_class:
+        if self.form_class is None or self.filterform_class is None or self.filterset_class is None:
             return {}
 
         # Get model form and fields
-        modelform = self.form_class()
+        modelform = self.form_class()  # pylint: disable=not-callable
         modelform_fields = modelform.fields
 
         # Get filter form and fields
-        filterform = self.filterform_class()
+        filterform = self.filterform_class()  # pylint: disable=not-callable
         filterform_fields = filterform.fields
 
         # Get filterset and fields
-        filterset = self.filterset_class()
+        filterset = self.filterset_class()  # pylint: disable=not-callable
         filterset_fields = filterset.filters
 
         # Get dynamic group filter field mappings (if any)
@@ -303,6 +304,7 @@ class DynamicGroup(PrimaryModel):
         # Since associated_object is a GenericForeignKey, we can't just do:
         #     return self.static_group_associations.values_list("associated_object", flat=True)
         return self.model.objects.filter(
+            # pylint: disable=no-member  # false positive about self.static_group_associations
             pk__in=self.static_group_associations(manager="all_objects").values_list("associated_object_id", flat=True)
         )
 
@@ -611,7 +613,7 @@ class DynamicGroup(PrimaryModel):
                 raise ValidationError({"filter": "Filter can only be set for groups of type `dynamic-filter`."})
         else:
             # Validate against the filterset's internal form validation.
-            filterset = self.filterset_class(self.filter)
+            filterset = self.filterset_class(self.filter)  # pylint: disable=not-callable
             if not filterset.is_valid():
                 raise ValidationError(filterset.errors)
 
@@ -725,7 +727,7 @@ class DynamicGroup(PrimaryModel):
         if self.group_type != DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER:
             raise RuntimeError(f"{self} is not a dynamic-filter group")
 
-        filterset = self.filterset_class(self.filter, self.model.objects.all())
+        filterset = self.filterset_class(self.filter, self.model.objects.all())  # pylint: disable=not-callable
         query = models.Q()
 
         # In this case we want all filters for a group's filter dict in a set intersection (boolean