nautobot 2.3.15b1__py3-none-any.whl → 2.3.16__py3-none-any.whl

nautobot/extras/api/serializers.py

@@ -212,13 +212,13 @@ class ContactSerializer(NautobotModelSerializer):
             "phone": {"default": ""},
         }
 
-    def validate(self, data):
-        attrs = data.copy()
-        attrs.pop("teams", None)
+    def validate(self, attrs):
+        local_attrs = attrs.copy()
+        local_attrs.pop("teams", None)
         validator = UniqueTogetherValidator(queryset=Contact.objects.all(), fields=("name", "phone", "email"))
-        validator(attrs, self)
-        super().validate(attrs)
-        return data
+        validator(local_attrs, self)
+        super().validate(local_attrs)
+        return attrs
 
 
 class ContactAssociationSerializer(NautobotModelSerializer):
@@ -233,18 +233,18 @@ class ContactAssociationSerializer(NautobotModelSerializer):
             "team": {"required": False},
         }
 
-    def validate(self, data):
+    def validate(self, attrs):
         # Validate uniqueness of (associated object, associated object type, contact/team, role)
         unique_together_fields = None
 
-        if data.get("contact") and data.get("role"):
+        if attrs.get("contact") and attrs.get("role"):
             unique_together_fields = (
                 "associated_object_type",
                 "associated_object_id",
                 "contact",
                 "role",
             )
-        elif data.get("team") and data.get("role"):
+        elif attrs.get("team") and attrs.get("role"):
             unique_together_fields = (
                 "associated_object_type",
                 "associated_object_id",
@@ -257,11 +257,11 @@ class ContactAssociationSerializer(NautobotModelSerializer):
                 queryset=ContactAssociation.objects.all(),
                 fields=unique_together_fields,
             )
-            validator(data, self)
+            validator(attrs, self)
 
-        super().validate(data)
+        super().validate(attrs)
 
-        return data
+        return attrs
 
 
 #
@@ -279,8 +279,8 @@ class ContentTypeSerializer(BaseModelSerializer):
         fields = "__all__"
 
     @extend_schema_field(serializers.CharField)
-    def get_display(self, obj):
-        return obj.app_labeled_name
+    def get_display(self, instance):
+        return instance.app_labeled_name
 
 
 #
@@ -501,17 +501,17 @@ class ImageAttachmentSerializer(ValidatedModelSerializer):
         model = ImageAttachment
         fields = "__all__"
 
-    def validate(self, data):
+    def validate(self, attrs):
         # Validate that the parent object exists
         try:
-            data["content_type"].get_object_for_this_type(id=data["object_id"])
+            attrs["content_type"].get_object_for_this_type(id=attrs["object_id"])
         except ObjectDoesNotExist:
-            raise serializers.ValidationError(f"Invalid parent object: {data['content_type']} ID {data['object_id']}")
+            raise serializers.ValidationError(f"Invalid parent object: {attrs['content_type']} ID {attrs['object_id']}")
 
         # Enforce model validation
-        super().validate(data)
+        super().validate(attrs)
 
-        return data
+        return attrs
 
     @extend_schema_field(
         PolymorphicProxySerializer(
@@ -539,24 +539,24 @@ class JobSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
         model = Job
         fields = "__all__"
 
-    def validate(self, data):
+    def validate(self, attrs):
         # note no validation for on creation of jobs because we do not support user creation of Job records via API
         if self.instance:
-            has_sensitive_variables = data.get("has_sensitive_variables", self.instance.has_sensitive_variables)
-            approval_required = data.get("approval_required", self.instance.approval_required)
+            has_sensitive_variables = attrs.get("has_sensitive_variables", self.instance.has_sensitive_variables)
+            approval_required = attrs.get("approval_required", self.instance.approval_required)
 
             if approval_required and has_sensitive_variables:
                 error_message = "A job with sensitive variables cannot also be marked as requiring approval"
                 errors = {}
 
-                if "approval_required" in data:
+                if "approval_required" in attrs:
                     errors["approval_required"] = [error_message]
-                if "has_sensitive_variables" in data:
+                if "has_sensitive_variables" in attrs:
                     errors["has_sensitive_variables"] = [error_message]
 
                 raise serializers.ValidationError(errors)
 
-        return super().validate(data)
+        return super().validate(attrs)
 
 
 class JobVariableSerializer(serializers.Serializer):
@@ -668,22 +668,22 @@ class JobHookSerializer(NautobotModelSerializer):
         model = JobHook
         fields = "__all__"
 
-    def validate(self, data):
-        validated_data = super().validate(data)
+    def validate(self, attrs):
+        validated_attrs = super().validate(attrs)
 
         conflicts = JobHook.check_for_conflicts(
             instance=self.instance,
-            content_types=data.get("content_types"),
-            job=data.get("job"),
-            type_create=data.get("type_create"),
-            type_update=data.get("type_update"),
-            type_delete=data.get("type_delete"),
+            content_types=attrs.get("content_types"),
+            job=attrs.get("job"),
+            type_create=attrs.get("type_create"),
+            type_update=attrs.get("type_update"),
+            type_delete=attrs.get("type_delete"),
         )
 
         if conflicts:
             raise serializers.ValidationError(conflicts)
 
-        return validated_data
+        return validated_attrs
 
 
 class JobCreationSerializer(BaseModelSerializer):
@@ -702,15 +702,15 @@ class JobCreationSerializer(BaseModelSerializer):
         model = ScheduledJob
         fields = ["url", "name", "start_time", "interval", "crontab"]
 
-    def validate(self, data):
-        data = super().validate(data)
+    def validate(self, attrs):
+        attrs = super().validate(attrs)
 
-        if data["interval"] in choices.JobExecutionType.SCHEDULE_CHOICES:
-            if "name" not in data:
+        if attrs["interval"] in choices.JobExecutionType.SCHEDULE_CHOICES:
+            if "name" not in attrs:
                 raise serializers.ValidationError({"name": "Please provide a name for the job schedule."})
 
-            if ("start_time" not in data and data["interval"] != choices.JobExecutionType.TYPE_CUSTOM) or (
-                "start_time" in data and data["start_time"] < models.ScheduledJob.earliest_possible_time()
+            if ("start_time" not in attrs and attrs["interval"] != choices.JobExecutionType.TYPE_CUSTOM) or (
+                "start_time" in attrs and attrs["start_time"] < models.ScheduledJob.earliest_possible_time()
             ):
                 raise serializers.ValidationError(
                     {
@@ -718,15 +718,15 @@ class JobCreationSerializer(BaseModelSerializer):
                     }
                 )
 
-            if data["interval"] == choices.JobExecutionType.TYPE_CUSTOM:
-                if data.get("crontab") is None:
+            if attrs["interval"] == choices.JobExecutionType.TYPE_CUSTOM:
+                if attrs.get("crontab") is None:
                     raise serializers.ValidationError({"crontab": "Please enter a valid crontab."})
                 try:
-                    models.ScheduledJob.get_crontab(data["crontab"])
+                    models.ScheduledJob.get_crontab(attrs["crontab"])
                 except Exception as e:
                     raise serializers.ValidationError({"crontab": e})
 
-        return data
+        return attrs
 
 
 class JobInputSerializer(serializers.Serializer):
@@ -744,15 +744,18 @@ class JobMultiPartInputSerializer(serializers.Serializer):
     _schedule_crontab = serializers.CharField(required=False, allow_blank=True)
     _task_queue = serializers.CharField(required=False, allow_blank=True)
 
-    def validate(self, data):
-        data = super().validate(data)
+    def validate(self, attrs):
+        attrs = super().validate(attrs)
 
-        if "_schedule_interval" in data and data["_schedule_interval"] != JobExecutionType.TYPE_IMMEDIATELY:
-            if "_schedule_name" not in data:
+        if "_schedule_interval" in attrs and attrs["_schedule_interval"] != JobExecutionType.TYPE_IMMEDIATELY:
+            if "_schedule_name" not in attrs:
                 raise serializers.ValidationError({"_schedule_name": "Please provide a name for the job schedule."})
 
-            if ("_schedule_start_time" not in data and data["_schedule_interval"] != JobExecutionType.TYPE_CUSTOM) or (
-                "_schedule_start_time" in data and data["_schedule_start_time"] < ScheduledJob.earliest_possible_time()
+            if (
+                "_schedule_start_time" not in attrs and attrs["_schedule_interval"] != JobExecutionType.TYPE_CUSTOM
+            ) or (
+                "_schedule_start_time" in attrs
+                and attrs["_schedule_start_time"] < ScheduledJob.earliest_possible_time()
             ):
                 raise serializers.ValidationError(
                     {
@@ -760,15 +763,15 @@ class JobMultiPartInputSerializer(serializers.Serializer):
                     }
                 )
 
-            if data["_schedule_interval"] == JobExecutionType.TYPE_CUSTOM:
-                if data.get("_schedule_crontab") is None:
+            if attrs["_schedule_interval"] == JobExecutionType.TYPE_CUSTOM:
+                if attrs.get("_schedule_crontab") is None:
                     raise serializers.ValidationError({"_schedule_crontab": "Please enter a valid crontab."})
                 try:
-                    ScheduledJob.get_crontab(data["_schedule_crontab"])
+                    ScheduledJob.get_crontab(attrs["_schedule_crontab"])
                 except Exception as e:
                     raise serializers.ValidationError({"_schedule_crontab": e})
 
-        return data
+        return attrs
 
 
 class JobLogEntrySerializer(BaseModelSerializer):
@@ -1054,18 +1057,18 @@ class TagSerializer(NautobotModelSerializer):
             "color": {"help_text": "RGB color in hexadecimal (e.g. 00ff00)"},
         }
 
-    def validate(self, data):
-        data = super().validate(data)
+    def validate(self, attrs):
+        attrs = super().validate(attrs)
 
         # check if tag is assigned to any of the removed content_types
-        if self.instance is not None and self.instance.present_in_database and "content_types" in data:
-            content_types_id = [content_type.id for content_type in data["content_types"]]
+        if self.instance is not None and self.instance.present_in_database and "content_types" in attrs:
+            content_types_id = [content_type.id for content_type in attrs["content_types"]]
             errors = self.instance.validate_content_types_removal(content_types_id)
 
             if errors:
                 raise serializers.ValidationError(errors)
 
-        return data
+        return attrs
 
 
 #
@@ -1087,10 +1090,10 @@ class TeamSerializer(NautobotModelSerializer):
         # https://www.django-rest-framework.org/api-guide/validators/#optional-fields
         validators = []
 
-    def validate(self, data):
+    def validate(self, attrs):
         validator = UniqueTogetherValidator(queryset=Team.objects.all(), fields=("name", "phone", "email"))
-        validator(data, self)
-        return super().validate(data)
+        validator(attrs, self)
+        return super().validate(attrs)
 
 
 #
@@ -1108,19 +1111,19 @@ class WebhookSerializer(ValidatedModelSerializer, NotesSerializerMixin):
         model = Webhook
         fields = "__all__"
 
-    def validate(self, data):
-        validated_data = super().validate(data)
+    def validate(self, attrs):
+        validated_attrs = super().validate(attrs)
 
         conflicts = Webhook.check_for_conflicts(
             instance=self.instance,
-            content_types=data.get("content_types"),
-            payload_url=data.get("payload_url"),
-            type_create=data.get("type_create"),
-            type_update=data.get("type_update"),
-            type_delete=data.get("type_delete"),
+            content_types=attrs.get("content_types"),
+            payload_url=attrs.get("payload_url"),
+            type_create=attrs.get("type_create"),
+            type_update=attrs.get("type_update"),
+            type_delete=attrs.get("type_delete"),
         )
 
         if conflicts:
             raise serializers.ValidationError(conflicts)
 
-        return validated_data
+        return validated_attrs

nautobot/extras/api/views.py

@@ -732,13 +732,13 @@ class JobViewSet(
 ):
     lookup_value_regex = r"[-0-9a-fA-F]+"
 
-    def perform_destroy(self, obj):
-        if obj.module_name.startswith("nautobot."):
+    def perform_destroy(self, instance):
+        if instance.module_name.startswith("nautobot."):
             raise ProtectedError(
-                f"Unable to delete Job {obj}. System Job cannot be deleted",
+                f"Unable to delete Job {instance}. System Job cannot be deleted",
                 [],
             )
-        super().perform_destroy(obj)
+        super().perform_destroy(instance)
 
 
 @extend_schema_view(

nautobot/extras/forms/mixins.py

@@ -837,7 +837,7 @@ class StatusModelFilterFormMixin(forms.Form):
         self.order_fields(self.field_order)  # Reorder fields again
 
 
-class TagsBulkEditFormMixin(forms.Form):
+class TagsBulkEditFormMixin(BulkEditForm):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 

nautobot/extras/health_checks.py

@@ -160,5 +160,4 @@ class RedisBackend(RedisHealthCheck):
         elif client_class == "django_redis.client.DefaultClient":
             self.check_redis(redis_url=location, **options.get("CONNECTION_POOL_KWARGS", {}))
         else:
-            if self.redis_url is None:
-                self.add_error(ServiceUnavailable(f"{client_class} is an unsupported CLIENT_CLASS!"))
+            self.add_error(ServiceUnavailable(f"{client_class} is an unsupported CLIENT_CLASS!"))

nautobot/extras/jobs.py

@@ -295,7 +295,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
@@ -332,7 +332,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
@@ -420,7 +420,7 @@ class BaseJob:
     @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):
@@ -1011,7 +1011,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,
@@ -1040,7 +1040,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/models/customfields.py

@@ -578,7 +578,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 +596,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
@@ -676,7 +683,7 @@ class CustomField(
             default_choice = self.custom_field_choices.filter(value=self.default).first()
 
             # Set the initial value to the first available choice (if any)
-            if self.type == CustomFieldTypeChoices.TYPE_SELECT:
+            if self.type == CustomFieldTypeChoices.TYPE_SELECT and not for_filter_form:
                 if not required or default_choice is None:
                     choices = add_blank_choice(choices)
                 field_class = CSVChoiceField if for_csv_import else forms.ChoiceField
@@ -704,16 +711,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
 

nautobot/extras/models/groups.py

@@ -1,6 +1,9 @@
 """Dynamic Groups Models."""
 
+from __future__ import annotations  # python 3.8
+
 import logging
+from typing import Optional
 
 from django import forms
 from django.contrib.contenttypes.fields import GenericForeignKey
@@ -116,7 +119,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 +128,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 +137,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 +150,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 +306,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 +615,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 +729,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

nautobot/extras/models/jobs.py

@@ -234,13 +234,13 @@ class Job(PrimaryModel):
     def __str__(self):
         return self.name
 
-    def delete(self):
+    def delete(self, *args, **kwargs):
         if self.module_name.startswith("nautobot."):
             raise ProtectedError(
                 f"Unable to delete Job {self}. System Job cannot be deleted",
                 [],
             )
-        super().delete()
+        super().delete(*args, **kwargs)
 
     @property
     def job_class(self):
@@ -610,7 +610,7 @@ class JobResult(BaseModel, CustomFieldModel):
             # Only add metrics if we have a related job model. If we are moving to a terminal state we should always
             # have a related job model, so this shouldn't be too tight of a restriction.
             if self.job_model:
-                duration = self.date_done - self.created
+                duration = self.date_done - self.date_created
                 JOB_RESULT_METRIC.labels(self.job_model.grouping, self.job_model.name, status).observe(
                     duration.total_seconds()
                 )
@@ -1180,7 +1180,7 @@ class ScheduledJob(BaseModel):
 
     def to_cron(self):
         tz = self.time_zone
-        t = self.start_time.astimezone(tz)
+        t = self.start_time.astimezone(tz)  # pylint: disable=no-member
         if self.interval == JobExecutionType.TYPE_HOURLY:
             return TzAwareCrontab(minute=t.minute, tz=tz)
         elif self.interval == JobExecutionType.TYPE_DAILY:

nautobot/extras/models/models.py

@@ -207,7 +207,7 @@ class ConfigContextModel(models.Model, ConfigContextSchemaValidationMixin):
             # Annotation not available, so fall back to manually querying for the config context
             config_context_data = ConfigContext.objects.get_for_object(self).values_list("data", flat=True)
         else:
-            config_context_data = self.config_context_data or []
+            config_context_data = self.config_context_data or []  # pylint: disable=no-member
             config_context_data = [
                 c["data"] for c in sorted(config_context_data, key=lambda k: (k["weight"], k["name"]))
             ]
@@ -831,7 +831,7 @@ class Note(ChangeLoggedModel, BaseModel):
         unique_together = [["assigned_object_type", "assigned_object_id", "user_name", "created"]]
 
     def __str__(self):
-        return f"{self.assigned_object} - {self.created.isoformat() if self.created else None}"
+        return f"{self.assigned_object} - {self.created.isoformat() if self.created else None}"  # pylint: disable=no-member
 
     def save(self, *args, **kwargs):
         # Record the user's name as static strings

nautobot/extras/plugins/views.py

@@ -166,7 +166,7 @@ class AppsAPIRootView(AuthenticatedAPIRootView):
         return entry
 
     @extend_schema(exclude=True)
-    def get(self, request, format=None):  # pylint: disable=redefined-builtin
+    def get(self, request, *args, format=None, **kwargs):  # pylint: disable=redefined-builtin
         entries = []
         for app_name in settings.PLUGINS:
             app_config = apps.get_app_config(app_name)