nautobot 2.2.7__py3-none-any.whl → 2.2.8__py3-none-any.whl

nautobot/core/graphql/generators.py

@@ -55,12 +55,12 @@ def generate_null_choices_resolver(name, resolver_name):
 
 def generate_filter_resolver(schema_type, resolver_name, field_name):
     """
-    Generate function to resolve OneToMany filtering.
+    Generate function to resolve filtering of ManyToOne and ManyToMany related objects.
 
     Args:
         schema_type (DjangoObjectType): DjangoObjectType for a given model
         resolver_name (str): name of the resolver
-        field_name (str): name of OneToMany field to filter
+        field_name (str): name of ManyToOneField, ManyToManyRel, or ManyToOneRel field to filter
     """
     filterset_class = schema_type._meta.filterset_class
 

nautobot/core/graphql/schema.py

@@ -6,7 +6,8 @@ import logging
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.validators import ValidationError
-from django.db.models.fields.reverse_related import ManyToOneRel, OneToOneRel
+from django.db.models import ManyToManyField
+from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel, OneToOneRel
 import graphene
 from graphene.types import generic
 
@@ -198,9 +199,11 @@ def extend_schema_type_filter(schema_type, model):
         (DjangoObjectType): The extended schema_type object
     """
     for field in model._meta.get_fields():
-        # Check attribute is a ManyToOne field
-        # OneToOneRel is a subclass of ManyToOneRel, but we don't want to treat is as a list
-        if not isinstance(field, ManyToOneRel) or isinstance(field, OneToOneRel):
+        # Check whether attribute is a ManyToOne or ManyToMany field
+        if not isinstance(field, (ManyToManyField, ManyToManyRel, ManyToOneRel)):
+            continue
+        # OneToOneRel is a subclass of ManyToOneRel, but we don't want to treat it as a list
+        if isinstance(field, OneToOneRel):
             continue
         child_schema_type = registry["graphql_types"].get(field.related_model._meta.label_lower)
         if child_schema_type:

nautobot/core/tests/integration/test_general_functionality.py

@@ -0,0 +1,36 @@
+from django.urls import reverse
+
+from nautobot.core.testing.integration import SeleniumTestCase
+
+
+class StaticMediaFailureTestCase(SeleniumTestCase):
+    """Integration test to make sure no static media failures are encountered."""
+
+    def setUp(self):
+        super().setUp()
+        self.user.is_superuser = True
+        self.user.is_staff = True
+        self.user.save()
+        self.login(self.user.username, self.password)
+
+    def tearDown(self):
+        self.logout()
+        super().tearDown()
+
+    def test_for_static_media_failure(self):
+        test_urls = [
+            reverse("home"),
+            reverse("api-root"),
+            reverse("graphql"),
+            reverse("api_docs"),
+            "/admin/",
+            "/static/docs/overview/index.html",
+        ]
+        for url in test_urls:
+            with self.subTest(test_url=url):
+                self.browser.visit(self.live_server_url + url)
+                # Wait for body element to appear
+                self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=10), "Page failed to load")
+                # Ensure we weren't redirected to another page
+                self.assertEqual(self.browser.url, self.live_server_url + url)
+                self.assertTrue(self.browser.is_text_not_present("Static Media Failure"))

nautobot/core/tests/test_graphql.py

@@ -729,8 +729,8 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         cls.location_type = LocationType.objects.get(name="Campus")
         cls.location1 = Location.objects.filter(location_type=cls.location_type).first()
         cls.location2 = Location.objects.filter(location_type=cls.location_type).last()
-        cls.location1.name = "Location-1"
-        cls.location2.name = "Location-2"
+        cls.location1.name = "Campus Location-1"
+        cls.location2.name = "Campus Location-2"
         cls.location1.status = cls.location_statuses[0]
         cls.location2.status = cls.location_statuses[1]
         cls.location1.validated_save()
@@ -930,6 +930,7 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         cls.prefix1 = Prefix.objects.create(
             prefix="10.0.1.0/24", namespace=cls.namespace, status=cls.prefix_statuses[0]
         )
+        cls.prefix1.locations.add(cls.location1, cls.location2)
         cls.ipaddr1 = IPAddress.objects.create(
             address="10.0.1.1/24", namespace=cls.namespace, status=cls.ip_statuses[0]
         )
@@ -968,6 +969,7 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         cls.prefix2 = Prefix.objects.create(
             prefix="10.0.2.0/24", namespace=cls.namespace, status=cls.prefix_statuses[1]
         )
+        cls.prefix2.locations.add(cls.location1, cls.location2)
         cls.ipaddr2 = IPAddress.objects.create(
             address="10.0.2.1/30", namespace=cls.namespace, status=cls.ip_statuses[1]
         )
@@ -1507,9 +1509,9 @@ query {
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_locations_filter(self):
         filters = (
-            ('name: "Location-1"', 1),
-            ('name: ["Location-1"]', 1),
-            ('name: ["Location-1", "Location-2"]', 2),
+            ('name: "Campus Location-1"', 1),
+            ('name: ["Campus Location-1"]', 1),
+            ('name: ["Campus Location-1", "Campus Location-2"]', 2),
             ('name__ic: "Location"', Location.objects.filter(name__icontains="Location").count()),
             ('name__ic: ["Location"]', Location.objects.filter(name__icontains="Location").count()),
             ('name__nic: "Location"', Location.objects.exclude(name__icontains="Location").count()),
@@ -1541,6 +1543,50 @@ query {
                 self.assertIsNone(result.errors)
                 self.assertEqual(len(result.data["locations"]), nbr_expected_results)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_query_prefixes_nested_m2m_filter(self):
+        """
+        Test functionality added to address https://github.com/nautobot/nautobot/issues/5906.
+
+        Prefix.locations is a ManyToManyField, which was not filterable in our GraphQL schema before this fix.
+        """
+        query = 'query { prefixes (prefix_length__gte:16) { prefix locations (location_type:["Campus"]) { name } } }'
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        found_valid_location = False
+        found_invalid_location = False
+        for prefix_data in result.data["prefixes"]:
+            for location_data in prefix_data["locations"]:
+                if location_data["name"].startswith("Campus"):
+                    found_valid_location = True
+                else:
+                    print(f"Found unexpected unfiltered location {location_data['name']} under {prefix_data['prefix']}")
+                    found_invalid_location = True
+        self.assertTrue(found_valid_location)
+        self.assertFalse(found_invalid_location)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_query_locations_nested_reverse_m2m_filter(self):
+        """
+        Test functionality added to address https://github.com/nautobot/nautobot/issues/5906.
+
+        Location.prefixes is a (reverse) ManyToManyRel, which was not filterable in our GraphQL schema before this fix.
+        """
+        query = "query { locations { name prefixes (prefix_length:24) { prefix } } }"
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        found_valid_prefix = False
+        found_invalid_prefix = False
+        for location_data in result.data["locations"]:
+            for prefix_data in location_data["prefixes"]:
+                if prefix_data["prefix"].endswith("/24"):
+                    found_valid_prefix = True
+                else:
+                    print(f"Found unexpected unfiltered prefix {prefix_data['prefix']} under {location_data['name']}")
+                    found_invalid_prefix = True
+        self.assertTrue(found_valid_prefix)
+        self.assertFalse(found_invalid_prefix)
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_devices_filter(self):
         filterset_class = DeviceFilterSet

nautobot/dcim/models/devices.py

@@ -832,9 +832,16 @@ class Device(PrimaryModel, ConfigContextModel):
         # Update Location and Rack assignment for any child Devices
         devices = Device.objects.filter(parent_bay__device=self)
         for device in devices:
-            device.location = self.location
-            device.rack = self.rack
-            device.save()
+            save_child_device = False
+            if device.location != self.location:
+                device.location = self.location
+                save_child_device = True
+            if device.rack != self.rack:
+                device.rack = self.rack
+                save_child_device = True
+
+            if save_child_device:
+                device.save()
 
     def create_components(self):
         """Create device components from the device type definition."""

nautobot/dcim/tests/test_models.py

@@ -16,6 +16,7 @@ from nautobot.dcim.choices import (
     InterfaceTypeChoices,
     PortTypeChoices,
     PowerOutletFeedLegChoices,
+    SubdeviceRoleChoices,
 )
 from nautobot.dcim.models import (
     Cable,
@@ -886,6 +887,13 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         self.device_type = DeviceType.objects.create(
             manufacturer=manufacturer,
             model="Test Device Type 1",
+            subdevice_role=SubdeviceRoleChoices.ROLE_PARENT,
+        )
+        self.child_devicetype = DeviceType.objects.create(
+            model="Child Device Type 1",
+            manufacturer=manufacturer,
+            subdevice_role=SubdeviceRoleChoices.ROLE_CHILD,
+            u_height=0,
         )
         self.device_role = Role.objects.get_for_model(Device).first()
         self.device_status = Status.objects.get_for_model(Device).first()
@@ -1188,6 +1196,73 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         self.device_type.software_image_files.add(software_image_file)
         self.device.validated_save()
 
+    def test_child_devices_are_not_saved_when_unnecessary(self):
+        parent_device = Device.objects.create(
+            name="Parent Device 1",
+            location=self.location_3,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        parent_device.validated_save()
+
+        child_device = Device.objects.create(
+            name="Child Device 1",
+            location=parent_device.location,
+            device_type=self.child_devicetype,
+            role=parent_device.role,
+            status=self.device_status,
+        )
+        child_device.validated_save()
+        child_mtime_before_parent_saved = str(child_device.last_updated)
+
+        devicebay = DeviceBay.objects.get(device=parent_device, name="Device Bay 1")
+        devicebay.installed_device = child_device
+        devicebay.validated_save()
+
+        #
+        # Tests
+        #
+
+        #
+        # On a NOOP save, the child device shouldn't be updated
+        parent_device.save()
+
+        child_mtime_after_parent_noop_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertEqual(child_mtime_before_parent_saved, child_mtime_after_parent_noop_save)
+
+        #
+        # On a serial number update, the child device shouldn't be updated
+        parent_device.serial = "12345"
+        parent_device.save()
+
+        child_mtime_after_parent_serial_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertEqual(child_mtime_before_parent_saved, child_mtime_after_parent_serial_update_save)
+
+        #
+        # If the parent rack updates, the child mtime should update.
+        rack = Rack.objects.create(name="Rack 1", location=parent_device.location, status=self.device_status)
+        parent_device.rack = rack
+        parent_device.save()
+
+        child_mtime_after_parent_rack_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertNotEqual(child_mtime_after_parent_noop_save, child_mtime_after_parent_rack_update_save)
+
+        #
+        # If the parent site updates, the child mtime should update
+        location = Location.objects.create(
+            name="New Site 1", status=self.device_status, location_type=self.location_type_3
+        )
+        parent_device.location = location
+        parent_device.save()
+
+        child_mtime_after_parent_site_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertNotEqual(child_mtime_after_parent_rack_update_save, child_mtime_after_parent_site_update_save)
+
 
 class DeviceTypeToSoftwareImageFileTestCase(ModelTestCases.BaseModelTestCase):
     model = DeviceTypeToSoftwareImageFile

nautobot/extras/models/relationships.py

@@ -244,6 +244,18 @@ class RelationshipModel(models.Model):
             if relation.skip_required(cls, opposite_side):
                 continue
 
+            if getattr(relation, f"{relation.required_on}_filter") and instance:
+                filterset = get_filterset_for_model(cls)
+                if filterset:
+                    filter_params = getattr(relation, f"{relation.required_on}_filter")
+                    # If the relationship is required on the model, but the object is not in the filter,
+                    # we should allow the object to be saved, as the object is not part of the relationship.
+                    # Example: We want a Device with a Role of Switch to be required to have a relationship
+                    # with a Device that has a Role of Router. A Device with a Role of Printer should
+                    # be exempt from the requirement.
+                    if not filterset(filter_params, cls.objects.filter(id=instance.id)).qs.exists():
+                        continue
+
             if relation.has_many(opposite_side):
                 num_required_verbose = "at least one"
             else:

nautobot/extras/tests/integration/test_dynamicgroups.py

@@ -74,7 +74,7 @@ class DynamicGroupTestCase(SeleniumTestCase):
 
         # And just a cursory check to make sure that the filter worked.
         group = DynamicGroup.objects.get(name=name)
-        self.assertEqual(group.count, len(devices))
+        self.assertEqual(group.count, Device.objects.filter(status__name="Active").count())
         self.assertEqual(group.filter, {"status": ["Active"]})
 
         # Verify dynamic group shows up on device detail tab

nautobot/extras/tests/test_relationships.py

@@ -15,9 +15,11 @@ from nautobot.core.tables import RelationshipColumn
 from nautobot.core.testing import TestCase
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.core.utils.lookup import get_route_for_model
+from nautobot.dcim.forms import DeviceForm
 from nautobot.dcim.models import (
     Controller,
     Device,
+    DeviceType,
     DeviceTypeToSoftwareImageFile,
     Location,
     LocationType,
@@ -27,7 +29,7 @@ from nautobot.dcim.models import (
 from nautobot.dcim.tables import LocationTable
 from nautobot.dcim.tests.test_views import create_test_device
 from nautobot.extras.choices import RelationshipRequiredSideChoices, RelationshipSideChoices, RelationshipTypeChoices
-from nautobot.extras.models import Relationship, RelationshipAssociation, Status
+from nautobot.extras.models import Relationship, RelationshipAssociation, Role, Status
 from nautobot.ipam.models import VLAN, VLANGroup
 
 
@@ -486,6 +488,224 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
                 with self.assertNumQueries(0):
                     manager_method(Location)
 
+    def test_required_related_object_errors(self):
+        """
+        Confirm that the fix in https://github.com/nautobot/nautobot/pull/5570 is working as expected
+        """
+        device_ct = ContentType.objects.get_for_model(Device)
+        status = Status.objects.get_for_model(Device).first()
+        device_type = DeviceType.objects.exclude(manufacturer__isnull=True).first()
+        # Create a Device with role Role 1
+        role_1 = Role.objects.create(name="Role 1")
+        role_1.content_types.add(ContentType.objects.get_for_model(Device))
+        device_1 = Device.objects.create(
+            device_type=device_type, role=role_1, name="Device 1", location=self.locations[0], status=status
+        )
+        # Create a Device with role Role 2
+        role_2 = Role.objects.create(name="Role 2")
+        role_2.content_types.add(ContentType.objects.get_for_model(Device))
+        device_2 = Device.objects.create(
+            device_type=device_type, role=role_2, name="Device 2", location=self.locations[0], status=status
+        )
+        # Create a Device with role Role 3
+        role_3 = Role.objects.create(name="Role 3")
+        role_3.content_types.add(ContentType.objects.get_for_model(Device))
+        device_3 = Device.objects.create(
+            device_type=device_type, role=role_3, name="Device 3", location=self.locations[0], status=status
+        )
+        # Create a one-to-many relationship with destination required, source filter: {"role": ["Role 1"]}
+        # and destination filter {"role": ["Role 2"]}
+        relationship = Relationship.objects.create(
+            label="Device to Devices",
+            key="device_to_devices",
+            source_type=device_ct,
+            source_filter={"role": ["Role 1"]},
+            destination_type=device_ct,
+            destination_filter={"role": ["Role 2"]},
+            type=RelationshipTypeChoices.TYPE_ONE_TO_MANY,
+            required_on="destination",
+        )
+        # Attempt to update device_3 which will not be in the queryset filtered by the destination filter
+        # Assert that the form is valid and no ValueError is raised.
+        update_status = Status.objects.get_for_model(Device).last()
+        update_data_for_device_3 = {
+            "location": device_3.location.pk,
+            "device_type": device_3.device_type.pk,
+            "role": device_3.role.pk,
+            "name": device_3.name,
+            "status": update_status.pk,
+        }
+        form = DeviceForm(instance=device_3, data=update_data_for_device_3)
+        self.assertTrue(form.is_valid())
+        # Attempt to update device_1 which will not be in the destination filter,
+        # but is in the source filter.
+        update_data_for_device_1 = {
+            "location": device_1.location.pk,
+            "device_type": device_1.device_type.pk,
+            "role": device_1.role.pk,
+            "name": device_1.name,
+            "status": update_status.pk,
+        }
+        form2 = DeviceForm(instance=device_1, data=update_data_for_device_1)
+        self.assertTrue(form2.is_valid())
+        # Attempt to update device_2 which will be in the destination filter, so it should
+        # require the relationship.
+        update_data_for_device_2 = {
+            "location": device_2.location.pk,
+            "device_type": device_2.device_type.pk,
+            "role": device_2.role.pk,
+            "name": "Device 2",
+            "status": update_status.pk,
+        }
+        form3 = DeviceForm(instance=device_2, data=update_data_for_device_2)
+        self.assertFalse(form3.is_valid())
+        # Device 1 has a relationship to Device 2
+        update_data_for_device_1 = {
+            "location": device_1.location.pk,
+            "device_type": device_1.device_type.pk,
+            "role": device_1.role.pk,
+            "name": device_1.name,
+            "status": update_status.pk,
+            "cr_device_to_devices__destination": [device_2.pk],
+        }
+        form4 = DeviceForm(instance=device_1, data=update_data_for_device_1)
+        self.assertTrue(form4.is_valid())
+        form4.save()
+        # Device 2 has a relationship to Device 1, form should validate and save.
+        update_data_for_device_2 = {
+            "location": device_2.location.pk,
+            "device_type": device_2.device_type.pk,
+            "role": device_2.role.pk,
+            "name": "Device 2",
+            "status": update_status.pk,
+            "cr_device_to_devices__source": device_1.pk,
+        }
+        form5 = DeviceForm(instance=device_2, data=update_data_for_device_2)
+        self.assertTrue(form5.is_valid())
+        form5.save()
+        # Device 2 has a relationship to Device 3, save should fail as Device 3 doesn't match filter.
+        update_data_for_device_2 = {
+            "location": device_2.location.pk,
+            "device_type": device_2.device_type.pk,
+            "role": device_2.role.pk,
+            "name": "Device 2",
+            "status": update_status.pk,
+            "cr_device_to_devices__source": device_3.pk,
+        }
+        form6 = DeviceForm(instance=device_2, data=update_data_for_device_2)
+        with self.assertRaises(ValidationError):
+            form6.save()
+        # Device 1 has a relationship to Device 3, save should fail as Device 3 doesn't match filter.
+        update_data_for_device_1 = {
+            "location": device_1.location.pk,
+            "device_type": device_1.device_type.pk,
+            "role": device_1.role.pk,
+            "name": "Device 1",
+            "status": update_status.pk,
+            "cr_device_to_devices__destination": [
+                device_3.pk,
+            ],
+        }
+        form6 = DeviceForm(instance=device_1, data=update_data_for_device_1)
+        with self.assertRaises(ValidationError):
+            form6.save()
+
+        relationship.required_on = "source"
+        relationship.save()
+        # Attempt to update device_3 which will not be in the queryset filtered by the destination filter
+        # Assert that the form is valid and no ValueError is raised. This ensures that an object that
+        # does not take part in any relationships can still be updated, addressing issue #5569.
+        update_status = Status.objects.get_for_model(Device).last()
+        update_data_for_device_3 = {
+            "location": device_3.location.pk,
+            "device_type": device_3.device_type.pk,
+            "role": device_3.role.pk,
+            "name": device_3.name,
+            "status": update_status.pk,
+        }
+        form = DeviceForm(instance=device_3, data=update_data_for_device_3)
+        self.assertTrue(form.is_valid())
+        # Attempt to update device_1 which will not be in the destination filter,
+        # but is in the source filter. Should fail as device_to_devices is required.
+        device_1.delete()
+        device_1 = Device.objects.create(
+            device_type=device_type, role=role_1, name="Device 1", location=self.locations[0], status=status
+        )
+        update_data_for_device_1 = {
+            "location": device_1.location.pk,
+            "device_type": device_1.device_type.pk,
+            "role": device_1.role.pk,
+            "name": device_1.name,
+            "status": update_status.pk,
+        }
+        form2 = DeviceForm(instance=device_1, data=update_data_for_device_1)
+        self.assertFalse(form2.is_valid())
+        # Attempt to update device_2 which will be in the destination filter, which should not require the
+        # relationship anymore.
+        device_2.delete()
+        device_2 = Device.objects.create(
+            device_type=device_type, role=role_2, name="Device 2", location=self.locations[0], status=status
+        )
+        update_data_for_device_2 = {
+            "location": device_2.location.pk,
+            "device_type": device_2.device_type.pk,
+            "role": device_2.role.pk,
+            "name": "Device 2",
+            "status": update_status.pk,
+        }
+        form3 = DeviceForm(instance=device_2, data=update_data_for_device_2)
+        self.assertTrue(form3.is_valid())
+        # Device 1 has a relationship to Device 2
+        update_data_for_device_1 = {
+            "location": device_1.location.pk,
+            "device_type": device_1.device_type.pk,
+            "role": device_1.role.pk,
+            "name": device_1.name,
+            "status": update_status.pk,
+            "cr_device_to_devices__destination": [device_2.pk],
+        }
+        form4 = DeviceForm(instance=device_1, data=update_data_for_device_1)
+        self.assertTrue(form4.is_valid())
+        form4.save()
+        # Device 2 has a relationship to Device 1, form should validate and save.
+        update_data_for_device_2 = {
+            "location": device_2.location.pk,
+            "device_type": device_2.device_type.pk,
+            "role": device_2.role.pk,
+            "name": "Device 2",
+            "status": update_status.pk,
+            "cr_device_to_devices__source": device_1.pk,
+        }
+        form5 = DeviceForm(instance=device_2, data=update_data_for_device_2)
+        self.assertTrue(form5.is_valid())
+        form5.save()
+        # Device 2 has a relationship to Device 3, save should fail as Device 3 doesn't match filter.
+        update_data_for_device_2 = {
+            "location": device_2.location.pk,
+            "device_type": device_2.device_type.pk,
+            "role": device_2.role.pk,
+            "name": "Device 2",
+            "status": update_status.pk,
+            "cr_device_to_devices__source": device_3.pk,
+        }
+        form6 = DeviceForm(instance=device_2, data=update_data_for_device_2)
+        with self.assertRaises(ValidationError):
+            form6.save()
+        # Device 1 has a relationship to Device 3, save should fail as Device 3 doesn't match filter.
+        update_data_for_device_1 = {
+            "location": device_1.location.pk,
+            "device_type": device_1.device_type.pk,
+            "role": device_1.role.pk,
+            "name": "Device 1",
+            "status": update_status.pk,
+            "cr_device_to_devices__destination": [
+                device_3.pk,
+            ],
+        }
+        form6 = DeviceForm(instance=device_1, data=update_data_for_device_1)
+        with self.assertRaises(ValidationError):
+            form6.save()
+
 
 class RelationshipAssociationTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
     model = RelationshipAssociation

nautobot/project-static/docs/404.html

@@ -12,7 +12,7 @@
       
       
       <link rel="icon" href="/projects/core/en/stable/assets/favicon.ico">
-      <meta name="generator" content="mkdocs-1.6.0, mkdocs-material-9.5.28">
+      <meta name="generator" content="mkdocs-1.6.0, mkdocs-material-9.5.29">
     
     
       
@@ -20,7 +20,7 @@
       
     
     
-      <link rel="stylesheet" href="/projects/core/en/stable/assets/stylesheets/main.6543a935.min.css">
+      <link rel="stylesheet" href="/projects/core/en/stable/assets/stylesheets/main.76a95c52.min.css">
       
         
         <link rel="stylesheet" href="/projects/core/en/stable/assets/stylesheets/palette.06af60db.min.css">

nautobot/project-static/docs/apps/index.html

@@ -18,7 +18,7 @@
       
       
       <link rel="icon" href="../assets/favicon.ico">
-      <meta name="generator" content="mkdocs-1.6.0, mkdocs-material-9.5.28">
+      <meta name="generator" content="mkdocs-1.6.0, mkdocs-material-9.5.29">
     
     
       
@@ -26,7 +26,7 @@
       
     
     
-      <link rel="stylesheet" href="../assets/stylesheets/main.6543a935.min.css">
+      <link rel="stylesheet" href="../assets/stylesheets/main.76a95c52.min.css">
       
         
         <link rel="stylesheet" href="../assets/stylesheets/palette.06af60db.min.css">

nautobot/project-static/docs/apps/nautobot-apps.html

@@ -16,7 +16,7 @@
       
       
       <link rel="icon" href="../assets/favicon.ico">
-      <meta name="generator" content="mkdocs-1.6.0, mkdocs-material-9.5.28">
+      <meta name="generator" content="mkdocs-1.6.0, mkdocs-material-9.5.29">
     
     
       
@@ -24,7 +24,7 @@
       
     
     
-      <link rel="stylesheet" href="../assets/stylesheets/main.6543a935.min.css">
+      <link rel="stylesheet" href="../assets/stylesheets/main.76a95c52.min.css">
       
         
         <link rel="stylesheet" href="../assets/stylesheets/palette.06af60db.min.css">