nautobot 2.4.9__py3-none-any.whl → 2.4.11__py3-none-any.whl

nautobot/core/utils/module_loading.py

@@ -1,29 +1,13 @@
-from contextlib import contextmanager
-import importlib
-from importlib.util import find_spec, module_from_spec
+from importlib.machinery import FileFinder, SOURCE_SUFFIXES, SourceFileLoader
+from importlib.util import module_from_spec
+from keyword import iskeyword
 import logging
-import os
 import pkgutil
 import sys
 
 logger = logging.getLogger(__name__)
 
 
-@contextmanager
-def _temporarily_add_to_sys_path(path):
-    """
-    Allow loading of modules and packages from within the provided directory by temporarily modifying `sys.path`.
-
-    On exit, it restores the original `sys.path` value.
-    """
-    old_sys_path = sys.path.copy()
-    sys.path.insert(0, path)
-    try:
-        yield
-    finally:
-        sys.path = old_sys_path
-
-
 def clear_module_from_sys_modules(module_name):
     """
     Remove the module and all its submodules from sys.modules.
@@ -33,7 +17,29 @@ def clear_module_from_sys_modules(module_name):
             del sys.modules[name]
 
 
-def import_modules_privately(path, module_path=None, ignore_import_errors=True):
+def check_name_safe_to_import_privately(name: str) -> tuple[bool, str]:
+    """
+    Make sure the given package/module name is "safe" to import from the filesystem.
+
+    In other words, make sure it's:
+    - a valid Python identifier and not a reserved keyword
+    - not the name of an existing "real" Python package or builtin
+
+    Returns:
+        (bool, str): Whether safe to load, and an explanatory string fragment for logging/exception messages.
+    """
+    if not name.isidentifier():
+        return False, "not a valid identifier"
+    if iskeyword(name):
+        return False, "a reserved keyword"
+    if name in sys.builtin_module_names:
+        return False, "a Python builtin"
+    if any(module_info.name == name for module_info in pkgutil.iter_modules()):
+        return False, "the name of an installed Python package"
+    return True, "a valid and non-conflicting module name"
+
+
+def import_modules_privately(path, module_path=None, module_prefix="", ignore_import_errors=True):
     """
     Import modules from the filesystem without adding the path permanently to `sys.path`.
 
@@ -49,49 +55,71 @@ def import_modules_privately(path, module_path=None, ignore_import_errors=True):
         ignore_import_errors (bool): Exceptions raised while importing modules will be caught and logged.
             If this is set as False, they will then be re-raised to be handled by the caller of this function.
     """
-    if module_path is None:
-        module_path = []
-        module_prefix = None
+    loaded_modules = []
+    # We formerly used pkgutil.walk_packages() here to handle submodule loading with a multi-entry module_path,
+    # but that has the downside (and risk!) of automatically importing all packages that it finds in the given path,
+    # whether or not we actually want to do so. So instead, for the case where a module_path is provided, we need to
+    # iteratively import each submodule ourselves.
+    if module_path:
+        # Git repository case - e.g. import_modules_privately(settings.GIT_ROOT, module_path=[repository_slug, "jobs"])
+        # Here we want to ONLY auto-load the module sequence identified by module_path.
+        permitted, reason = check_name_safe_to_import_privately(module_path[0])
+        if not permitted:
+            logger.error("Unable to load module %r from %s as it is %s", module_path[0], path, reason)
+        else:
+            module = None
+            module_name = module_path.pop(0)
+            submodule_name = module_name
+            try:
+                while True:
+                    finder = FileFinder(path, (SourceFileLoader, SOURCE_SUFFIXES))
+                    finder.invalidate_caches()
+                    spec = finder.find_spec(module_name)
+                    if spec is None or spec.loader is None:
+                        logger.error("Unable to find module spec and/or loader for %r", submodule_name)
+                        break
+                    spec.name = submodule_name
+                    spec.loader.name = submodule_name
+                    submodule = module_from_spec(spec)
+                    sys.modules[submodule_name] = submodule
+                    spec.loader.exec_module(submodule)
+                    if module is not None:
+                        setattr(module, module_name, submodule)
+                    module = submodule
+                    loaded_modules.append(module)
+                    if module_path:
+                        submodule_name = f"{module_name}.{module_path[0]}"
+                        module_name = module_path.pop(0)
+                        path = module.__path__[0]
+                    else:
+                        break
+            except Exception as exc:
+                logger.error("Unable to load module %s from %s: %s", module_name, path, exc)
+                if not ignore_import_errors:
+                    raise
     else:
-        module_prefix = ".".join(module_path)
-    with _temporarily_add_to_sys_path(path):
-        for finder, discovered_module_name, is_package in pkgutil.walk_packages([path], onerror=logger.error):
-            if module_prefix and not (
-                module_prefix.startswith(f"{discovered_module_name}.")  # my_repo/__init__.py
-                or discovered_module_name == module_prefix  # my_repo/jobs.py
-                or discovered_module_name.startswith(f"{module_prefix}.")  # my_repo/jobs/foobar.py
-            ):
+        # JOBS_ROOT case - import ALL top-level modules/packages that we can find in the given path;
+        # they can implement and import submodules as desired by themselves, but we only autoimport top-level ones.
+        for finder, discovered_module_name, _ in pkgutil.iter_modules([path]):
+            permitted, reason = check_name_safe_to_import_privately(discovered_module_name)
+            if not permitted:
+                logger.error("Unable to load module %r from %s as it is %s", discovered_module_name, path, reason)
                 continue
-            try:
-                existing_module = find_spec(discovered_module_name)
-            except (ModuleNotFoundError, ValueError):
-                existing_module = None
-            if existing_module is not None:
-                existing_module_path = os.path.realpath(existing_module.origin)
-                if not existing_module_path.startswith(path):
-                    logger.error(
-                        "Unable to load module %s from %s as it conflicts with existing module %s",
-                        discovered_module_name,
-                        path,
-                        existing_module_path,
-                    )
-                    continue
-
-            if discovered_module_name in sys.modules:
-                clear_module_from_sys_modules(discovered_module_name)
+            module_name = discovered_module_name
+            if module_name in sys.modules:
+                clear_module_from_sys_modules(module_name)
 
             try:
-                if not is_package:
-                    spec = finder.find_spec(discovered_module_name)
-                    if spec is None:
-                        raise ValueError("Unable to find module spec")
-                    module = module_from_spec(spec)
-                    sys.modules[discovered_module_name] = module
-                    spec.loader.exec_module(module)
-                else:
-                    module = importlib.import_module(discovered_module_name)
-                importlib.reload(module)
+                spec = finder.find_spec(discovered_module_name)
+                if spec is None or spec.loader is None:
+                    logger.error("Unable to find module spec and/or loader for %r", discovered_module_name)
+                    continue
+                module = module_from_spec(spec)
+                sys.modules[module_name] = module
+                spec.loader.exec_module(module)
+                loaded_modules.append(module)
             except Exception as exc:
                 logger.error("Unable to load module %s from %s: %s", discovered_module_name, path, exc)
                 if not ignore_import_errors:
                     raise
+    return loaded_modules

nautobot/core/views/__init__.py

@@ -3,6 +3,7 @@ import datetime
 import logging
 import os
 import platform
+import posixpath
 import re
 import sys
 import time
@@ -24,6 +25,7 @@ from django.views.csrf import csrf_failure as _csrf_failure
 from django.views.decorators.csrf import requires_csrf_token
 from django.views.defaults import ERROR_500_TEMPLATE_NAME, page_not_found
 from django.views.generic import TemplateView, View
+from django.views.static import serve
 from graphene_django.views import GraphQLView
 from packaging import version
 from prometheus_client import (
@@ -133,6 +135,25 @@ class HomeView(AccessMixin, TemplateView):
         return self.render_to_response(context)
 
 
+class MediaView(AccessMixin, View):
+    """
+    Serves media files while enforcing login restrictions.
+
+    This view wraps Django's `serve()` function to ensure that access to media files (with the exception of
+    branding files defined in `settings.BRANDING_FILEPATHS`) is restricted to authenticated users.
+    """
+
+    def get(self, request, path):
+        if request.user.is_authenticated:
+            return serve(request, path, document_root=settings.MEDIA_ROOT)
+
+        # Unauthenticated users can access BRANDING_FILEPATHS only
+        if posixpath.normpath(path).lstrip("/") in settings.BRANDING_FILEPATHS.values():
+            return serve(request, path, document_root=settings.MEDIA_ROOT)
+
+        return self.handle_no_permission()
+
+
 class WorkerStatusView(UserPassesTestMixin, TemplateView):
     template_name = "utilities/worker_status.html"
 

nautobot/core/views/generic.py

@@ -54,6 +54,7 @@ from nautobot.core.views.utils import (
     check_filter_for_display,
     common_detail_view_context,
     get_csv_form_fields_from_serializer_class,
+    get_saved_views_for_user,
     handle_protectederror,
     import_csv_helper,
     prepare_cloned_fields,
@@ -315,18 +316,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         table_config_form = None
         current_saved_view = None
         current_saved_view_pk = self.request.GET.get("saved_view", None)
-        # We are not using .restrict(request.user, "view") here
-        # User should be able to see any saved view that he has the list view access to.
-        if user.has_perms(["extras.view_savedview"]):
-            saved_views = SavedView.objects.filter(view=list_url).order_by("name").only("pk", "name")
-        else:
-            shared_saved_views = (
-                SavedView.objects.filter(view=list_url, is_shared=True).order_by("name").only("pk", "name")
-            )
-            user_owned_saved_views = (
-                SavedView.objects.filter(view=list_url, owner=user).order_by("name").only("pk", "name")
-            )
-            saved_views = shared_saved_views | user_owned_saved_views
+        saved_views = get_saved_views_for_user(user, list_url)
 
         if current_saved_view_pk:
             try:

nautobot/core/views/mixins.py

@@ -239,6 +239,9 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
     table_class = None
     notes_form_class = NoteForm
     permission_classes = []
+    # custom view attributes used for permission checks and handling
+    custom_view_base_action = None
+    custom_view_additional_permissions = None
 
     def get_permissions_for_model(self, model, actions):
         """
@@ -249,6 +252,10 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
         """
         model_permissions = []
         for action in actions:
+            # Append additional object permissions if specified.
+            if self.custom_view_additional_permissions:
+                model_permissions.append(*self.custom_view_additional_permissions)
+            # Append the model-level permissions for the action.
             model_permissions.append(f"{model._meta.app_label}.{action}_{model._meta.model_name}")
         return model_permissions
 
@@ -501,7 +508,13 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
 
     def get_action(self):
         """Helper method for retrieving action and if action not set defaulting to action name."""
-        return PERMISSIONS_ACTION_MAP.get(self.action, self.action)
+        if self.custom_view_base_action:
+            return self.custom_view_base_action
+        if self.action in PERMISSIONS_ACTION_MAP:
+            # If the action is in the action_map, return the mapped permission
+            return PERMISSIONS_ACTION_MAP[self.action]
+
+        return self.action
 
     def get_extra_context(self, request, instance=None):
         """
@@ -1032,6 +1045,11 @@ class BulkEditAndBulkDeleteModelMixin:
 
         filter_query_params = new_filter_query_params
 
+        if nullified_fields := request.POST.getlist("_nullify"):
+            form_data["_nullify"] = nullified_fields
+        else:
+            form_data["_nullify"] = []
+
         job_form = BulkEditObjects.as_form(
             data={
                 "form_data": form_data,

nautobot/core/views/renderers.py

@@ -28,6 +28,7 @@ from nautobot.core.views.utils import (
     check_filter_for_display,
     common_detail_view_context,
     get_csv_form_fields_from_serializer_class,
+    get_saved_views_for_user,
     view_changes_not_saved,
 )
 from nautobot.extras.models import SavedView
@@ -235,7 +236,8 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
                     if view.filterset_form_class is not None:
                         filter_form = view.filterset_form_class(view.filter_params, label_suffix="")
                 table = self.construct_table(view, request=request, permissions=permissions)
-                search_form = SearchForm(data=view.filter_params)
+                q_placeholder = "Search " + bettertitle(model._meta.verbose_name_plural)
+                search_form = SearchForm(data=view.filter_params, q_placeholder=q_placeholder)
             elif view.action == "destroy":
                 form = form_class(initial=request.GET)
             elif view.action in ["create", "update"]:
@@ -309,18 +311,7 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
             list_url = f"{resolved_path.app_name}:{resolved_path.url_name}"
             saved_views = None
             if model.is_saved_view_model:
-                # We are not using .restrict(request.user, "view") here
-                # User should be able to see any saved view that he has the list view access to.
-                if request.user.has_perms(["extras.view_savedview"]):
-                    saved_views = SavedView.objects.filter(view=list_url).order_by("name").only("pk", "name")
-                else:
-                    shared_saved_views = (
-                        SavedView.objects.filter(view=list_url, is_shared=True).order_by("name").only("pk", "name")
-                    )
-                    user_owned_saved_views = (
-                        SavedView.objects.filter(view=list_url, owner=request.user).order_by("name").only("pk", "name")
-                    )
-                    saved_views = shared_saved_views | user_owned_saved_views
+                saved_views = get_saved_views_for_user(request.user, list_url)
 
             new_changes_not_applied = view_changes_not_saved(request, view, self.saved_view)
             context.update(

nautobot/core/views/utils.py

@@ -17,6 +17,7 @@ from nautobot.core.utils.data import is_uuid
 from nautobot.core.utils.filtering import get_filter_field_label
 from nautobot.core.utils.lookup import get_created_and_last_updated_usernames_for_model, get_form_for_model
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
+from nautobot.extras.models import SavedView
 from nautobot.extras.tables import AssociatedContactsTable, DynamicGroupTable, ObjectMetadataTable
 
 
@@ -382,3 +383,18 @@ def common_detail_view_context(request, instance):
         context["associated_object_metadata_table"] = None
 
     return context
+
+
+def get_saved_views_for_user(user, list_url):
+    # We are not using .restrict(request.user, "view") here
+    # User should be able to see any saved view that he has the list view access to.
+    saved_views = SavedView.objects.filter(view=list_url).order_by("name").only("pk", "name")
+    if user.has_perms(["extras.view_savedview"]):
+        return saved_views
+
+    shared_saved_views = saved_views.filter(is_shared=True)
+    if user.is_authenticated:
+        user_owned_saved_views = SavedView.objects.filter(view=list_url, owner=user).order_by("name").only("pk", "name")
+        return shared_saved_views | user_owned_saved_views
+
+    return shared_saved_views

nautobot/dcim/api/serializers.py

@@ -79,6 +79,7 @@ from nautobot.dcim.models import (
     Module,
     ModuleBay,
     ModuleBayTemplate,
+    ModuleFamily,
     ModuleType,
     PathEndpoint,
     Platform,
@@ -1124,3 +1125,15 @@ class InterfaceVDCAssignmentSerializer(ValidatedModelSerializer):
     class Meta:
         model = InterfaceVDCAssignment
         fields = "__all__"
+
+
+class ModuleFamilySerializer(NautobotModelSerializer):
+    """API serializer for ModuleFamily objects."""
+
+    url = serializers.HyperlinkedIdentityField(view_name="dcim-api:modulefamily-detail")
+    module_type_count = serializers.IntegerField(read_only=True)
+    module_bay_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = ModuleFamily
+        fields = "__all__"

nautobot/dcim/api/urls.py

@@ -17,6 +17,7 @@ router.register("rack-reservations", views.RackReservationViewSet)
 router.register("manufacturers", views.ManufacturerViewSet)
 router.register("device-families", views.DeviceFamilyViewSet)
 router.register("device-types", views.DeviceTypeViewSet)
+router.register("module-families", views.ModuleFamilyViewSet)
 router.register("module-types", views.ModuleTypeViewSet)
 
 # Device type and Module type components

nautobot/dcim/api/views.py

@@ -54,6 +54,7 @@ from nautobot.dcim.models import (
     Module,
     ModuleBay,
     ModuleBayTemplate,
+    ModuleFamily,
     ModuleType,
     Platform,
     PowerFeed,
@@ -644,6 +645,14 @@ class CableViewSet(NautobotModelViewSet):
     serializer_class = serializers.CableSerializer
     filterset_class = filters.CableFilterSet
 
+    def get_queryset(self):
+        # 6933 fix: with prefetch related in queryset
+        # DeviceInterface is not properly cleared of _path_id
+        queryset = super().get_queryset()
+        if self.action == "destroy":
+            queryset = queryset.prefetch_related(None)
+        return queryset
+
 
 #
 # Virtual chassis
@@ -836,3 +845,14 @@ class InterfaceVDCAssignmentViewSet(ModelViewSet):
     queryset = InterfaceVDCAssignment.objects.all()
     serializer_class = serializers.InterfaceVDCAssignmentSerializer
     filterset_class = filters.InterfaceVDCAssignmentFilterSet
+
+
+class ModuleFamilyViewSet(NautobotModelViewSet):
+    """API viewset for interacting with ModuleFamily objects."""
+
+    queryset = ModuleFamily.objects.annotate(
+        module_type_count=count_related(ModuleType, "module_family"),
+        module_bay_count=count_related(ModuleBay, "module_family"),
+    )
+    serializer_class = serializers.ModuleFamilySerializer
+    filterset_class = filters.ModuleFamilyFilterSet

nautobot/dcim/apps.py

@@ -14,6 +14,7 @@ class DCIMConfig(NautobotConfig):
         "devicetype",
         "location",
         "module",
+        "modulefamily",
         "moduletype",
         "powerfeed",
         "rack",

nautobot/dcim/factory.py

@@ -49,6 +49,7 @@ from nautobot.dcim.models import (
     Module,
     ModuleBay,
     ModuleBayTemplate,
+    ModuleFamily,
     ModuleType,
     Platform,
     PowerOutletTemplate,
@@ -787,6 +788,7 @@ class ModuleTypeFactory(PrimaryModelFactory):
         exclude = ("has_part_number", "has_comments")
 
     manufacturer = random_instance(Manufacturer, allow_null=False)
+    module_family = random_instance(ModuleFamily, allow_null=True)
 
     has_part_number = NautobotBoolIterator()
     part_number = factory.Maybe("has_part_number", factory.Faker("ean", length=8), "")
@@ -970,6 +972,15 @@ class ModuleBayTemplateFactory(ModularDeviceComponentTemplateFactory):
         factory.LazyAttribute(lambda o: o.module_type.module_bay_templates.count() + 1),
     )
 
+    class Params:
+        has_module_family = NautobotBoolIterator()
+
+    module_family = factory.Maybe(
+        "has_module_family",
+        random_instance(ModuleFamily),
+        None,
+    )
+
 
 class VirtualDeviceContextFactory(PrimaryModelFactory):
     class Meta:

nautobot/dcim/filters/__init__.py

@@ -74,6 +74,7 @@ from nautobot.dcim.models import (
     Module,
     ModuleBay,
     ModuleBayTemplate,
+    ModuleFamily,
     ModuleType,
     Platform,
     PowerFeed,
@@ -137,6 +138,7 @@ __all__ = (
     "ManufacturerFilterSet",
     "ModuleBayFilterSet",
     "ModuleBayTemplateFilterSet",
+    "ModuleFamilyFilterSet",
     "ModuleFilterSet",
     "ModuleTypeFilterSet",
     "PathEndpointFilterSet",
@@ -2072,6 +2074,12 @@ class ModuleFilterSet(
         to_field_name="model",
         label="Module type (model or ID)",
     )
+    module_family = NaturalKeyOrPKMultipleChoiceFilter(
+        field_name="module_type__module_family",
+        queryset=ModuleFamily.objects.all(),
+        to_field_name="name",
+        label="Module family (name or ID)",
+    )
     parent_module_bay = django_filters.ModelMultipleChoiceFilter(
         queryset=ModuleBay.objects.all(),
         label="Parent Module Bay",
@@ -2082,6 +2090,13 @@ class ModuleFilterSet(
         label="Device (name or ID)",
         method="filter_device",
     )
+    compatible_with_module_bay = extend_schema_field({"type": "string", "format": "uuid"})(
+        django_filters.ModelChoiceFilter(
+            queryset=ModuleBay.objects.all(),
+            method="filter_module_bay",
+            label="Compatible with module bay (ID)",
+        )
+    )
 
     def _construct_device_filter_recursively(self, field_name, value):
         recursion_depth = MODULE_RECURSION_DEPTH_LIMIT
@@ -2107,6 +2122,12 @@ class ModuleFilterSet(
         params = self.generate_query_filter_device(value)
         return queryset.filter(params)
 
+    def filter_module_bay(self, queryset, name, value):
+        """Filter modules based on a module bay's module family."""
+        if value and value.module_family:
+            return queryset.filter(module_type__module_family=value.module_family)
+        return queryset
+
     class Meta:
         model = Module
         fields = "__all__"
@@ -2133,6 +2154,23 @@ class ModuleTypeFilterSet(DeviceTypeModuleTypeCommonFiltersMixin, NautobotFilter
             },
         },
     )
+    manufacturer = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Manufacturer.objects.all(),
+        to_field_name="name",
+        label="Manufacturer (name or ID)",
+    )
+    module_family = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=ModuleFamily.objects.all(),
+        to_field_name="name",
+        label="Module family (name or ID)",
+    )
+    compatible_with_module_bay = extend_schema_field({"type": "string", "format": "uuid"})(
+        django_filters.ModelChoiceFilter(
+            queryset=ModuleBay.objects.all(),
+            method="filter_module_bay",
+            label="Installable in module bay (ID)",
+        )
+    )
     has_modules = RelatedMembershipBooleanFilter(
         field_name="modules",
         label="Has module instances",
@@ -2142,6 +2180,12 @@ class ModuleTypeFilterSet(DeviceTypeModuleTypeCommonFiltersMixin, NautobotFilter
         model = ModuleType
         fields = "__all__"
 
+    def filter_module_bay(self, queryset, name, value):
+        """Filter module types based on a module bay's module family."""
+        if value and value.module_family:
+            return queryset.filter(module_family=value.module_family)
+        return queryset
+
 
 class ModuleBayTemplateFilterSet(ModularDeviceComponentTemplateModelFilterSetMixin, NautobotFilterSet):
     q = SearchFilter(
@@ -2172,6 +2216,14 @@ class ModuleBayTemplateFilterSet(ModularDeviceComponentTemplateModelFilterSetMix
             },
         }
     )
+    module_family = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=ModuleFamily.objects.all(),
+        to_field_name="name",
+        label="Module family (name or ID)",
+    )
+    requires_first_party_modules = django_filters.BooleanFilter(
+        label="Requires first-party modules",
+    )
 
     class Meta:
         model = ModuleBayTemplate
@@ -2228,6 +2280,15 @@ class ModuleBayFilterSet(NautobotFilterSet):
         field_name="installed_module",
         label="Has installed module",
     )
+    module_family = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=ModuleFamily.objects.all(),
+        to_field_name="name",
+        label="Module family (name or ID)",
+    )
+    requires_first_party_modules = django_filters.BooleanFilter(
+        field_name="requires_first_party_modules",
+        label="Requires first-party modules",
+    )
 
     class Meta:
         model = ModuleBay
@@ -2362,3 +2423,52 @@ class InterfaceVDCAssignmentFilterSet(NautobotFilterSet):
             "interface",
             "virtual_device_context",
         ]
+
+
+class ModuleFamilyFilterSet(NautobotFilterSet):
+    """FilterSet for ModuleFamily objects."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "name": {
+                "lookup_expr": "icontains",
+                "preprocessor": str.strip,
+            },
+            "description": {
+                "lookup_expr": "icontains",
+                "preprocessor": str.strip,
+            },
+            "module_types__model": {
+                "lookup_expr": "icontains",
+                "preprocessor": str.strip,
+            },
+            "module_types__manufacturer__name": {
+                "lookup_expr": "icontains",
+                "preprocessor": str.strip,
+            },
+        }
+    )
+
+    module_types = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=ModuleType.objects.all(),
+        to_field_name="model",
+        label="Module types (model or ID)",
+    )
+
+    module_bay_id = extend_schema_field({"type": "array", "items": {"type": "string", "format": "uuid"}})(
+        django_filters.ModelMultipleChoiceFilter(
+            queryset=ModuleBay.objects.all(),
+            label="Module bay (ID)",
+        )
+    )
+
+    class Meta:
+        model = ModuleFamily
+        fields = [
+            "id",
+            "name",
+            "description",
+            "module_types",
+            "module_bay_id",
+            "tags",
+        ]