nautobot 2.4.3__py3-none-any.whl → 2.4.5__py3-none-any.whl

nautobot/__init__.py

@@ -14,18 +14,34 @@ __initialized = False
 
 def add_success_logger():
     """Add a custom log level for success messages."""
-    SUCCESS = 25
+    SUCCESS = 25  # between INFO and WARNING
     logging.addLevelName(SUCCESS, "SUCCESS")
 
-    def success(self, message, *args, **kws):
+    def success(self, message, *args, **kwargs):
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 1) + 1  # so that funcName is the caller function, not "success"
         if self.isEnabledFor(SUCCESS):
-            self._log(SUCCESS, message, args, **kws)
+            self._log(SUCCESS, message, args, **kwargs)
 
     logging.Logger.success = success
     return success
 
 
+def add_failure_logger():
+    """Add a custom log level for failure messages less severe than an ERROR."""
+    FAILURE = 35  # between WARNING and ERROR
+    logging.addLevelName(FAILURE, "FAILURE")
+
+    def failure(self, message, *args, **kwargs):
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 1) + 1  # so that funcName is the caller function, not "failure"
+        if self.isEnabledFor(FAILURE):
+            self._log(FAILURE, message, args, **kwargs)
+
+    logging.Logger.failure = failure
+    return failure
+
+
 add_success_logger()
+add_failure_logger()
 logger = logging.getLogger(__name__)
 
 

nautobot/apps/filters.py

@@ -43,6 +43,7 @@ from nautobot.extras.filters.mixins import (
     StatusFilter,
 )
 from nautobot.extras.plugins import FilterExtension
+from nautobot.ipam.filters import PrefixFilter
 from nautobot.tenancy.filters import TenancyModelFilterSetMixin
 
 __all__ = (
@@ -72,6 +73,7 @@ __all__ = (
     "NaturalKeyOrPKMultipleChoiceFilter",
     "NautobotFilterSet",
     "NumericArrayFilter",
+    "PrefixFilter",
     "RelatedMembershipBooleanFilter",
     "RelationshipFilter",
     "RelationshipModelFilterSetMixin",

nautobot/circuits/filters.py

@@ -16,7 +16,7 @@ from nautobot.dcim.filters import (
 )
 from nautobot.dcim.models import Location
 from nautobot.extras.filters import NautobotFilterSet, StatusModelFilterSetMixin
-from nautobot.tenancy.filters import TenancyModelFilterSetMixin
+from nautobot.tenancy.filters.mixins import TenancyModelFilterSetMixin
 
 from .models import Circuit, CircuitTermination, CircuitType, Provider, ProviderNetwork
 

nautobot/circuits/tests/test_models.py

@@ -17,8 +17,7 @@ class CircuitTerminationModelTestCase(ModelTestCases.BaseModelTestCase):
         provider = Provider.objects.first()
         circuit_type = CircuitType.objects.first()
 
-        location_type_1 = LocationType.objects.get(name="Campus")
-        location_type_1.content_types.set([])
+        location_type_1 = LocationType.objects.create(name="University")
         location_type_2 = LocationType.objects.get(name="Building")
         location_type_2.content_types.add(ContentType.objects.get_for_model(CircuitTermination))
         status = Status.objects.get_for_model(Circuit).first()
@@ -26,7 +25,10 @@ class CircuitTerminationModelTestCase(ModelTestCases.BaseModelTestCase):
             cid="Circuit 1", provider=provider, circuit_type=circuit_type, status=status
         )
         cls.provider_network = ProviderNetwork.objects.create(name="Provider Network 1", provider=provider)
-        cls.location_1 = Location.objects.filter(location_type=location_type_1)[0]
+        location_status = Status.objects.get_for_model(Location).first()
+        cls.location_1 = Location.objects.create(
+            name="Department", location_type=location_type_1, status=location_status
+        )
         cls.location_2 = Location.objects.filter(location_type=location_type_2)[0]
 
         cloud_resource_type = CloudResourceType.objects.get_for_model(CloudNetwork).first()

nautobot/cloud/filters.py

@@ -1,5 +1,3 @@
-import django_filters
-
 from nautobot.cloud import models
 from nautobot.core.filters import (
     BaseFilterSet,
@@ -11,7 +9,7 @@ from nautobot.dcim.models import Manufacturer
 from nautobot.extras.filters import NautobotFilterSet
 from nautobot.extras.models import SecretsGroup
 from nautobot.extras.utils import FeatureQuery
-from nautobot.ipam.models import Prefix
+from nautobot.ipam.filters import PrefixFilter
 
 
 class CloudAccountFilterSet(NautobotFilterSet):
@@ -98,7 +96,7 @@ class CloudNetworkFilterSet(NautobotFilterSet):
         queryset=models.CloudNetwork.objects.all(),
         label="Parent cloud network (name or ID)",
     )
-    prefixes = django_filters.ModelMultipleChoiceFilter(queryset=Prefix.objects.all())
+    prefixes = PrefixFilter()
 
     class Meta:
         model = models.CloudNetwork
@@ -117,8 +115,7 @@ class CloudNetworkPrefixAssignmentFilterSet(BaseFilterSet):
         queryset=models.CloudNetwork.objects.all(),
         label="Cloud network (name or ID)",
     )
-    # Prefix doesn't have an appropriate natural key for NaturalKeyOrPKMultipleChoiceFilter
-    prefix = django_filters.ModelMultipleChoiceFilter(queryset=Prefix.objects.all())
+    prefix = PrefixFilter()
 
     class Meta:
         model = models.CloudNetworkPrefixAssignment

nautobot/cloud/tests/test_filters.py

@@ -65,6 +65,7 @@ class CloudNetworkTestCase(FilterTestCases.FilterTestCase):
         ("name",),
         ("parent", "parent__id"),
         ("parent", "parent__name"),
+        ("prefixes", "prefixes__id"),
     ]
     exclude_q_filter_predicates = [
         "parent__name",
@@ -79,6 +80,16 @@ class CloudNetworkTestCase(FilterTestCases.FilterTestCase):
             queryset = queryset.filter(children__isnull=True)
         return queryset
 
+    def test_prefixes_filter_by_string(self):
+        """Test filtering by prefix strings as an alternative to pk."""
+        prefix = self.queryset.filter(prefixes__isnull=False).first().prefixes.first()
+        params = {"prefixes": [prefix.prefix]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefixes__network=prefix.network, prefixes__prefix_length=prefix.prefix_length),
+            ordered=False,
+        )
+
 
 class CloudNetworkPrefixAssignmentTestCase(FilterTestCases.FilterTestCase):
     queryset = models.CloudNetworkPrefixAssignment.objects.all()
@@ -89,6 +100,16 @@ class CloudNetworkPrefixAssignmentTestCase(FilterTestCases.FilterTestCase):
         ("prefix", "prefix__id"),
     ]
 
+    def test_prefix_filter_by_string(self):
+        """Test filtering by prefix strings as an alternative to pk."""
+        prefix = self.queryset.first().prefix
+        params = {"prefix": [prefix.prefix]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefix__network=prefix.network, prefix__prefix_length=prefix.prefix_length),
+            ordered=False,
+        )
+
 
 class CloudServiceNetworkAssignmentTestCase(FilterTestCases.FilterTestCase):
     queryset = models.CloudServiceNetworkAssignment.objects.all()

nautobot/core/admin.py

@@ -9,7 +9,9 @@ from django_celery_beat.models import (
     PeriodicTask,
     SolarSchedule,
 )
+import social_django.admin  # noqa: F401  # unused-import -- but this import installs the social_django admin
 from social_django.models import Association, Nonce, UserSocialAuth
+import taggit.admin  # noqa: F401  # unused-import -- but this import installs the taggit admin
 from taggit.models import Tag
 
 from nautobot.core.forms import BootstrapMixin

nautobot/core/celery/__init__.py

@@ -14,7 +14,7 @@ from django.utils.module_loading import import_string
 from kombu.serialization import register
 from prometheus_client import CollectorRegistry, multiprocess, start_http_server
 
-from nautobot import add_success_logger
+from nautobot import add_failure_logger, add_success_logger
 from nautobot.core.celery.control import discard_git_repository, refresh_git_repository  # noqa: F401  # unused-import
 from nautobot.core.celery.encoders import NautobotKombuJSONEncoder
 from nautobot.core.celery.log import NautobotDatabaseHandler
@@ -138,14 +138,16 @@ def add_nautobot_log_handler(logger_instance, log_format=None):
 
 @signals.after_setup_logger.connect
 def setup_nautobot_global_logging(logger, **kwargs):  # pylint: disable=redefined-outer-name
-    """Add SUCCESS log to celery global logger."""
+    """Add SUCCESS and FAILURE logs to celery global logger."""
     logger.success = add_success_logger()
+    logger.failure = add_failure_logger()
 
 
 @signals.after_setup_task_logger.connect
 def setup_nautobot_task_logging(logger, **kwargs):  # pylint: disable=redefined-outer-name
-    """Add SUCCESS log to celery task logger."""
+    """Add SUCCESS and FAILURE logs to celery task logger."""
     logger.success = add_success_logger()
+    logger.failure = add_failure_logger()
 
 
 @signals.celeryd_after_setup.connect

nautobot/core/jobs/__init__.py

@@ -229,7 +229,8 @@ class ExportObjectList(Job):
             # The force_csv=True attribute is a hack, but much easier than trying to construct a valid HttpRequest
             # object from scratch that passes all implicit and explicit assumptions in Django and DRF.
             serializer = serializer_class(queryset, many=True, context={"request": None}, force_csv=True)
-            csv_data = renderer.render(serializer.data)
+            # Explicitly add UTF-8 BOM to the data so that Excel will understand non-ASCII characters correctly...
+            csv_data = codecs.BOM_UTF8 + renderer.render(serializer.data).encode("utf-8")
             self.create_file(filename + ".csv", csv_data)
 
 
@@ -294,8 +295,9 @@ class ImportObjects(Job):
                     validation_failed = True
             else:
                 validation_failed = True
-                for field, err in serializer.errors.items():
-                    self.logger.error("Row %d: `%s`: `%s`", row, field, err[0])
+                for field, errs in serializer.errors.items():
+                    for err in errs:
+                        self.logger.error("Row %d: `%s`: `%s`", row, field, err)
         return new_objs, validation_failed
 
     def run(self, *, content_type, csv_data=None, csv_file=None, roll_back_if_error=False):  # pylint:disable=arguments-differ

nautobot/core/management/commands/generate_performance_test_endpoints.py

@@ -1,5 +1,6 @@
 from typing import Optional
 
+from django.apps import apps
 from django.conf import settings
 from django.core.management.base import BaseCommand
 from django.urls import get_resolver
@@ -162,6 +163,10 @@ class Command(BaseCommand):
         if model:
             app_name = model._meta.app_label
 
+        # Retrieve the base URL for the app to be used in the URL pattern
+        app_config = apps.get_app_config(app_name)
+        base_url = app_config.base_url if hasattr(app_config, "base_url") else app_name
+
         if app_name == "users" and pattern.name in ["login", "logout"]:
             # No need to test the login and logout endpoints for performance testing
             url_pattern = f"/{pattern.pattern}"  # /login, /logout
@@ -199,7 +204,7 @@ class Command(BaseCommand):
         elif is_api_endpoint:
             if not is_app:
                 # One of the nautobot apps: nautobot.circuits, nautobot.dcim, and etc.
-                url_pattern = f"/api/{app_name}/{pattern.pattern}"  # /api/dcim/devices/
+                url_pattern = f"/api/{base_url}/{pattern.pattern}"  # /api/dcim/devices/
                 app_name = f"{app_name}-api"  # dcim-api
                 view_name = f"{app_name}:{pattern.name}"  # dcim-api:device-list
             else:
@@ -207,16 +212,14 @@ class Command(BaseCommand):
                 view_name = (
                     f"plugins-api:{api_app_name}:{pattern.name}"  # plugins-api:example_app-api:examplemodel-list
                 )
-                app_name = app_name.replace("_", "-")  # example_app -> example-app
-                url_pattern = f"/api/plugins/{app_name}/{pattern.pattern}"  # /api/plugins/example-app/models/
+                url_pattern = f"/api/plugins/{base_url}/{pattern.pattern}"  # /api/plugins/example-app/models/
         else:
             if not is_app:
-                url_pattern = f"/{app_name}/{pattern.pattern}"  # /dcim/devices/
+                url_pattern = f"/{base_url}/{pattern.pattern}"  # /dcim/devices/
                 view_name = f"{app_name}:{pattern.name}"  # dcim:device_list
             else:
                 view_name = f"plugins:{app_name}:{pattern.name}"  # plugins:example_app:examplemodel_list
-                app_name = app_name.replace("_", "-")  # example_app -> example-app
-                url_pattern = f"/plugins/{app_name}/{pattern.pattern}"  # /plugins/example-app/models/
+                url_pattern = f"/plugins/{base_url}/{pattern.pattern}"  # /plugins/example-app/models/
 
         return url_pattern, view_name, is_api_endpoint
 

nautobot/core/models/utils.py

@@ -112,7 +112,12 @@ def serialize_object(obj, extra=None, exclude=None):
 
     # Include any tags. Check for tags cached on the instance; fall back to using the manager.
     if is_taggable(obj):
-        tags = getattr(obj, "_tags", []) or obj.tags.all()
+        # Note that when upgrading from Nautobot 1.x to 2.0, this method may be called during data migrations,
+        # specifically ipam_0022 and dcim_0034, to create ObjectChange records.
+        # This can be problematic (see issue #6952) as the Tag records in the DB still have `created` as a `DateField`,
+        # but the 2.x code expects this to be a `DateTimeField` (as it will be after the upgrade completes in full).
+        # We "cleverly" bypass that issue by using `.only("name")` since that's the only actual Tag field we need here.
+        tags = getattr(obj, "_tags", []) or obj.tags.only("name")
         data["tags"] = [tag.name for tag in tags]
 
     # Append any extra data

nautobot/core/templates/inc/javascript.html

@@ -27,6 +27,7 @@
 <script src="{% versioned_static 'js/dropdown.js' %}"
         onerror="window.location='{% url 'media_failure' %}?filename=js/dropdown.js'"></script>
 <script type="text/javascript">
+    var nautobot_static_url = "{% static '' %}";
     var nautobot_api_path = "{% url 'api-root' %}";
     var nautobot_csrf_token = "{{ csrf_token }}";
     var loading = $(".loading");

nautobot/core/templatetags/ui_framework.py

@@ -1,9 +1,13 @@
+import logging
+
 from django import template
 from django.utils.html import format_html_join
 
 from nautobot.core.utils.lookup import get_view_for_model
 from nautobot.core.views.utils import get_obj_from_context
 
+logger = logging.getLogger(__name__)
+
 register = template.Library()
 
 
@@ -26,15 +30,27 @@ def render_components(context, components):
 @register.simple_tag(takes_context=True)
 def render_detail_view_extra_buttons(context):
     """
-    Render the "extra_buttons" if any from the base detail view associated with the context object.
+    Render the "extra_buttons" from the context's object_detail_content, or as fallback, from the base detail view.
 
     This makes it possible for "extra" tabs (such as Changelog and Notes, and any added by App TemplateExtensions)
     to automatically still render any `extra_buttons` defined by the base detail view, without the tab-specific views
     needing to explicitly inherit from the base view.
     """
-    obj = get_obj_from_context(context)
-    base_detail_view = get_view_for_model(obj)
-    object_detail_content = getattr(base_detail_view, "object_detail_content", None)
+    object_detail_content = context.get("object_detail_content")
+    if object_detail_content is None:
+        obj = get_obj_from_context(context)
+        if obj is None:
+            logger.error("No 'obj' or 'object' found in the render context!")
+            return ""
+        base_detail_view = get_view_for_model(obj)
+        if base_detail_view is None:
+            logger.warning(
+                "Unable to identify the base detail view - check that it has a valid name, i.e. %sUIViewSet or %sView",
+                type(obj).__name__,
+                type(obj).__name__,
+            )
+            return ""
+        object_detail_content = getattr(base_detail_view, "object_detail_content", None)
     if object_detail_content is not None and object_detail_content.extra_buttons:
         return render_components(context, object_detail_content.extra_buttons)
     return ""

nautobot/core/testing/__init__.py

@@ -68,6 +68,8 @@ def run_job_for_testing(job, username="test-user", profile=False, **kwargs):
         username=username, defaults={"is_superuser": True, "password": "password"}
     )
     # Run the job synchronously in the current thread as if it were being executed by a worker
+    # TODO: in Nautobot core testing, we set `CELERY_TASK_ALWAYS_EAGER = True`, so we *could* use enqueue_job() instead,
+    #       but switching now would be a potentially breaking change for apps...
     job_result = JobResult.execute_job(
         job_model=job,
         user=user_instance,

nautobot/core/testing/forms.py

@@ -24,7 +24,7 @@ class FormTestCases:
                         self.skipTest(f"{self.form_class.__name__}.{field_name} has no query_params")
                     field_model = field_class.queryset.model
                     filterset_class = get_filterset_for_model(field_model)
-                    filterset_fields = set(filterset_class.declared_filters.keys())
+                    filterset_fields = set(filterset_class.get_filters().keys())
                     invalid_query_params = query_params_fields - filterset_fields
                     self.assertFalse(
                         invalid_query_params,

nautobot/core/testing/mixins.py

@@ -18,6 +18,7 @@ from nautobot.core.models import fields as core_fields
 from nautobot.core.testing import utils
 from nautobot.core.utils import permissions
 from nautobot.extras import management, models as extras_models
+from nautobot.extras.choices import JobResultStatusChoices
 from nautobot.users import models as users_models
 
 # Use the proper swappable User model
@@ -188,6 +189,14 @@ class NautobotTestCaseMixin:
                 err_message = f"{msg}\n{err_message}"
         self.assertIn(response.status_code, expected_status, err_message)
 
+    def assertJobResultStatus(self, job_result, expected_status=JobResultStatusChoices.STATUS_SUCCESS):
+        """Assert that the given job_result has the expected_status, or print the job logs to aid in debugging."""
+        self.assertEqual(
+            job_result.status,
+            expected_status,
+            (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
+        )
+
     def assertInstanceEqual(self, instance, data, exclude=None, api=False):
         """
         Compare a model instance to a dictionary, checking that its attribute values match those specified

nautobot/core/tests/test_api.py

@@ -609,7 +609,7 @@ class WritableNestedSerializerTest(testing.APITestCase):
             dcim_models.LocationType.objects.get(name="Building"),
         ]
         for location_type in self.locations_types:
-            location_type.content_types.set([vlan_group_ct, vlan_ct])
+            location_type.content_types.add(vlan_group_ct, vlan_ct)
 
         self.statuses = extras_models.Status.objects.get_for_model(dcim_models.Location)
         self.location1 = dcim_models.Location.objects.create(

nautobot/core/tests/test_graphql.py

@@ -8,7 +8,7 @@ from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
-from django.db.models import Q
+from django.db.models import Count, Q
 from django.test import override_settings, TestCase
 from django.test.client import RequestFactory
 from django.urls import reverse
@@ -919,8 +919,8 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
                 priority=789,
             ),
         )
-        prefixes = Prefix.objects.all()[:2]
-        cls.namespace = prefixes[0].namespace
+        cls.namespace = Namespace.objects.annotate(prefix_count=Count("prefixes")).filter(prefix_count__gt=2).first()
+        prefixes = Prefix.objects.filter(namespace=cls.namespace)
         vrfs = (
             VRF.objects.create(name="VRF 1", rd="65000:100", namespace=cls.namespace),
             VRF.objects.create(name="VRF 2", rd="65000:200", namespace=cls.namespace),