nautobot 2.3.8__py3-none-any.whl → 2.3.10__py3-none-any.whl

nautobot/apps/tables.py

@@ -15,6 +15,7 @@ from nautobot.core.tables import (
     TagColumn,
     ToggleColumn,
 )
+from nautobot.extras.plugins import TableExtension
 from nautobot.extras.tables import RoleTableMixin, StatusTableMixin
 
 __all__ = (
@@ -32,5 +33,6 @@ __all__ = (
     "RoleTableMixin",
     "StatusTableMixin",
     "TagColumn",
+    "TableExtension",
     "ToggleColumn",
 )

nautobot/core/forms/__init__.py

@@ -7,6 +7,8 @@ from nautobot.core.forms.constants import (
     NUMERIC_EXPANSION_PATTERN,
 )
 from nautobot.core.forms.fields import (
+    AutoPositionField,
+    AutoPositionPatternField,
     CommentField,
     CSVChoiceField,
     CSVContentTypeField,
@@ -80,6 +82,8 @@ __all__ = (
     "ALPHANUMERIC_EXPANSION_PATTERN",
     "APISelect",
     "APISelectMultiple",
+    "AutoPositionField",
+    "AutoPositionPatternField",
     "BOOLEAN_CHOICES",
     "BOOLEAN_WITH_BLANK_CHOICES",
     "BootstrapMixin",

nautobot/core/forms/fields.py

@@ -444,6 +444,38 @@ class SlugField(django_forms.SlugField):
         self.widget.attrs["slug-source"] = slug_source
 
 
+class AutoPositionField(django_forms.CharField):
+    def __init__(self, source="name", *args, **kwargs):
+        """
+        Instantiate a AutoPositionField.
+
+        Args:
+            source (str, tuple): Name of the field (or a list of field names) that will be used to suggest a position.
+        """
+        kwargs.setdefault("label", "Position")
+        kwargs.setdefault("widget", forms.SlugWidget)
+        super().__init__(*args, **kwargs)
+        if isinstance(source, (tuple, list)):
+            source = " ".join(source)
+        self.widget.attrs["source"] = source
+
+
+class AutoPositionPatternField(ExpandableNameField):
+    def __init__(self, source="name_pattern", *args, **kwargs):
+        """
+        Instantiate a AutoPositionPatternField.
+
+        Args:
+            source (str, tuple): Name pattern of the field (or a list of field names) that will be used to suggest a position pattern.
+        """
+        kwargs.setdefault("label", "Position")
+        kwargs.setdefault("widget", forms.SlugWidget)
+        super().__init__(*args, **kwargs)
+        if isinstance(source, (tuple, list)):
+            source = " ".join(source)
+        self.widget.attrs["source"] = source
+
+
 class DynamicModelChoiceMixin:
     """
     :param display_field: The name of the attribute of an API response object to display in the selection list

nautobot/core/jobs/__init__.py

@@ -19,7 +19,12 @@ from nautobot.core.jobs.cleanup import LogsCleanup
 from nautobot.core.jobs.groups import RefreshDynamicGroupCaches
 from nautobot.core.utils.lookup import get_filterset_for_model
 from nautobot.core.utils.requests import get_filterable_params_from_filter_params
-from nautobot.extras.datasources import ensure_git_repository, git_repository_dry_run, refresh_datasource_content
+from nautobot.extras.datasources import (
+    ensure_git_repository,
+    git_repository_dry_run,
+    refresh_datasource_content,
+    refresh_job_code_from_repository,
+)
 from nautobot.extras.jobs import BooleanVar, ChoiceVar, FileVar, Job, ObjectVar, RunJobTaskFailed, StringVar, TextVar
 from nautobot.extras.models import ExportTemplate, GitRepository
 
@@ -49,13 +54,24 @@ class GitRepositorySync(Job):
         self.logger.info(f'Creating/refreshing local copy of Git repository "{repository.name}"...')
 
         try:
-            ensure_git_repository(repository, logger=self.logger)
-            refresh_datasource_content("extras.gitrepository", repository, user, job_result, delete=False)
-            # Given that the above succeeded, tell all workers (including ourself) to call ensure_git_repository()
-            app.control.broadcast("refresh_git_repository", repository_pk=repository.pk, head=repository.current_head)
-        finally:
-            if job_result.duration:
-                self.logger.info("Repository synchronization completed in %s", job_result.duration)
+            with transaction.atomic():
+                ensure_git_repository(repository, logger=self.logger)
+                refresh_datasource_content("extras.gitrepository", repository, user, job_result, delete=False)
+                # Given that the above succeeded, tell all workers (including ourself) to call ensure_git_repository()
+                app.control.broadcast(
+                    "refresh_git_repository", repository_pk=repository.pk, head=repository.current_head
+                )
+                if job_result.duration:
+                    self.logger.info("Repository synchronization completed in %s", job_result.duration)
+        except Exception:
+            job_result.log("Changes to database records have been reverted.")
+            # Re-check-out previous commit if any
+            repository.refresh_from_db()
+            if repository.current_head:
+                job_result.log(f"Attempting to revert local repository clone to commit {repository.current_head}")
+                ensure_git_repository(repository, logger=self.logger, head=repository.current_head)
+                refresh_job_code_from_repository(repository.slug, ignore_import_errors=True)
+            raise
 
 
 class GitRepositoryDryRun(Job):

nautobot/core/models/query_functions.py

@@ -1,5 +1,7 @@
 from django.db import NotSupportedError
-from django.db.models import Aggregate, Func, JSONField
+from django.db.models import Aggregate, Func, JSONField, Value
+from django.db.models.fields.json import compile_json_path
+from django.db.models.functions import Cast
 
 
 class CollateAsChar(Func):
@@ -26,6 +28,150 @@ class CollateAsChar(Func):
         return super().as_sql(compiler, connection, function, template, arg_joiner, **extra_context)
 
 
+class JSONSet(Func):
+    """
+    Set or create the value of a single key in a JSONField.
+
+    Example:
+        model.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "cf_key", "new_value"))
+
+    Limitations:
+        - Postgres and MySQL only.
+        - Does *not* support nested lookups (`key1__key2`), only a single top-level key.
+        - Unlike the referenced Django PR, supports only a single key/value rather than an arbitrary number of them.
+
+    References:
+        - https://code.djangoproject.com/ticket/32519
+        - https://github.com/django/django/pull/18489/files
+    """
+
+    function = None
+
+    def __init__(self, expression, path, value, output_field=None):
+        self.path = path
+        self.value = value
+        super().__init__(expression, output_field=output_field)
+
+    def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
+        """
+        Based on https://github.com/django/django/pull/18489/files.
+
+        Transforms and inserts self.path and self.value appropriately into the expression fields.
+        """
+        c = super().resolve_expression(query, allow_joins, reuse, summarize, for_save)
+        # Resolve expressions in the JSON update values.
+        c.fields = {
+            self.path: (
+                self.value.resolve_expression(query, allow_joins, reuse, summarize, for_save)
+                if hasattr(self.value, "resolve_expression")
+                else self.value
+            )
+        }
+        return c
+
+    def as_sql(self, compiler, connection, function=None, **extra_context):
+        """
+        MySQL implementation based on https://github.com/django/django/pull/18489/files.
+
+        Creates a copy of this object with the appropriately transformed self.path and self.value for MySQL JSON_SET().
+        """
+        if connection.vendor != "mysql":
+            raise NotSupportedError(f"JSONSet is not implemented for database {connection.vendor}")
+
+        copy = self.copy()
+        new_source_expressions = copy.get_source_expressions()
+
+        path = compile_json_path([self.path])
+        value = self.value
+        if not hasattr(value, "resolve_expression"):
+            # Use Value to serialize the value to a string, then Cast to ensure it's treated as JSON.
+            value = Cast(Value(value, output_field=self.output_field), output_field=self.output_field)
+
+        new_source_expressions.extend((Value(path), value))
+        copy.set_source_expressions(new_source_expressions)
+        return super(JSONSet, copy).as_sql(compiler, connection, function="JSON_SET", **extra_context)
+
+    def as_postgresql(self, compiler, connection, function=None, **extra_context):
+        """
+        PostgreSQL implementation based on https://github.com/django/django/pull/18489/files.
+
+        Creates a copy of this object with appropriately transformed self.path and self.value for Postgres JSONB_SET().
+        """
+        copy = self.copy()
+        new_source_expressions = copy.get_source_expressions()
+
+        path = self.path
+        value = self.value
+        if not hasattr(value, "resolve_expression"):
+            # We don't need Cast() here because Value with a JSONFIeld is correctly handled as JSONB by Postgres
+            value = Value(value, output_field=self.output_field)
+        else:
+
+            class ToJSONB(Func):
+                function = "TO_JSONB"
+
+            value = ToJSONB(value, output_field=self.output_field)
+
+        new_source_expressions.extend((Value(f"{{{path}}}"), value))
+        copy.set_source_expressions(new_source_expressions)
+        return super(JSONSet, copy).as_sql(compiler, connection, function="JSONB_SET", **extra_context)
+
+
+class JSONRemove(Func):
+    """
+    Unset and remove a single key in a JSONField.
+
+    Example:
+        model.objects.all().update(_custom_field_data=JSONRemove("_custom_field_data", "cf_key"))
+
+    Limitations:
+        - Postgres and MySQL only.
+        - Does *not* support nested lookups (`key1__key2`), only a single top-level key.
+        - Unlike the referenced Django PR, supports only a single key, not N keys.
+
+    References:
+        - https://code.djangoproject.com/ticket/32519
+        - https://github.com/django/django/pull/18489/files
+    """
+
+    def __init__(self, expression, path):
+        self.path = path
+        super().__init__(expression)
+
+    def as_sql(self, compiler, connection, function=None, **extra_context):
+        """
+        MySQL implementation based on https://github.com/django/django/pull/18489/files.
+
+        Creates a copy of this object with appropriately transformed self.path for MySQL JSON_REMOVE().
+        """
+        if connection.vendor != "mysql":
+            raise NotSupportedError(f"JSONSet is not implemented for database {connection.vendor}")
+
+        copy = self.copy()
+        new_source_expressions = copy.get_source_expressions()
+
+        new_source_expressions.append(Value(compile_json_path([self.path])))
+
+        copy.set_source_expressions(new_source_expressions)
+        return super(JSONRemove, copy).as_sql(compiler, connection, function="JSON_REMOVE", **extra_context)
+
+    def as_postgresql(self, compiler, connection, function=None, **extra_context):
+        """
+        PostgreSQL implementation based on https://github.com/django/django/pull/18489/files.
+
+        Creates a copy of this object with appropriately transformed self.path for Postgres `#-` operator.
+        """
+        copy = self.copy()
+        new_source_expressions = copy.get_source_expressions()
+
+        new_source_expressions.append(Value(f"{{{self.path}}}"))
+
+        copy.set_source_expressions(new_source_expressions)
+        return super(JSONRemove, copy).as_sql(
+            compiler, connection, template="%(expressions)s", arg_joiner="#- ", **extra_context
+        )
+
+
 class JSONBAgg(Aggregate):
     """
     Like django.contrib.postgres.aggregates.JSONBAgg, but different.

nautobot/core/models/tree_queries.py

@@ -1,9 +1,11 @@
 from django.core.cache import cache
 from django.db.models import Case, When
+from django.db.models.signals import post_delete, post_save
 from tree_queries.models import TreeNode
 from tree_queries.query import TreeManager as TreeManager_, TreeQuerySet as TreeQuerySet_
 
 from nautobot.core.models import BaseManager, querysets
+from nautobot.core.signals import invalidate_max_depth_cache
 
 
 class TreeQuerySet(TreeQuerySet_, querysets.RestrictedQuerySet):
@@ -117,3 +119,9 @@ class TreeModel(TreeNode):
         display_str += self.name
         cache.set(cache_key, display_str, 5)
         return display_str
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        post_save.connect(invalidate_max_depth_cache, sender=cls)
+        post_delete.connect(invalidate_max_depth_cache, sender=cls)

nautobot/core/settings.py

@@ -418,7 +418,14 @@ if "NAUTOBOT_ALLOWED_HOSTS" in os.environ and os.environ["NAUTOBOT_ALLOWED_HOSTS
     ALLOWED_HOSTS = os.environ["NAUTOBOT_ALLOWED_HOSTS"].split(" ")
 else:
     ALLOWED_HOSTS = []
+
+# Allow CSRF trusted origins to be set via an environment variable
+# This allows Nautobot to be run behind a reverse proxy that terminates TLS
+# and fix potential issues with CSRF validation
 CSRF_TRUSTED_ORIGINS = []
+if "NAUTOBOT_CSRF_TRUSTED_ORIGINS" in os.environ and os.environ["NAUTOBOT_CSRF_TRUSTED_ORIGINS"] != "":
+    CSRF_TRUSTED_ORIGINS = os.getenv("NAUTOBOT_CSRF_TRUSTED_ORIGINS", "").split(_CONFIG_SETTING_SEPARATOR)
+
 CSRF_FAILURE_VIEW = "nautobot.core.views.csrf_failure"
 DATE_FORMAT = os.getenv("NAUTOBOT_DATE_FORMAT", "N j, Y")
 DATETIME_FORMAT = os.getenv("NAUTOBOT_DATETIME_FORMAT", "N j, Y g:i a")

nautobot/core/settings.yaml

@@ -587,6 +587,16 @@ properties:
     description: >-
       A list of hosts (fully-qualified domain names (FQDNs) or subdomains) that are considered trusted origins
       for cross-site secure requests such as HTTPS POST.
+
+      You might need to set this if you are using a reverse proxy or load balancer that changes the host header or if you face the error
+      'Invalid Form Submission - CSRF failure has occured' and 'Origin checking failed - https://subdomain.example.com does not match any trusted origins.'
+
+      Example:
+
+      ```python
+      CSRF_TRUSTED_ORIGINS = ['https://subdomain.example.com', 'https://*.example.com']
+      ```
+    environment_variable: "NAUTOBOT_CSRF_TRUSTED_ORIGINS"
     items:
       type: "string"
     see_also:

nautobot/core/signals.py

@@ -7,7 +7,6 @@ import logging
 
 from django.contrib.auth.signals import user_logged_in, user_logged_out
 from django.core.cache import cache
-from django.db.models.signals import post_delete, post_save
 from django.dispatch import receiver, Signal
 import redis.exceptions
 
@@ -62,10 +61,12 @@ def disable_for_loaddata(signal_handler):
     return wrapper
 
 
-@receiver(post_save)
-@receiver(post_delete)
 def invalidate_max_depth_cache(sender, **kwargs):
-    """Clear the appropriate TreeManager.max_depth cache as the create/update/delete may have changed the tree."""
+    """
+    Clear the appropriate TreeManager.max_depth cache as the create/update/delete may have changed the tree.
+
+    Note that this signal is connected in `TreeModel.__init_subclass__()` so as to only apply to those models.
+    """
     from nautobot.core.models.tree_queries import TreeManager
 
     if not isinstance(sender.objects, TreeManager):

nautobot/core/templates/nautobot_config.py.j2

@@ -94,9 +94,13 @@ SECRET_KEY = os.getenv("NAUTOBOT_SECRET_KEY", "{{ secret_key }}")
 # FQDNs that are considered trusted origins for secure, cross-domain, requests such as HTTPS POST.
 # If running Nautobot under a single domain, you may not need to set this variable;
 # if running on multiple domains, you *may* need to set this variable to more or less the same as ALLOWED_HOSTS above.
+# You also want to set this variable if you are facing CSRF validation issues such as 
+# 'CSRF failure has occured' or 'Origin checking failed - https://subdomain.example.com does not match any trusted origins.'
 # https://docs.djangoproject.com/en/stable/ref/settings/#csrf-trusted-origins
 #
 # CSRF_TRUSTED_ORIGINS = []
+# if "NAUTOBOT_CSRF_TRUSTED_ORIGINS" in os.environ and os.environ["NAUTOBOT_CSRF_TRUSTED_ORIGINS"] != "":
+#    CSRF_TRUSTED_ORIGINS = os.getenv("NAUTOBOT_CSRF_TRUSTED_ORIGINS", "").split(_CONFIG_SETTING_SEPARATOR)
 
 # Date/time formatting. See the following link for supported formats:
 # https://docs.djangoproject.com/en/stable/ref/templates/builtins/#date

nautobot/core/tests/test_models_query_functions.py

@@ -0,0 +1,108 @@
+from nautobot.core.models.query_functions import JSONRemove, JSONSet
+from nautobot.core.testing import TestCase
+from nautobot.dcim.models import Manufacturer
+
+
+class JSONFuncTests(TestCase):
+    """Test JSONSet and JSONRemove functionality."""
+
+    def test_json_set(self):
+        # Setting a key/value should efficiently work
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "a", 1))
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(1, mfr._custom_field_data["a"])
+
+        # Setting a different key/value shouldn't overwrite other keys
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "b", "text"))
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(1, mfr._custom_field_data["a"])
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("text", mfr._custom_field_data["b"])
+
+        # Setting a key/value again should overwrite that value only
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "b", "more text"))
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(1, mfr._custom_field_data["a"])
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("more text", mfr._custom_field_data["b"])
+
+        # A filtered query should be updatable
+        with self.assertNumQueries(1):
+            Manufacturer.objects.filter(name__istartswith="a").update(
+                _custom_field_data=JSONSet("_custom_field_data", "a", None)
+            )
+        for mfr in Manufacturer.objects.filter(name__istartswith="a"):
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(None, mfr._custom_field_data["a"])
+        for mfr in Manufacturer.objects.exclude(name__istartswith="a"):
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(1, mfr._custom_field_data["a"])
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("more text", mfr._custom_field_data["b"])
+
+        # Setting a value doesn't require all existing values to be homogeneous
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "a", "hello"))
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual("hello", mfr._custom_field_data["a"])
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("more text", mfr._custom_field_data["b"])
+
+    def test_json_remove(self):
+        Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "a", 1))
+        Manufacturer.objects.filter(name__istartswith="a").update(
+            _custom_field_data=JSONSet("_custom_field_data", "b", "hello")
+        )
+        Manufacturer.objects.exclude(name__istartswith="a").update(
+            _custom_field_data=JSONSet("_custom_field_data", "b", "world")
+        )
+
+        # Should be able to clear all values for a key without impacting other keys
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONRemove("_custom_field_data", "a"))
+        for mfr in Manufacturer.objects.all():
+            self.assertNotIn("a", mfr._custom_field_data)
+            self.assertIn("b", mfr._custom_field_data)
+        for mfr in Manufacturer.objects.filter(name__istartswith="a"):
+            self.assertEqual("hello", mfr._custom_field_data["b"])
+        for mfr in Manufacturer.objects.exclude(name__istartswith="a"):
+            self.assertEqual("world", mfr._custom_field_data["b"])
+
+        # Clearing a value that doesn't exist should be safe
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONRemove("_custom_field_data", "a"))
+        for mfr in Manufacturer.objects.all():
+            self.assertNotIn("a", mfr._custom_field_data)
+            self.assertIn("b", mfr._custom_field_data)
+        for mfr in Manufacturer.objects.filter(name__istartswith="a"):
+            self.assertEqual("hello", mfr._custom_field_data["b"])
+        for mfr in Manufacturer.objects.exclude(name__istartswith="a"):
+            self.assertEqual("world", mfr._custom_field_data["b"])
+
+        # Subsets should be updateable
+        with self.assertNumQueries(1):
+            Manufacturer.objects.filter(name__istartswith="a").update(
+                _custom_field_data=JSONRemove("_custom_field_data", "b")
+            )
+        for mfr in Manufacturer.objects.all():
+            self.assertNotIn("a", mfr._custom_field_data)
+        for mfr in Manufacturer.objects.filter(name__istartswith="a"):
+            self.assertNotIn("b", mfr._custom_field_data)
+        for mfr in Manufacturer.objects.exclude(name__istartswith="a"):
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("world", mfr._custom_field_data["b"])
+
+        # Non-homogeneous data should be updatable
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONRemove("_custom_field_data", "b"))
+        for mfr in Manufacturer.objects.all():
+            self.assertNotIn("a", mfr._custom_field_data)
+            self.assertNotIn("b", mfr._custom_field_data)

nautobot/dcim/forms.py

@@ -13,6 +13,8 @@ from nautobot.core.forms import (
     add_blank_choice,
     APISelect,
     APISelectMultiple,
+    AutoPositionField,
+    AutoPositionPatternField,
     BootstrapMixin,
     BulkEditNullBooleanSelect,
     ColorSelect,
@@ -269,23 +271,7 @@ class ComponentForm(BootstrapMixin, forms.Form):
 
 
 class ModularComponentForm(ComponentForm):
-    name_pattern = ExpandableNameField(
-        label="Name",
-        help_text="""
-            Alphanumeric ranges are supported for bulk creation. Mixed cases and types within a single range
-            are not supported. Examples:
-            <ul>
-                <li><code>[ge,xe]-0/0/[0-9]</code></li>
-                <li><code>e[0-3][a-d,f]</code></li>
-            </ul>
-
-            The variables <code>{module}</code>, <code>{module.parent}</code>, <code>{module.parent.parent}</code>, etc.
-            may be used in the name field and will be replaced by the <code>position</code> of the module bay that the
-            module occupies (skipping over any bays with a blank <code>position</code>). These variables can be used
-            multiple times in the component name and there is no limit to the depth of parent levels.
-            Any variables that cannot be replaced by a suitable position value will remain unchanged.
-                """,
-    )
+    """Base class for forms for components that can be assigned to either a device or a module."""
 
 
 #
@@ -1064,11 +1050,27 @@ class ComponentTemplateCreateForm(ComponentForm):
     description = forms.CharField(required=False)
 
 
-class ModularComponentTemplateCreateForm(ModularComponentForm):
+class ModularComponentTemplateCreateForm(ComponentTemplateCreateForm):
     """
     Base form for the creation of modular device component templates (subclassed from ModularComponentTemplateModel).
     """
 
+    name_pattern = ExpandableNameField(
+        label="Name",
+        help_text="""
+        Alphanumeric ranges are supported for bulk creation. Mixed cases and types within a single range
+        are not supported. Examples:
+        <ul>
+            <li><code>[ge,xe]-0/0/[0-9]</code></li>
+            <li><code>e[0-3][a-d,f]</code></li>
+        </ul>
+
+        The variables <code>{module}</code>, <code>{module.parent}</code>, <code>{module.parent.parent}</code>, etc.
+        may be used in the name field and will be replaced by the <code>position</code> of the module bay that the
+        module occupies (skipping over any bays with a blank <code>position</code>). These variables can be used
+        multiple times in the component name and there is no limit to the depth of parent levels.
+        Any variables that cannot be replaced by a suitable position value will remain unchanged.""",
+    )
     device_type = DynamicModelChoiceField(
         queryset=DeviceType.objects.all(),
         required=False,
@@ -1077,7 +1079,6 @@ class ModularComponentTemplateCreateForm(ModularComponentForm):
         queryset=ModuleType.objects.all(),
         required=False,
     )
-    description = forms.CharField(required=False)
 
 
 class ConsolePortTemplateForm(ModularComponentTemplateForm):
@@ -1570,10 +1571,10 @@ class ModuleBayBaseCreateForm(BootstrapMixin, forms.Form):
         required=False,
         help_text="Alphanumeric ranges are supported. (Must match the number of names being created.)",
     )
-    position_pattern = ExpandableNameField(
-        label="Position",
+    position_pattern = AutoPositionPatternField(
         required=False,
-        help_text="Alphanumeric ranges are supported. (Must match the number of names being created.)",
+        help_text="Alphanumeric ranges are supported. (Must match the number of names being created.)"
+        " Default to the names of the module bays unless manually supplied by the user.",
     )
     description = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False)
 
@@ -2542,12 +2543,8 @@ class DeviceBulkAddComponentForm(ComponentForm, CustomFieldModelBulkEditFormMixi
         nullable_fields = []
 
 
-class ModuleBulkAddComponentForm(ModularComponentForm, CustomFieldModelBulkEditFormMixin):
+class ModuleBulkAddComponentForm(DeviceBulkAddComponentForm):
     pk = forms.ModelMultipleChoiceField(queryset=Module.objects.all(), widget=forms.MultipleHiddenInput())
-    description = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False)
-
-    class Meta:
-        nullable_fields = []
 
 
 #
@@ -3566,6 +3563,12 @@ class ModuleBayFilterForm(NautobotFilterForm):
 
 
 class ModuleBayForm(NautobotModelForm):
+    position = AutoPositionField(
+        max_length=CHARFIELD_MAX_LENGTH,
+        help_text="The position of the module bay within the parent device/module. "
+        "Defaults to the name of the module bay unless overridden.",
+        required=False,
+    )
     parent_device = DynamicModelChoiceField(
         queryset=Device.objects.all(),
         required=False,

nautobot/dcim/models/device_components.py

@@ -1280,3 +1280,8 @@ class ModuleBay(PrimaryModel):
 
         if not (self.parent_device or self.parent_module):
             raise ValidationError("Either parent_device or parent_module must be set")
+
+        # Populate the position field with the name of the module bay if it is not supplied by the user.
+
+        if not self.position:
+            self.position = self.name

nautobot/dcim/tables/devices.py

@@ -173,6 +173,7 @@ class DeviceTable(StatusTableMixin, RoleTableMixin, BaseTable):
         template_code="""{% if record.device_redundancy_group %}<span class="badge badge-default">{{ record.device_redundancy_group_priority|default:'None' }}</span>{% else %}—{% endif %}"""
     )
     controller_managed_device_group = tables.Column(linkify=True)
+    software_version = tables.Column(linkify=True, verbose_name="Software Version")
     secrets_group = tables.Column(linkify=True)
     tags = TagColumn(url_name="dcim:device_list")
 
@@ -201,6 +202,7 @@ class DeviceTable(StatusTableMixin, RoleTableMixin, BaseTable):
             "vc_priority",
             "device_redundancy_group",
             "device_redundancy_group_priority",
+            "software_version",
             "controller_managed_device_group",
             "secrets_group",
             "tags",
@@ -616,7 +618,7 @@ class DeviceModulePowerOutletTable(PowerOutletTable):
         row_attrs = {"class": cable_status_color_css}
 
 
-class BaseInterfaceTable(BaseTable):
+class BaseInterfaceTable(StatusTableMixin, RoleTableMixin, BaseTable):
     enabled = BooleanColumn()
     ip_addresses = tables.TemplateColumn(
         template_code=INTERFACE_IPADDRESSES,
@@ -632,7 +634,7 @@ class BaseInterfaceTable(BaseTable):
     vrf = tables.Column(linkify=True, verbose_name="VRF")
 
 
-class InterfaceTable(StatusTableMixin, ModularDeviceComponentTable, BaseInterfaceTable, PathEndpointTable):
+class InterfaceTable(ModularDeviceComponentTable, BaseInterfaceTable, PathEndpointTable):
     mgmt_only = BooleanColumn()
     tags = TagColumn(url_name="dcim:interface_list")