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

nautobot/wireless/tests/test_views.py

@@ -0,0 +1,378 @@
+import uuid
+
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
+from django.core.validators import URLValidator
+from django.test import override_settings
+from tree_queries.models import TreeNode
+
+from nautobot.core.testing import utils, ViewTestCases
+from nautobot.core.utils import lookup
+from nautobot.extras import choices as extras_choices
+from nautobot.extras.models import SecretsGroup, Tag
+from nautobot.users import models as users_models
+from nautobot.wireless import choices
+from nautobot.wireless.models import RadioProfile, SupportedDataRate, WirelessNetwork
+
+
+class WirelessNetworkTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    model = WirelessNetwork
+
+    @classmethod
+    def setUpTestData(cls):
+        WirelessNetwork.objects.create(
+            name="Deletable Wireless Network 1",
+            mode=choices.WirelessNetworkModeChoices.STANDALONE,
+            authentication=choices.WirelessNetworkAuthenticationChoices.WPA2_PERSONAL,
+            ssid="SSID 1",
+            description="Description 1",
+            enabled=True,
+            hidden=False,
+            secrets_group=SecretsGroup.objects.first(),
+        )
+        WirelessNetwork.objects.create(
+            name="Deletable Wireless Network 2",
+            mode=choices.WirelessNetworkModeChoices.CENTRAL,
+            authentication=choices.WirelessNetworkAuthenticationChoices.WPA2_ENTERPRISE,
+            ssid="SSID 2",
+            description="Description 2",
+            enabled=True,
+            hidden=False,
+            secrets_group=SecretsGroup.objects.first(),
+        )
+        WirelessNetwork.objects.create(
+            name="Deletable Wireless Network 3",
+            mode=choices.WirelessNetworkModeChoices.LOCAL,
+            authentication=choices.WirelessNetworkAuthenticationChoices.WPA2_ENTERPRISE,
+            ssid="SSID 3",
+            description="Description 3",
+            enabled=False,
+            hidden=True,
+            secrets_group=SecretsGroup.objects.first(),
+        )
+        cls.form_data = {
+            "name": "New Wireless Network",
+            "description": "A new wireless network",
+            "mode": choices.WirelessNetworkModeChoices.MESH,
+            "authentication": choices.WirelessNetworkAuthenticationChoices.WPA3_ENTERPRISE_192_BIT,
+            "ssid": "SOME SSID",
+            "tags": [t.pk for t in Tag.objects.get_for_model(WirelessNetwork)],
+            # Management form fields required for the dynamic Controller Managed Device Group formset
+            "controller_managed_device_group_assignments-TOTAL_FORMS": "0",
+            "controller_managed_device_group_assignments-INITIAL_FORMS": "1",
+            "controller_managed_device_group_assignments-MIN_NUM_FORMS": "0",
+            "controller_managed_device_group_assignments-MAX_NUM_FORMS": "1000",
+        }
+
+        cls.bulk_edit_data = {
+            "mode": choices.WirelessNetworkModeChoices.LOCAL,
+            "authentication": choices.WirelessNetworkAuthenticationChoices.WPA2_ENTERPRISE,
+            "enabled": False,
+            "ssid": "New SSID",
+            "description": "New description",
+        }
+
+
+class SupportedDataRateTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    model = SupportedDataRate
+
+    @classmethod
+    def setUpTestData(cls):
+        # Use high rate values that won't conflict with the factory rates
+        SupportedDataRate.objects.create(rate=165000, standard=choices.SupportedDataRateStandardChoices.B, mcs_index=1)
+        SupportedDataRate.objects.create(rate=169000, standard=choices.SupportedDataRateStandardChoices.G, mcs_index=2)
+        SupportedDataRate.objects.create(rate=280000, standard=choices.SupportedDataRateStandardChoices.N, mcs_index=3)
+        cls.form_data = {
+            "rate": 300000,
+            "standard": "802.11ac",
+            "tags": [t.pk for t in Tag.objects.get_for_model(SupportedDataRate)],
+        }
+        cls.bulk_edit_data = {
+            "mcs_index": 11,
+        }
+
+
+class RadioProfileTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    model = RadioProfile
+
+    @classmethod
+    def setUpTestData(cls):
+        supported_data_rates = (
+            SupportedDataRate.objects.create(
+                rate=1000000, standard=choices.SupportedDataRateStandardChoices.AC, mcs_index=1
+            ),
+            SupportedDataRate.objects.create(
+                rate=600000, standard=choices.SupportedDataRateStandardChoices.AX, mcs_index=2
+            ),
+            SupportedDataRate.objects.create(
+                rate=1280000, standard=choices.SupportedDataRateStandardChoices.BE, mcs_index=3
+            ),
+        )
+        rp1 = RadioProfile.objects.create(
+            name="Deletable Radio Profile 1",
+            frequency=choices.RadioProfileFrequencyChoices.FREQUENCY_5G,
+            tx_power_min=1,
+            tx_power_max=10,
+            channel_width=[20, 40, 80],
+            allowed_channel_list=[36, 40, 44, 48],
+            regulatory_domain=choices.RadioProfileRegulatoryDomainChoices.US,
+            rx_power_min=-90,
+        )
+        rp2 = RadioProfile.objects.create(
+            name="Deletable Radio Profile 2",
+            frequency=choices.RadioProfileFrequencyChoices.FREQUENCY_2_4G,
+            tx_power_min=2,
+            tx_power_max=11,
+            channel_width=[20, 40, 80, 160],
+            allowed_channel_list=[1, 6, 11],
+            regulatory_domain=choices.RadioProfileRegulatoryDomainChoices.JP,
+            rx_power_min=-89,
+        )
+        rp3 = RadioProfile.objects.create(
+            name="Deletable Radio Profile 3",
+            frequency=choices.RadioProfileFrequencyChoices.FREQUENCY_6G,
+            tx_power_min=15,
+            tx_power_max=25,
+            rx_power_min=-80,
+            regulatory_domain=choices.RadioProfileRegulatoryDomainChoices.JP,
+            allowed_channel_list=[],
+            channel_width=[],
+        )
+        rp1.supported_data_rates.set([supported_data_rates[0]])
+        rp2.supported_data_rates.set([supported_data_rates[1]])
+        rp3.supported_data_rates.set(supported_data_rates[:2])
+        cls.form_data = {
+            "name": "New Radio Profile",
+            "frequency": choices.RadioProfileFrequencyChoices.FREQUENCY_5G,
+            "tx_power_min": 1,
+            "tx_power_max": 10,
+            "allowed_channel_list": "1,6,11,36,161,165",
+            "channel_width": [20, 40],
+            "regulatory_domain": choices.RadioProfileRegulatoryDomainChoices.US,
+            "rx_power_min": -90,
+            "tags": [t.pk for t in Tag.objects.get_for_model(RadioProfile)],
+        }
+        # Form data for JSONArrayField with choices requires a JSON object, not a string
+        # but JSONArrayField renders the data as a string
+        cls.expected_data = {
+            "name": "New Radio Profile",
+            "frequency": choices.RadioProfileFrequencyChoices.FREQUENCY_5G,
+            "tx_power_min": 1,
+            "tx_power_max": 10,
+            "allowed_channel_list": "1,6,11,36,161,165",
+            "channel_width": "20,40",
+            "regulatory_domain": choices.RadioProfileRegulatoryDomainChoices.US,
+            "rx_power_min": -90,
+            "tags": [t.pk for t in Tag.objects.get_for_model(RadioProfile)],
+        }
+        cls.bulk_edit_data = {
+            "frequency": choices.RadioProfileFrequencyChoices.FREQUENCY_2_4G,
+            "tx_power_min": 2,
+            "tx_power_max": 11,
+            "allowed_channel_list": "1,2",
+            "channel_width": [20, 40, 80, 160],
+            "regulatory_domain": choices.RadioProfileRegulatoryDomainChoices.JP,
+            "rx_power_min": -89,
+        }
+        # Form data for JSONArrayField with choices requires a JSON object, not a string
+        # but JSONArrayField renders the data as a string
+        cls.bulk_edit_expected_data = {
+            "frequency": choices.RadioProfileFrequencyChoices.FREQUENCY_2_4G,
+            "tx_power_min": 2,
+            "tx_power_max": 11,
+            "allowed_channel_list": "1,2",
+            "channel_width": "20,40,80,160",
+            "regulatory_domain": choices.RadioProfileRegulatoryDomainChoices.JP,
+            "rx_power_min": -89,
+        }
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_create_object_with_permission(self):
+        """Override the default test to support the channel_width field."""
+        initial_count = self._get_queryset().count()
+
+        # Assign unconstrained permission
+        self.add_permissions(f"{self.model._meta.app_label}.add_{self.model._meta.model_name}")
+
+        # Try GET with model-level permission
+        self.assertHttpStatus(self.client.get(self._get_url("add")), 200)
+
+        # Try POST with model-level permission
+        request = {
+            "path": self._get_url("add"),
+            "data": utils.post_data(self.form_data),
+        }
+        self.assertHttpStatus(self.client.post(**request), 302)
+        self.assertEqual(initial_count + 1, self._get_queryset().count())
+        # order_by() is no supported by django TreeNode,
+        # So we directly retrieve the instance by "slug" or "name".
+        if isinstance(self._get_queryset().first(), TreeNode):
+            filter_by = self.slug_source if getattr(self, "slug_source", None) else "name"
+            instance = self._get_queryset().get(**{filter_by: self.form_data.get(filter_by)})
+            # Override the self.form_data with self.expected_data in this overridden method
+            self.assertInstanceEqual(instance, self.expected_data)
+        else:
+            if hasattr(self.model, "last_updated"):
+                instance = self._get_queryset().order_by("last_updated").last()
+                # Override the self.form_data with self.expected_data in this overridden method
+                self.assertInstanceEqual(instance, self.expected_data)
+            else:
+                instance = self._get_queryset().last()
+                # Override the self.form_data with self.expected_data in this overridden method
+                self.assertInstanceEqual(instance, self.expected_data)
+
+        if hasattr(self.model, "to_objectchange"):
+            # Verify ObjectChange creation
+            objectchanges = lookup.get_changes_for_model(instance)
+            self.assertEqual(len(objectchanges), 1)
+            # Assert that Created By table row is updated with the user that created the object
+            self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_CREATE)
+            # Validate if detail view exists
+            validate = URLValidator()
+            try:
+                detail_url = instance.get_absolute_url()
+                validate(detail_url)
+                response = self.client.get(detail_url)
+                response_body = utils.extract_page_body(response.content.decode(response.charset))
+                advanced_tab_href = f"{detail_url}#advanced"
+                self.assertIn(advanced_tab_href, response_body)
+                self.assertIn("<td>Created By</td>", response_body)
+                self.assertIn("<td>nautobotuser</td>", response_body)
+            except (AttributeError, ValidationError):
+                # Instance does not have a valid detail view, do nothing here.
+                pass
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_create_object_with_constrained_permission(self):
+        """Override the default test to support the channel_width field."""
+        initial_count = self._get_queryset().count()
+
+        # Assign constrained permission
+        obj_perm = users_models.ObjectPermission(
+            name="Test permission",
+            constraints={"pk": str(uuid.uuid4())},  # Match a non-existent pk (i.e., deny all)
+            actions=["add"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+
+        # Try GET with object-level permission
+        self.assertHttpStatus(self.client.get(self._get_url("add")), 200)
+
+        # Try to create an object (not permitted)
+        request = {
+            "path": self._get_url("add"),
+            "data": utils.post_data(self.form_data),
+        }
+        self.assertHttpStatus(self.client.post(**request), 200)
+        self.assertEqual(initial_count, self._get_queryset().count())  # Check that no object was created
+
+        # Update the ObjectPermission to allow creation
+        obj_perm.constraints = {"pk__isnull": False}
+        obj_perm.save()
+
+        # Try to create an object (permitted)
+        request = {
+            "path": self._get_url("add"),
+            "data": utils.post_data(self.form_data),
+        }
+        self.assertHttpStatus(self.client.post(**request), 302)
+        self.assertEqual(initial_count + 1, self._get_queryset().count())
+        # order_by() is no supported by django TreeNode,
+        # So we directly retrieve the instance by "slug".
+        if isinstance(self._get_queryset().first(), TreeNode):
+            filter_by = self.slug_source if getattr(self, "slug_source", None) else "name"
+            instance = self._get_queryset().get(**{filter_by: self.form_data.get(filter_by)})
+            # Override the self.form_data with self.expected_data in this overridden method
+            self.assertInstanceEqual(instance, self.expected_data)
+        else:
+            if hasattr(self.model, "last_updated"):
+                # Override the self.form_data with self.expected_data in this overridden method
+                self.assertInstanceEqual(self._get_queryset().order_by("last_updated").last(), self.expected_data)
+            else:
+                # Override the self.form_data with self.expected_data in this overridden method
+                self.assertInstanceEqual(self._get_queryset().last(), self.expected_data)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_edit_object_with_permission(self):
+        """Override the default test to support the channel_width field."""
+        instance = self._get_queryset().first()
+
+        # Assign model-level permission
+        self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
+
+        # Try GET with model-level permission
+        self.assertHttpStatus(self.client.get(self._get_url("edit", instance)), 200)
+
+        # Try POST with model-level permission
+        update_data = self.update_data or self.form_data
+        request = {
+            "path": self._get_url("edit", instance),
+            "data": utils.post_data(update_data),
+        }
+        self.assertHttpStatus(self.client.post(**request), 302)
+        # Override update_data with self.expected_data in this overridden method
+        self.assertInstanceEqual(self._get_queryset().get(pk=instance.pk), self.expected_data)
+
+        if hasattr(self.model, "to_objectchange"):
+            # Verify ObjectChange creation
+            objectchanges = lookup.get_changes_for_model(instance)
+            self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_UPDATE)
+            # Validate if detail view exists
+            validate = URLValidator()
+            try:
+                detail_url = instance.get_absolute_url()
+                validate(detail_url)
+                response = self.client.get(detail_url)
+                response_body = utils.extract_page_body(response.content.decode(response.charset))
+                advanced_tab_href = f"{detail_url}#advanced"
+                self.assertIn(advanced_tab_href, response_body)
+                self.assertIn("<td>Last Updated By</td>", response_body)
+                self.assertIn("<td>nautobotuser</td>", response_body)
+            except (AttributeError, ValidationError):
+                # Instance does not have a valid detail view, do nothing here.
+                pass
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_edit_object_with_constrained_permission(self):
+        """Override the default test to support the channel_width field."""
+        instance1, instance2 = self._get_queryset().all()[:2]
+
+        # Assign constrained permission
+        obj_perm = users_models.ObjectPermission(
+            name="Test permission",
+            constraints={"pk": instance1.pk},
+            actions=["change"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+
+        # Try GET with a permitted object
+        self.assertHttpStatus(self.client.get(self._get_url("edit", instance1)), 200)
+
+        # Try GET with a non-permitted object
+        self.assertHttpStatus(self.client.get(self._get_url("edit", instance2)), 404)
+
+        # Try to edit a permitted object
+        update_data = self.update_data or self.form_data
+        request = {
+            "path": self._get_url("edit", instance1),
+            "data": utils.post_data(update_data),
+        }
+        self.assertHttpStatus(self.client.post(**request), 302)
+        # Override update_data with self.expected_data in this overridden method
+        self.assertInstanceEqual(self._get_queryset().get(pk=instance1.pk), self.expected_data)
+
+        # Try to edit a non-permitted object
+        request = {
+            "path": self._get_url("edit", instance2),
+            "data": utils.post_data(update_data),
+        }
+        self.assertHttpStatus(self.client.post(**request), 404)
+
+    def validate_object_data_after_bulk_edit(self, pk_list):
+        for instance in self._get_queryset().filter(pk__in=pk_list):
+            # Override the self.bulk_edit_data with self.bulk_edit_expected_data in this overridden method
+            self.assertInstanceEqual(instance, self.bulk_edit_expected_data)

nautobot/wireless/urls.py

@@ -0,0 +1,13 @@
+from nautobot.core.views.routers import NautobotUIViewSetRouter
+
+from . import views
+
+app_name = "wireless"
+router = NautobotUIViewSetRouter()
+
+router.register("radio-profiles", views.RadioProfileUIViewSet)
+router.register("supported-data-rates", views.SupportedDataRateUIViewSet)
+router.register("wireless-networks", views.WirelessNetworkUIViewSet)
+
+urlpatterns = []
+urlpatterns += router.urls

nautobot/wireless/views.py

@@ -0,0 +1,129 @@
+from django.core.exceptions import ValidationError
+from django_tables2 import RequestConfig
+
+from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
+from nautobot.core.views.viewsets import NautobotUIViewSet
+from nautobot.wireless.api.serializers import (
+    RadioProfileSerializer,
+    SupportedDataRateSerializer,
+    WirelessNetworkSerializer,
+)
+from nautobot.wireless.filters import (
+    RadioProfileFilterSet,
+    SupportedDataRateFilterSet,
+    WirelessNetworkFilterSet,
+)
+from nautobot.wireless.forms import (
+    RadioProfileBulkEditForm,
+    RadioProfileFilterForm,
+    RadioProfileForm,
+    SupportedDataRateBulkEditForm,
+    SupportedDataRateFilterForm,
+    SupportedDataRateForm,
+    WirelessNetworkBulkEditForm,
+    WirelessNetworkControllerManagedDeviceGroupFormSet,
+    WirelessNetworkFilterForm,
+    WirelessNetworkForm,
+)
+from nautobot.wireless.models import RadioProfile, SupportedDataRate, WirelessNetwork
+from nautobot.wireless.tables import (
+    ControllerManagedDeviceGroupWirelessNetworkAssignmentTable,
+    RadioProfileTable,
+    SupportedDataRateTable,
+    WirelessNetworkTable,
+)
+
+
+class RadioProfileUIViewSet(NautobotUIViewSet):
+    queryset = RadioProfile.objects.all()
+    filterset_class = RadioProfileFilterSet
+    filterset_form_class = RadioProfileFilterForm
+    serializer_class = RadioProfileSerializer
+    table_class = RadioProfileTable
+    form_class = RadioProfileForm
+    bulk_update_form_class = RadioProfileBulkEditForm
+
+    def get_extra_context(self, request, instance=None):
+        context = super().get_extra_context(request, instance)
+        if self.action == "retrieve":
+            # Supported Data Rates
+            supported_data_rates = instance.supported_data_rates.restrict(request.user, "view")
+            supported_data_rates_table = SupportedDataRateTable(supported_data_rates)
+            RequestConfig(
+                request, paginate={"paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request)}
+            ).configure(supported_data_rates_table)
+            context["supported_data_rates_table"] = supported_data_rates_table
+
+        return context
+
+    def extra_post_save_action(self, obj, form):
+        if form.cleaned_data.get("add_supported_data_rates", None):
+            obj.supported_data_rates.add(*form.cleaned_data["add_supported_data_rates"])
+        if form.cleaned_data.get("remove_supported_data_rates", None):
+            obj.supported_data_rates.remove(*form.cleaned_data["remove_supported_data_rates"])
+        if form.cleaned_data.get("add_controller_managed_device_groups", None):
+            obj.controller_managed_device_groups.add(*form.cleaned_data["add_controller_managed_device_groups"])
+        if form.cleaned_data.get("remove_controller_managed_device_groups", None):
+            obj.controller_managed_device_groups.remove(*form.cleaned_data["remove_controller_managed_device_groups"])
+
+
+class SupportedDataRateUIViewSet(NautobotUIViewSet):
+    queryset = SupportedDataRate.objects.all()
+    filterset_class = SupportedDataRateFilterSet
+    filterset_form_class = SupportedDataRateFilterForm
+    serializer_class = SupportedDataRateSerializer
+    table_class = SupportedDataRateTable
+    form_class = SupportedDataRateForm
+    bulk_update_form_class = SupportedDataRateBulkEditForm
+
+
+class WirelessNetworkUIViewSet(NautobotUIViewSet):
+    queryset = WirelessNetwork.objects.all()
+    filterset_class = WirelessNetworkFilterSet
+    filterset_form_class = WirelessNetworkFilterForm
+    serializer_class = WirelessNetworkSerializer
+    table_class = WirelessNetworkTable
+    form_class = WirelessNetworkForm
+    bulk_update_form_class = WirelessNetworkBulkEditForm
+
+    def get_extra_context(self, request, instance=None):
+        context = super().get_extra_context(request, instance)
+        if self.action == "retrieve":
+            # Controller Managed Device Groups
+            controller_managed_device_groups = instance.controller_managed_device_group_assignments.restrict(
+                request.user, "view"
+            )
+            controller_managed_device_groups_table = ControllerManagedDeviceGroupWirelessNetworkAssignmentTable(
+                controller_managed_device_groups
+            )
+            controller_managed_device_groups_table.columns.hide("wireless_network")
+            controller_managed_device_groups_table.columns.hide("ssid")
+            controller_managed_device_groups_table.columns.hide("mode")
+            controller_managed_device_groups_table.columns.hide("enabled")
+            controller_managed_device_groups_table.columns.hide("authentication")
+            controller_managed_device_groups_table.columns.hide("hidden")
+            controller_managed_device_groups_table.columns.hide("secrets_group")
+            RequestConfig(
+                request, paginate={"paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request)}
+            ).configure(controller_managed_device_groups_table)
+            context["controller_managed_device_groups_table"] = controller_managed_device_groups_table
+
+        if self.action in ["create", "update"]:
+            context["controller_managed_device_groups"] = WirelessNetworkControllerManagedDeviceGroupFormSet(
+                instance=instance,
+                data=request.POST if request.method == "POST" else None,
+            )
+
+        return context
+
+    def form_save(self, form, **kwargs):
+        obj = super().form_save(form, **kwargs)
+
+        ctx = self.get_extra_context(self.request, obj)
+        controller_managed_device_groups = ctx.get("controller_managed_device_groups")
+        if controller_managed_device_groups.is_valid():
+            controller_managed_device_groups.save()
+        else:
+            raise ValidationError(controller_managed_device_groups.errors)
+
+        return obj

{nautobot-2.3.16.dist-info → nautobot-2.4.0b1.dist-info}/METADATA

@@ -1,18 +1,17 @@
 Metadata-Version: 2.1
 Name: nautobot
-Version: 2.3.16
+Version: 2.4.0b1
 Summary: Source of truth and network automation platform.
 Home-page: https://nautobot.com
 License: Apache-2.0
 Keywords: Nautobot
 Author: Network to Code
 Author-email: opensource@networktocode.com
-Requires-Python: >=3.8,<3.13
+Requires-Python: >=3.9,<3.13
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -23,16 +22,15 @@ Provides-Extra: mysql
 Provides-Extra: napalm
 Provides-Extra: remote-storage
 Provides-Extra: sso
-Requires-Dist: Django (>=4.2.17,<4.3.0)
+Requires-Dist: Django (>=4.2.16,<4.3.0)
 Requires-Dist: GitPython (>=3.1.43,<3.2.0)
-Requires-Dist: Jinja2 (>=3.1.5,<3.2.0)
+Requires-Dist: Jinja2 (>=3.1.4,<3.2.0)
 Requires-Dist: Markdown (>=3.6,<3.7)
-Requires-Dist: MarkupSafe (>=2.1.5,<2.2.0)
-Requires-Dist: Pillow (>=10.3.0,<10.4.0)
+Requires-Dist: Pillow (>=11.0.0,<11.1.0)
 Requires-Dist: PyYAML (>=6.0.2,<6.1.0)
 Requires-Dist: celery (>=5.3.6,<5.4.0)
 Requires-Dist: django-ajax-tables (>=1.1.1,<1.2.0)
-Requires-Dist: django-auth-ldap (>=4.8.0,<4.9.0) ; extra == "all" or extra == "ldap"
+Requires-Dist: django-auth-ldap (>=5.1.0,<5.2.0) ; extra == "all" or extra == "ldap"
 Requires-Dist: django-celery-beat (>=2.6.0,<2.7.0)
 Requires-Dist: django-celery-results (>=2.5.1,<2.6.0)
 Requires-Dist: django-constance (>=3.1.0,<3.2.0)
@@ -44,28 +42,27 @@ Requires-Dist: django-health-check (>=3.18.3,<3.19.0)
 Requires-Dist: django-jinja (>=2.11.0,<2.12.0)
 Requires-Dist: django-prometheus (>=2.3.1,<2.4.0)
 Requires-Dist: django-redis (>=5.4.0,<5.5.0)
-Requires-Dist: django-silk (>=5.1.0,<5.2.0)
+Requires-Dist: django-silk (>=5.3.0,<5.4.0)
 Requires-Dist: django-storages (==1.14.3) ; extra == "all" or extra == "remote-storage"
 Requires-Dist: django-structlog[celery] (>=8.1.0,<9.0.0)
-Requires-Dist: django-tables2 (==2.7.0) ; python_version < "3.9"
-Requires-Dist: django-tables2 (>=2.7.4,<2.8.0) ; python_version >= "3.9"
-Requires-Dist: django-taggit (>=5.0.0,<5.1.0)
+Requires-Dist: django-tables2 (>=2.7.0,<2.8.0)
+Requires-Dist: django-taggit (>=6.1.0,<6.2.0)
 Requires-Dist: django-timezone-field (>=7.0,<7.1)
 Requires-Dist: django-tree-queries (>=0.19.0,<0.20.0)
 Requires-Dist: django-webserver (>=1.2.0,<1.3.0)
 Requires-Dist: djangorestframework (>=3.15.2,<3.16.0)
-Requires-Dist: drf-react-template-framework (>=0.0.17,<0.0.18)
 Requires-Dist: drf-spectacular[sidecar] (>=0.27.2,<0.28.0)
 Requires-Dist: emoji (>=2.12.1,<2.13.0)
 Requires-Dist: graphene-django (>=2.16.0,<2.17.0)
 Requires-Dist: graphene-django-optimizer (>=0.8.0,<0.9.0)
 Requires-Dist: jsonschema (>=4.7.0,<5.0.0)
 Requires-Dist: kombu (>=5.4.2,<5.5.0)
+Requires-Dist: kubernetes (>=31.0.0,<32.0.0)
 Requires-Dist: mysqlclient (>=2.2.6,<2.3.0) ; extra == "all" or extra == "mysql"
 Requires-Dist: napalm (>=4.1.0,<6.0.0) ; extra == "all" or extra == "napalm"
 Requires-Dist: netaddr (>=1.3.0,<1.4.0)
 Requires-Dist: netutils (>=1.6.0,<2.0.0)
-Requires-Dist: nh3 (>=0.2.20,<0.3.0)
+Requires-Dist: nh3 (>=0.2.15,<0.3.0)
 Requires-Dist: packaging (>=23.1)
 Requires-Dist: prometheus-client (>=0.20.0,<0.21.0)
 Requires-Dist: psycopg2-binary (>=2.9.10,<2.10.0)