Rename MACPrefix to MACBlock ("MAC address block")

docs/features/devices-cabling.md

@@ -91,7 +91,7 @@ One especially nice feature of modules is that templated components can be autom
 
 [MAC addresses](../models/dcim/macaddress.md) are modeled as first-class objects in NetBox so that an interface may have multiple MAC addresses assigned to it, with one optionally designated as the interface's primary MAC. This accommodates virtual interfaces and modular hardware where the link-layer address is not necessarily fixed at the factory. MAC addresses can be assigned to both [device interfaces](../models/dcim/interface.md) and [virtual machine interfaces](../models/virtualization/vminterface.md).
 
-[MAC prefixes](../models/dcim/macprefix.md) represent blocks of MAC addresses, such as organizationally unique identifiers (OUIs). They can be used to track the utilization of a block, to create MAC addresses from the next available address in a block, and to prevent duplicate MAC addresses within a block.
+[MAC address blocks](../models/dcim/macblock.md) represent blocks of MAC addresses, such as organizationally unique identifiers (OUIs). They can be used to track the utilization of a block, to create MAC addresses from the next available address in a block, and to prevent duplicate MAC addresses within a block.
 
 ## Cables
 

docs/models/dcim/macaddress.md

@@ -4,7 +4,7 @@ A MAC address object in NetBox represents a single Ethernet link-layer address a
 
 Most physical interfaces have only a single MAC address, hard-coded at the factory. However, some interfaces (particularly virtual interfaces and modular hardware) support multiple or reassignable MAC addresses. To accommodate this, NetBox models MAC addresses as first-class objects which may be created, modified, and reassigned independently of any specific interface.
 
-Blocks of MAC addresses, such as organizationally unique identifiers (OUIs), can be tracked as [MAC prefixes](./macprefix.md).
+Blocks of MAC addresses, such as organizationally unique identifiers (OUIs), can be tracked as [MAC address blocks](./macblock.md).
 
 ## Fields
 

docs/models/dcim/macblock.md

@@ -0,0 +1,33 @@
+# MAC Address Blocks
+
+A MAC address block represents a contiguous range of [MAC addresses](./macaddress.md), defined by a prefix (the first address in the block) and a prefix length (the number of leading bits shared by every address in it). This mirrors the blocks assigned by the IEEE: an organizationally unique identifier (OUI, or MA-L block) such as `BC:24:11` is a MAC address block with a prefix length of 24, spanning the MAC addresses `BC:24:11:00:00:00` through `BC:24:11:FF:FF:FF`. The smaller MA-M and MA-S blocks have lengths of 28 and 36 bits, respectively. Blocks can also represent ranges within an assigned block which are set aside for a particular purpose, such as a virtualization cluster.
+
+A MAC address belongs to every MAC address block which contains it: MAC addresses are not explicitly assigned to blocks. The MAC address view shows the most specific block which contains it.
+
+Each MAC address block shows its utilization (the percentage of its MAC addresses which exist in NetBox), and its MAC addresses. A new MAC address can be created from the first available address within the block, using either the UI or the REST API (`/api/dcim/mac-blocks/<id>/available-mac-addresses/`).
+
+## Fields
+
+### Prefix
+
+The first MAC address in the block, for example `BC:24:11:00:00:00`. Any bits beyond the prefix length are cleared when the prefix is saved.
+
+### Prefix Length
+
+The number of leading bits which are shared by all MAC addresses in the block (1 to 48). Defaults to 24, the length of an OUI.
+
+### Name
+
+An optional name for the block, such as the organization to which it is assigned.
+
+### Enforce Unique
+
+If enabled, duplicate MAC addresses are not permitted within this block. Uniqueness cannot be enforced on a block which already contains duplicate MAC addresses.
+
+### Description
+
+An optional human-readable description of the MAC address block.
+
+### Comments
+
+Free-form Markdown-supported notes regarding the MAC address block.

docs/models/dcim/macprefix.md

@@ -1,33 +0,0 @@
-# MAC Prefixes
-
-A MAC prefix represents a block of [MAC addresses](./macaddress.md) which share a common leading sequence of bits. For example, an organizationally unique identifier (OUI) such as `BC:24:11` is a MAC prefix with a length of 24 bits, which spans the MAC addresses `BC:24:11:00:00:00` through `BC:24:11:FF:FF:FF`. MAC prefixes can also represent the smaller blocks assigned by the IEEE (MA-M and MA-S blocks have lengths of 28 and 36 bits, respectively), or blocks within an OUI set aside for a particular purpose, such as a virtualization cluster.
-
-A MAC address belongs to every MAC prefix which contains it: MAC addresses are not explicitly assigned to prefixes. The MAC address view shows the most specific prefix which contains it.
-
-Each MAC prefix shows its utilization (the percentage of its MAC addresses which exist in NetBox), and its MAC addresses. A new MAC address can be created from the first available address within the prefix, using either the UI or the REST API (`/api/dcim/mac-prefixes/<id>/available-mac-addresses/`).
-
-## Fields
-
-### Prefix
-
-The first MAC address in the block, for example `BC:24:11:00:00:00`. Any bits beyond the prefix length are cleared when the prefix is saved.
-
-### Prefix Length
-
-The number of leading bits which are shared by all MAC addresses in the block (1 to 48). Defaults to 24, the length of an OUI.
-
-### Name
-
-An optional name for the block, such as the organization to which it is assigned.
-
-### Enforce Unique
-
-If enabled, duplicate MAC addresses are not permitted within this prefix. Uniqueness cannot be enforced on a prefix which already contains duplicate MAC addresses.
-
-### Description
-
-An optional human-readable description of the MAC prefix.
-
-### Comments
-
-Free-form Markdown-supported notes regarding the MAC prefix.

mkdocs.yml

@@ -225,7 +225,7 @@ nav:
             - InventoryItemTemplate: 'models/dcim/inventoryitemtemplate.md'
             - Location: 'models/dcim/location.md'
             - MACAddress: 'models/dcim/macaddress.md'
-            - MACPrefix: 'models/dcim/macprefix.md'
+            - MACBlock: 'models/dcim/macblock.md'
             - Manufacturer: 'models/dcim/manufacturer.md'
             - Module: 'models/dcim/module.md'
             - ModuleBay: 'models/dcim/modulebay.md'

netbox/dcim/api/serializers_/devices.py

@@ -8,7 +8,7 @@ from rest_framework import serializers
 
 from dcim.choices import *
 from dcim.constants import MACADDRESS_ASSIGNMENT_MODELS
-from dcim.models import Device, DeviceBay, MACAddress, MACPrefix, Module, VirtualDeviceContext
+from dcim.models import Device, DeviceBay, MACAddress, MACBlock, Module, VirtualDeviceContext
 from dcim.utils import get_module_bay_positions, resolve_module_placeholder
 from extras.api.serializers_.configtemplates import ConfigTemplateSerializer
 from ipam.api.serializers_.ip import IPAddressSerializer
@@ -30,7 +30,7 @@ __all__ = (
     'AvailableMACAddressSerializer',
     'DeviceSerializer',
     'MACAddressSerializer',
-    'MACPrefixSerializer',
+    'MACBlockSerializer',
     'ModuleSerializer',
     'VirtualDeviceContextSerializer',
 )
@@ -363,21 +363,21 @@ class MACAddressSerializer(PrimaryModelSerializer):
         brief_fields = ('id', 'url', 'display', 'mac_address', 'description')
 
 
-class MACPrefixSerializer(PrimaryModelSerializer):
+class MACBlockSerializer(PrimaryModelSerializer):
     last_address = serializers.CharField(read_only=True)
     size = serializers.IntegerField(read_only=True)
     mac_address_count = serializers.IntegerField(read_only=True)
     utilization = serializers.FloatField(read_only=True)
 
     class Meta:
-        model = MACPrefix
+        model = MACBlock
         fields = [
             'id', 'url', 'display_url', 'display', 'prefix', 'prefix_length', 'last_address', 'size', 'name',
             'enforce_unique', 'mac_address_count', 'utilization', 'description', 'owner', 'comments', 'tags',
             'custom_fields', 'created', 'last_updated',
         ]
         brief_fields = ('id', 'url', 'display', 'prefix', 'prefix_length', 'name', 'description')
-        # Preserve the prefix as normalized by MACPrefix.clean()
+        # Preserve the prefix as normalized by MACBlock.clean()
         model_clean_fields = ('prefix',)
 
 

netbox/dcim/api/urls.py

@@ -67,7 +67,7 @@ router.register('inventory-item-roles', views.InventoryItemRoleViewSet)
 
 # Addressing
 router.register('mac-addresses', views.MACAddressViewSet)
-router.register('mac-prefixes', views.MACPrefixViewSet)
+router.register('mac-blocks', views.MACBlockViewSet)
 
 # Cables
 router.register('cables', views.CableViewSet)
@@ -92,9 +92,9 @@ app_name = 'dcim-api'
 
 urlpatterns = [
     path(
-        'mac-prefixes/<int:pk>/available-mac-addresses/',
-        views.MACPrefixAvailableMACAddressesView.as_view(),
-        name='macprefix-available-mac-addresses'
+        'mac-blocks/<int:pk>/available-mac-addresses/',
+        views.MACBlockAvailableMACAddressesView.as_view(),
+        name='macblock-available-mac-addresses'
     ),
 ]
 

netbox/dcim/api/views.py

@@ -607,23 +607,23 @@ class MACAddressViewSet(NetBoxModelViewSet):
     filterset_class = filtersets.MACAddressFilterSet
 
 
-class MACPrefixViewSet(NetBoxModelViewSet):
-    queryset = MACPrefix.objects.annotate_mac_address_count()
-    serializer_class = serializers.MACPrefixSerializer
-    filterset_class = filtersets.MACPrefixFilterSet
+class MACBlockViewSet(NetBoxModelViewSet):
+    queryset = MACBlock.objects.annotate_mac_address_count()
+    serializer_class = serializers.MACBlockSerializer
+    filterset_class = filtersets.MACBlockFilterSet
 
 
-class MACPrefixAvailableMACAddressesView(AvailableObjectsView):
+class MACBlockAvailableMACAddressesView(AvailableObjectsView):
     queryset = MACAddress.objects.all()
     read_serializer_class = serializers.AvailableMACAddressSerializer
     write_serializer_class = serializers.AvailableMACAddressSerializer
     advisory_lock_key = 'available-mac-addresses'
 
     def get_parent(self, request, pk):
-        return get_object_or_404(MACPrefix.objects.restrict(request.user), pk=pk)
+        return get_object_or_404(MACBlock.objects.restrict(request.user), pk=pk)
 
     def get_available_objects(self, parent, limit=None):
-        # A prefix may contain millions of available MAC addresses, so always apply a limit
+        # A block may contain millions of available MAC addresses, so always apply a limit
         if not limit or limit < 0:
             limit = get_config().PAGINATE_COUNT
         return list(islice(parent.iter_available_mac_addresses(), limit))

netbox/dcim/constants.py

@@ -86,12 +86,12 @@ NONCONNECTABLE_IFACE_TYPES = VIRTUAL_IFACE_TYPES + WIRELESS_IFACE_TYPES + [
 
 
 #
-# MAC prefixes
+# MAC blocks
 #
 
-MACPREFIX_LENGTH_MIN = 1
-MACPREFIX_LENGTH_MAX = 48
-MACPREFIX_LENGTH_DEFAULT = 24  # An organizationally unique identifier (OUI)
+MACBLOCK_LENGTH_MIN = 1
+MACBLOCK_LENGTH_MAX = 48
+MACBLOCK_LENGTH_DEFAULT = 24  # An organizationally unique identifier (OUI)
 
 
 #

netbox/dcim/filtersets.py

@@ -79,7 +79,7 @@ __all__ = (
     'InventoryItemTemplateFilterSet',
     'LocationFilterSet',
     'MACAddressFilterSet',
-    'MACPrefixFilterSet',
+    'MACBlockFilterSet',
     'ManufacturerFilterSet',
     'ModuleBayFilterSet',
     'ModuleBayTemplateFilterSet',
@@ -2288,9 +2288,9 @@ class MACAddressFilterSet(PrimaryModelFilterSet):
         method='filter_primary',
         label=_('Is primary'),
     )
-    mac_prefix_id = MultiValueBigNumberFilter(
-        method='filter_mac_prefix',
-        label=_('MAC prefix (ID)'),
+    mac_block_id = MultiValueBigNumberFilter(
+        method='filter_mac_block',
+        label=_('MAC address block (ID)'),
     )
 
     class Meta:
@@ -2349,17 +2349,17 @@ class MACAddressFilterSet(PrimaryModelFilterSet):
             return queryset.filter(query)
         return queryset.exclude(query)
 
-    def filter_mac_prefix(self, queryset, name, value):
+    def filter_mac_block(self, queryset, name, value):
         query = Q()
-        for mac_prefix in MACPrefix.objects.filter(pk__in=value):
-            query |= Q(mac_address__gte=mac_prefix.first_address, mac_address__lte=mac_prefix.last_address)
+        for mac_block in MACBlock.objects.filter(pk__in=value):
+            query |= Q(mac_address__gte=mac_block.first_address, mac_address__lte=mac_block.last_address)
         if not query:
             return queryset.none()
         return queryset.filter(query)
 
 
 @register_filterset
-class MACPrefixFilterSet(PrimaryModelFilterSet):
+class MACBlockFilterSet(PrimaryModelFilterSet):
     prefix = MultiValueMACAddressFilter()
     contains = django_filters.CharFilter(
         method='filter_contains',
@@ -2367,7 +2367,7 @@ class MACPrefixFilterSet(PrimaryModelFilterSet):
     )
 
     class Meta:
-        model = MACPrefix
+        model = MACBlock
         fields = ('id', 'prefix_length', 'name', 'enforce_unique', 'description')
 
     def search(self, queryset, name, value):

netbox/dcim/forms/bulk_edit.py

@@ -63,7 +63,7 @@ __all__ = (
     'InventoryItemTemplateBulkEditForm',
     'LocationBulkEditForm',
     'MACAddressBulkEditForm',
-    'MACPrefixBulkEditForm',
+    'MACBlockBulkEditForm',
     'ManufacturerBulkEditForm',
     'ModuleBayBulkEditForm',
     'ModuleBayTemplateBulkEditForm',
@@ -2286,7 +2286,7 @@ class MACAddressBulkEditForm(PrimaryModelBulkEditForm):
     nullable_fields = ('description', 'comments')
 
 
-class MACPrefixBulkEditForm(PrimaryModelBulkEditForm):
+class MACBlockBulkEditForm(PrimaryModelBulkEditForm):
     name = forms.CharField(
         label=_('Name'),
         max_length=100,
@@ -2298,7 +2298,7 @@ class MACPrefixBulkEditForm(PrimaryModelBulkEditForm):
         widget=BulkEditNullBooleanSelect
     )
 
-    model = MACPrefix
+    model = MACBlock
     fieldsets = (
         FieldSet('name', 'enforce_unique', 'description'),
     )

netbox/dcim/forms/bulk_import.py

@@ -55,7 +55,7 @@ __all__ = (
     'InventoryItemRoleImportForm',
     'LocationImportForm',
     'MACAddressImportForm',
-    'MACPrefixImportForm',
+    'MACBlockImportForm',
     'ManufacturerImportForm',
     'ModuleBayImportForm',
     'ModuleBayTypeImportForm',
@@ -1711,10 +1711,10 @@ class MACAddressImportForm(PrimaryModelImportForm):
         return instance
 
 
-class MACPrefixImportForm(PrimaryModelImportForm):
+class MACBlockImportForm(PrimaryModelImportForm):
 
     class Meta:
-        model = MACPrefix
+        model = MACBlock
         fields = [
             'prefix', 'prefix_length', 'name', 'enforce_unique', 'description', 'owner', 'comments', 'tags',
         ]

netbox/dcim/forms/filtersets.py

@@ -60,7 +60,7 @@ __all__ = (
     'InventoryItemTemplateFilterForm',
     'LocationFilterForm',
     'MACAddressFilterForm',
-    'MACPrefixFilterForm',
+    'MACBlockFilterForm',
     'ManufacturerFilterForm',
     'ModuleBayFilterForm',
     'ModuleBayTemplateFilterForm',
@@ -2453,7 +2453,7 @@ class MACAddressFilterForm(PrimaryModelFilterSetForm):
     model = MACAddress
     fieldsets = (
         FieldSet('q', 'filter_id', 'tag'),
-        FieldSet('mac_address', 'mac_prefix_id', name=_('Attributes')),
+        FieldSet('mac_address', 'mac_block_id', name=_('Attributes')),
         FieldSet('device_id', 'virtual_machine_id', 'assigned', 'primary', name=_('Assignments')),
         FieldSet('owner_group_id', 'owner_id', name=_('Ownership')),
     )
@@ -2462,10 +2462,10 @@ class MACAddressFilterForm(PrimaryModelFilterSetForm):
         required=False,
         label=_('MAC address'),
     )
-    mac_prefix_id = DynamicModelMultipleChoiceField(
-        queryset=MACPrefix.objects.all(),
+    mac_block_id = DynamicModelMultipleChoiceField(
+        queryset=MACBlock.objects.all(),
         required=False,
-        label=_('MAC prefix'),
+        label=_('MAC address block'),
     )
     device_id = DynamicModelMultipleChoiceField(
         queryset=Device.objects.all(),
@@ -2494,8 +2494,8 @@ class MACAddressFilterForm(PrimaryModelFilterSetForm):
     tag = TagFilterField(model)
 
 
-class MACPrefixFilterForm(PrimaryModelFilterSetForm):
-    model = MACPrefix
+class MACBlockFilterForm(PrimaryModelFilterSetForm):
+    model = MACBlock
     fieldsets = (
         FieldSet('q', 'filter_id', 'tag'),
         FieldSet('prefix', 'prefix_length', 'contains', 'enforce_unique', name=_('Attributes')),
@@ -2507,8 +2507,8 @@ class MACPrefixFilterForm(PrimaryModelFilterSetForm):
     )
     prefix_length = forms.IntegerField(
         required=False,
-        min_value=MACPREFIX_LENGTH_MIN,
-        max_value=MACPREFIX_LENGTH_MAX,
+        min_value=MACBLOCK_LENGTH_MIN,
+        max_value=MACBLOCK_LENGTH_MAX,
         label=_('Prefix length'),
     )
     contains = forms.CharField(

netbox/dcim/forms/model_forms.py

@@ -73,7 +73,7 @@ __all__ = (
     'InventoryItemTemplateForm',
     'LocationForm',
     'MACAddressForm',
-    'MACPrefixForm',
+    'MACBlockForm',
     'ManufacturerForm',
     'ModuleBayForm',
     'ModuleBayTemplateForm',
@@ -2606,7 +2606,7 @@ class MACAddressForm(PrimaryModelForm):
             self.instance.assigned_object = None
 
 
-class MACPrefixForm(PrimaryModelForm):
+class MACBlockForm(PrimaryModelForm):
     prefix = forms.CharField(
         required=True,
         label=_('Prefix'),
@@ -2614,11 +2614,13 @@ class MACPrefixForm(PrimaryModelForm):
     )
 
     fieldsets = (
-        FieldSet('prefix', 'prefix_length', 'name', 'enforce_unique', 'description', 'tags', name=_('MAC Prefix')),
+        FieldSet(
+            'prefix', 'prefix_length', 'name', 'enforce_unique', 'description', 'tags', name=_('MAC Address Block')
+        ),
     )
 
     class Meta:
-        model = MACPrefix
+        model = MACBlock
         fields = [
             'prefix', 'prefix_length', 'name', 'enforce_unique', 'description', 'owner', 'comments', 'tags',
         ]

netbox/dcim/graphql/filters.py

@@ -97,7 +97,7 @@ __all__ = (
     'InventoryItemTemplateFilter',
     'LocationFilter',
     'MACAddressFilter',
-    'MACPrefixFilter',
+    'MACBlockFilter',
     'ManufacturerFilter',
     'ModuleBayFilter',
     'ModuleBayTemplateFilter',
@@ -539,8 +539,8 @@ class MACAddressFilter(PrimaryModelFilter):
         return ~Q(query)
 
 
-@register_filter(models.MACPrefix, lookups=True)
-class MACPrefixFilter(PrimaryModelFilter):
+@register_filter(models.MACBlock, lookups=True)
+class MACBlockFilter(PrimaryModelFilter):
     prefix: StrFilterLookup | None = strawberry_django.filter_field()
     prefix_length: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (
         strawberry_django.filter_field()

netbox/dcim/graphql/schema.py

@@ -66,8 +66,8 @@ class DCIMQuery:
     mac_address: MACAddressType = strawberry_django.field()
     mac_address_list: list[MACAddressType] = strawberry_django.field()
 
-    mac_prefix: MACPrefixType = strawberry_django.field()
-    mac_prefix_list: list[MACPrefixType] = strawberry_django.field()
+    mac_block: MACBlockType = strawberry_django.field()
+    mac_block_list: list[MACBlockType] = strawberry_django.field()
 
     interface: InterfaceType = strawberry_django.field()
     interface_list: list[InterfaceType] = strawberry_django.field()

netbox/dcim/graphql/types.py

@@ -74,7 +74,7 @@ __all__ = (
     'InventoryItemType',
     'LocationType',
     'MACAddressType',
-    'MACPrefixType',
+    'MACBlockType',
     'ManufacturerType',
     'ModularComponentType',
     'ModuleBayTemplateType',
@@ -526,12 +526,12 @@ class FrontPortTemplateType(ModularComponentTemplateType):
 
 
 @register_type(
-    models.MACPrefix,
+    models.MACBlock,
     exclude=['_last_address'],
-    filters=MACPrefixFilter,
+    filters=MACBlockFilter,
     pagination=True
 )
-class MACPrefixType(PrimaryObjectType):
+class MACBlockType(PrimaryObjectType):
     prefix: str
 
 

netbox/dcim/migrations/0253_macprefix.py → netbox/dcim/migrations/0253_macblock.py

@@ -1,4 +1,4 @@
-# Generated by Django 6.1.1 on 2026-11-11 01:08
+# Generated by Django 6.1.1 on 2026-11-12 14:04
 
 import django.core.validators
 import django.db.models.deletion
@@ -19,7 +19,7 @@ class Migration(migrations.Migration):
 
     operations = [
         migrations.CreateModel(
-            name='MACPrefix',
+            name='MACBlock',
             fields=[
                 ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False)),
                 ('created', models.DateTimeField(auto_now_add=True, null=True)),
@@ -57,18 +57,18 @@ class Migration(migrations.Migration):
                 ('tags', taggit.managers.TaggableManager(through='extras.TaggedItem', to='extras.Tag')),
             ],
             options={
-                'verbose_name': 'MAC prefix',
-                'verbose_name_plural': 'MAC prefixes',
+                'verbose_name': 'MAC address block',
+                'verbose_name_plural': 'MAC address blocks',
                 'ordering': ('prefix', 'prefix_length', 'pk'),
                 'indexes': [
-                    models.Index(fields=['prefix', 'prefix_length', 'id'], name='dcim_macpre_prefix_298c1d_idx'),
-                    models.Index(fields=['prefix', '_last_address'], name='dcim_macpre_prefix_fa4f07_idx'),
+                    models.Index(fields=['prefix', 'prefix_length', 'id'], name='dcim_macblo_prefix_221d31_idx'),
+                    models.Index(fields=['prefix', '_last_address'], name='dcim_macblo_prefix_5acee2_idx'),
                 ],
                 'constraints': [
                     models.UniqueConstraint(
                         fields=('prefix', 'prefix_length'),
-                        name='dcim_macprefix_unique_prefix_prefix_length',
-                        violation_error_message='A MAC prefix with this prefix and length already exists.',
+                        name='dcim_macblock_unique_prefix_prefix_length',
+                        violation_error_message='A MAC address block with this prefix and length already exists.',
                     )
                 ],
             },

netbox/dcim/models/devices.py

@@ -20,7 +20,7 @@ from netaddr import EUI, AddrFormatError
 from dcim.choices import *
 from dcim.constants import *
 from dcim.fields import MACAddressField, mac_unix_expanded_uppercase
-from dcim.querysets import MACPrefixQuerySet
+from dcim.querysets import MACBlockQuerySet
 from dcim.utils import create_port_mappings, update_interface_bridges, update_interface_parents
 from extras.models import ConfigContextModel, CustomField
 from extras.querysets import ConfigContextModelQuerySet
@@ -44,7 +44,7 @@ __all__ = (
     'DeviceRole',
     'DeviceType',
     'MACAddress',
-    'MACPrefix',
+    'MACBlock',
     'Manufacturer',
     'Platform',
     'VirtualChassis',
@@ -1563,35 +1563,35 @@ class MACAddress(PrimaryModel):
                         _("Cannot reassign MAC Address while it is designated as the primary MAC for an object")
                     )
 
-        # Enforce uniqueness within any MAC prefix which requires it
+        # Enforce uniqueness within any MAC block which requires it
         if self.mac_address and (
-            mac_prefix := self.get_mac_prefixes().filter(enforce_unique=True).order_by('-prefix_length').first()
+            mac_block := self.get_mac_blocks().filter(enforce_unique=True).order_by('-prefix_length').first()
         ):
             duplicates = MACAddress.objects.filter(mac_address=self.mac_address).exclude(pk=self.pk)
             if duplicates.exists():
                 raise ValidationError({
                     'mac_address': _(
-                        "Duplicate MAC address found within MAC prefix {mac_prefix}, which enforces uniqueness"
-                    ).format(mac_prefix=mac_prefix)
+                        "Duplicate MAC address found within MAC address block {mac_block}, which enforces uniqueness"
+                    ).format(mac_block=mac_block)
                 })
 
-    def get_mac_prefixes(self):
+    def get_mac_blocks(self):
         """
-        Return all MACPrefixes which contain this MAC address.
+        Return all MACBlocks which contain this MAC address.
         """
-        return MACPrefix.objects.filter(prefix__lte=self.mac_address, _last_address__gte=self.mac_address)
+        return MACBlock.objects.filter(prefix__lte=self.mac_address, _last_address__gte=self.mac_address)
 
     @cached_property
-    def mac_prefix(self):
+    def mac_block(self):
         """
-        Return the most specific MACPrefix which contains this MAC address (if any).
+        Return the most specific MACBlock which contains this MAC address (if any).
         """
         if not self.mac_address:
             return None
-        return self.get_mac_prefixes().order_by('-prefix_length').first()
+        return self.get_mac_blocks().order_by('-prefix_length').first()
 
 
-class MACPrefix(PrimaryModel):
+class MACBlock(PrimaryModel):
     """
     A block of MAC addresses which share a common prefix, such as an organizationally unique identifier (OUI).
     """
@@ -1601,10 +1601,10 @@ class MACPrefix(PrimaryModel):
     )
     prefix_length = models.PositiveSmallIntegerField(
         verbose_name=_('prefix length'),
-        default=MACPREFIX_LENGTH_DEFAULT,
+        default=MACBLOCK_LENGTH_DEFAULT,
         validators=(
-            MinValueValidator(MACPREFIX_LENGTH_MIN),
-            MaxValueValidator(MACPREFIX_LENGTH_MAX),
+            MinValueValidator(MACBLOCK_LENGTH_MIN),
+            MaxValueValidator(MACBLOCK_LENGTH_MAX),
         ),
         help_text=_('Number of leading bits shared by all MAC addresses in the block (e.g. 24 for an OUI)')
     )
@@ -1617,16 +1617,16 @@ class MACPrefix(PrimaryModel):
     enforce_unique = models.BooleanField(
         verbose_name=_('enforce unique'),
         default=False,
-        help_text=_('Prevent duplicate MAC addresses within this prefix')
+        help_text=_('Prevent duplicate MAC addresses within this block')
     )
 
-    # Cached last MAC address in the block, for finding the MAC addresses and prefixes it contains
+    # Cached last MAC address in the block, for finding the MAC addresses and blocks it contains
     _last_address = MACAddressField(
         blank=True,
         editable=False
     )
 
-    objects = MACPrefixQuerySet.as_manager()
+    objects = MACBlockQuerySet.as_manager()
 
     clone_fields = ('prefix_length', 'enforce_unique', 'description')
 
@@ -1640,11 +1640,11 @@ class MACPrefix(PrimaryModel):
             models.UniqueConstraint(
                 fields=('prefix', 'prefix_length'),
                 name='%(app_label)s_%(class)s_unique_prefix_prefix_length',
-                violation_error_message=_("A MAC prefix with this prefix and length already exists.")
+                violation_error_message=_("A MAC address block with this prefix and length already exists.")
             ),
         )
-        verbose_name = _('MAC prefix')
-        verbose_name_plural = _('MAC prefixes')
+        verbose_name = _('MAC address block')
+        verbose_name_plural = _('MAC address blocks')
 
     def __str__(self):
         return f'{self.prefix}/{self.prefix_length}'
@@ -1659,7 +1659,7 @@ class MACPrefix(PrimaryModel):
             prefix_length = int(self.prefix_length)
         except (AddrFormatError, TypeError, ValueError):
             return None
-        if not MACPREFIX_LENGTH_MIN <= prefix_length <= MACPREFIX_LENGTH_MAX:
+        if not MACBLOCK_LENGTH_MIN <= prefix_length <= MACBLOCK_LENGTH_MAX:
             return None
         host_mask = (1 << (48 - prefix_length)) - 1
         return prefix & ~host_mask, prefix | host_mask
@@ -1697,7 +1697,7 @@ class MACPrefix(PrimaryModel):
             self.prefix = first_address
             self._last_address = self.last_address
 
-        # Uniqueness cannot be enforced if the prefix already contains duplicate MAC addresses
+        # Uniqueness cannot be enforced if the block already contains duplicate MAC addresses
         if self.enforce_unique and self.first_address is not None:
             duplicate = self.get_mac_addresses().values('mac_address').annotate(
                 count=Count('pk')
@@ -1705,13 +1705,13 @@ class MACPrefix(PrimaryModel):
             if duplicate:
                 raise ValidationError({
                     'enforce_unique': _(
-                        "Cannot enforce uniqueness: duplicate MAC address {mac_address} exists within this prefix"
+                        "Cannot enforce uniqueness: duplicate MAC address {mac_address} exists within this block"
                     ).format(mac_address=duplicate['mac_address'])
                 })
 
     def save(self, *args, **kwargs):
         if self.first_address is None:
-            raise ValueError(f"Invalid MAC prefix: {self.prefix}/{self.prefix_length}")
+            raise ValueError(f"Invalid MAC address block: {self.prefix}/{self.prefix_length}")
 
         # Clear any host bits from the prefix, and cache the last address in the block
         self.prefix = self.first_address
@@ -1721,15 +1721,15 @@ class MACPrefix(PrimaryModel):
 
     def get_mac_addresses(self):
         """
-        Return all MACAddresses within this prefix.
+        Return all MACAddresses within this block.
         """
         return MACAddress.objects.filter(mac_address__gte=self.first_address, mac_address__lte=self.last_address)
 
-    def get_child_prefixes(self):
+    def get_child_blocks(self):
         """
-        Return all MACPrefixes within this prefix.
+        Return all MACBlocks within this block.
         """
-        return MACPrefix.objects.filter(
+        return MACBlock.objects.filter(
             prefix__gte=self.first_address,
             _last_address__lte=self.last_address,
             prefix_length__gt=self.prefix_length,
@@ -1738,21 +1738,21 @@ class MACPrefix(PrimaryModel):
     @cached_property
     def mac_address_count(self):
         """
-        Return the number of distinct MAC addresses within the prefix. (May be annotated by
-        MACPrefixQuerySet.annotate_mac_address_count().)
+        Return the number of distinct MAC addresses within the block. (May be annotated by
+        MACBlockQuerySet.annotate_mac_address_count().)
         """
         return self.get_mac_addresses().order_by().values('mac_address').distinct().count()
 
     @property
     def utilization(self):
         """
-        Return the percentage of MAC addresses within the prefix which exist in NetBox.
+        Return the percentage of MAC addresses within the block which exist in NetBox.
         """
         return self.mac_address_count / self.size * 100
 
     def _iter_occupied(self, batch_size=5000):
         """
-        Yield the distinct MAC addresses within the prefix which exist in NetBox as integers, in ascending order.
+        Yield the distinct MAC addresses within the block which exist in NetBox as integers, in ascending order.
         Addresses are fetched in batches, so that stopping early stops reading from the database.
         """
         resume = self.first_address
@@ -1771,7 +1771,7 @@ class MACPrefix(PrimaryModel):
 
     def iter_available_mac_addresses(self):
         """
-        Yield the MAC addresses within the prefix which do not exist in NetBox, in ascending order.
+        Yield the MAC addresses within the block which do not exist in NetBox, in ascending order.
         """
         candidate = int(self.first_address)
         for occupied in self._iter_occupied():
@@ -1783,6 +1783,6 @@ class MACPrefix(PrimaryModel):
 
     def get_first_available_mac_address(self):
         """
-        Return the first MAC address within the prefix which does not exist in NetBox (or None).
+        Return the first MAC address within the block which does not exist in NetBox (or None).
         """
         return next(self.iter_available_mac_addresses(), None)

netbox/dcim/querysets.py

@@ -4,15 +4,15 @@ from django.db.models.functions import Coalesce
 from utilities.querysets import RestrictedQuerySet
 
 __all__ = (
-    'MACPrefixQuerySet',
+    'MACBlockQuerySet',
 )
 
 
-class MACPrefixQuerySet(RestrictedQuerySet):
+class MACBlockQuerySet(RestrictedQuerySet):
 
     def annotate_mac_address_count(self):
         """
-        Annotate the number of distinct MAC addresses within each MACPrefix.
+        Annotate the number of distinct MAC addresses within each MACBlock.
         """
         from .models import MACAddress
 

netbox/dcim/search.py

@@ -168,8 +168,8 @@ class MACAddressIndex(SearchIndex):
 
 
 @register_search
-class MACPrefixIndex(SearchIndex):
-    model = models.MACPrefix
+class MACBlockIndex(SearchIndex):
+    model = models.MACBlock
     fields = (
         ('prefix', 100),
         ('name', 100),

netbox/dcim/tables/devices.py

@@ -38,7 +38,7 @@ __all__ = (
     'InventoryItemRoleTable',
     'InventoryItemTable',
     'MACAddressTable',
-    'MACPrefixTable',
+    'MACBlockTable',
     'ModuleBayTable',
     'PlatformTable',
     'PowerOutletTable',
@@ -1333,7 +1333,7 @@ class MACAddressTable(PrimaryModelTable):
         )
 
 
-class MACPrefixTable(PrimaryModelTable):
+class MACBlockTable(PrimaryModelTable):
     prefix = tables.Column(
         verbose_name=_('Prefix'),
         linkify=True
@@ -1350,7 +1350,7 @@ class MACPrefixTable(PrimaryModelTable):
     )
     mac_address_count = columns.LinkedCountColumn(
         viewname='dcim:macaddress_list',
-        url_params={'mac_prefix_id': 'pk'},
+        url_params={'mac_block_id': 'pk'},
         verbose_name=_('MAC Addresses'),
         orderable=False
     )
@@ -1362,7 +1362,7 @@ class MACPrefixTable(PrimaryModelTable):
         verbose_name=_('Enforce Unique')
     )
     tags = columns.TagColumn(
-        url_name='dcim:macprefix_list'
+        url_name='dcim:macblock_list'
     )
 
     def render_prefix(self, record):
@@ -1373,7 +1373,7 @@ class MACPrefixTable(PrimaryModelTable):
         return str(record.prefix)
 
     class Meta(PrimaryModelTable.Meta):
-        model = models.MACPrefix
+        model = models.MACBlock
         fields = (
             'pk', 'id', 'prefix', 'prefix_length', 'name', 'size', 'mac_address_count', 'utilization',
             'enforce_unique', 'description', 'comments', 'tags', 'created', 'last_updated',

netbox/dcim/tests/query_counts.json

@@ -46,8 +46,8 @@
   "location:list_objects_with_permission": 18,
   "macaddress:api_list_objects": 16,
   "macaddress:list_objects_with_permission": 20,
-  "macprefix:api_list_objects": 12,
-  "macprefix:list_objects_with_permission": 16,
+  "macblock:api_list_objects": 12,
+  "macblock:list_objects_with_permission": 16,
   "manufacturer:api_list_objects": 12,
   "manufacturer:list_objects_with_permission": 16,
   "module:api_list_objects": 19,

netbox/dcim/tests/test_api.py

@@ -7403,8 +7403,9 @@ class MACAddressTestCase(APIViewTestCases.APIViewTestCase):
         self.assertFalse(response.data['is_primary'])
 
 
-class MACPrefixTestCase(APIViewTestCases.APIViewTestCase):
-    model = MACPrefix
+class MACBlockTestCase(APIViewTestCases.APIViewTestCase):
+    model = MACBlock
+    graphql_base_name = 'mac_block'
     brief_fields = ['description', 'display', 'id', 'name', 'prefix', 'prefix_length', 'url']
     bulk_update_data = {
         'description': 'New description',
@@ -7415,15 +7416,15 @@ class MACPrefixTestCase(APIViewTestCases.APIViewTestCase):
 
     @classmethod
     def setUpTestData(cls):
-        MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24, name='Prefix 1')
-        MACPrefix.objects.create(prefix='BC:24:12:00:00:00', prefix_length=24, name='Prefix 2')
-        MACPrefix.objects.create(prefix='BC:24:13:00:00:00', prefix_length=24, name='Prefix 3')
+        MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24, name='Block 1')
+        MACBlock.objects.create(prefix='BC:24:12:00:00:00', prefix_length=24, name='Block 2')
+        MACBlock.objects.create(prefix='BC:24:13:00:00:00', prefix_length=24, name='Block 3')
 
         cls.create_data = [
             {
                 'prefix': 'BC:24:14:00:00:00',
                 'prefix_length': 24,
-                'name': 'Prefix 4',
+                'name': 'Block 4',
             },
             {
                 'prefix': 'BC:24:14:50:00:00',
@@ -7436,14 +7437,14 @@ class MACPrefixTestCase(APIViewTestCases.APIViewTestCase):
         ]
 
     def test_read_only_fields(self):
-        self.add_permissions('dcim.view_macprefix')
-        mac_prefix = MACPrefix.objects.create(prefix='BC:24:16:00:00:00', prefix_length=46)
+        self.add_permissions('dcim.view_macblock')
+        mac_block = MACBlock.objects.create(prefix='BC:24:16:00:00:00', prefix_length=46)
         MACAddress.objects.bulk_create((
             MACAddress(mac_address='BC:24:16:00:00:01'),
             MACAddress(mac_address='BC:24:16:00:00:01'),
             MACAddress(mac_address='BC:24:16:00:00:02'),
         ))
-        response = self.client.get(self._get_detail_url(mac_prefix), **self.header)
+        response = self.client.get(self._get_detail_url(mac_block), **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertEqual(response.data['last_address'], 'BC:24:16:00:00:03')
         self.assertEqual(response.data['size'], 4)
@@ -7451,22 +7452,22 @@ class MACPrefixTestCase(APIViewTestCases.APIViewTestCase):
         self.assertEqual(response.data['utilization'], 50)
 
     def test_create_normalizes_prefix(self):
-        self.add_permissions('dcim.add_macprefix')
+        self.add_permissions('dcim.add_macblock')
         data = {'prefix': 'BC:24:16:AA:BB:CC', 'prefix_length': 24}
         response = self.client.post(self._get_list_url(), data, format='json', **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
         self.assertEqual(response.data['prefix'], 'BC:24:16:00:00:00')
 
-        # A prefix whose host bits differ from an existing prefix is a duplicate
+        # A block whose host bits differ from an existing block is a duplicate
         data = {'prefix': 'BC:24:11:AA:BB:CC', 'prefix_length': 24}
         response = self.client.post(self._get_list_url(), data, format='json', **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
     def test_list_available_mac_addresses(self):
-        mac_prefix = MACPrefix.objects.create(prefix='BC:24:16:00:00:00', prefix_length=45)
+        mac_block = MACBlock.objects.create(prefix='BC:24:16:00:00:00', prefix_length=45)
         MACAddress.objects.create(mac_address='BC:24:16:00:00:01')
-        url = reverse('dcim-api:macprefix-available-mac-addresses', kwargs={'pk': mac_prefix.pk})
-        self.add_permissions('dcim.view_macprefix', 'dcim.view_macaddress')
+        url = reverse('dcim-api:macblock-available-mac-addresses', kwargs={'pk': mac_block.pk})
+        self.add_permissions('dcim.view_macblock', 'dcim.view_macaddress')
 
         response = self.client.get(url, **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
@@ -7485,16 +7486,16 @@ class MACPrefixTestCase(APIViewTestCases.APIViewTestCase):
         self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertEqual(len(response.data), 7)
 
-        # A large prefix returns a single page of results
-        mac_prefix = MACPrefix.objects.get(name='Prefix 1')
-        url = reverse('dcim-api:macprefix-available-mac-addresses', kwargs={'pk': mac_prefix.pk})
+        # A large block returns a single page of results
+        mac_block = MACBlock.objects.get(name='Block 1')
+        url = reverse('dcim-api:macblock-available-mac-addresses', kwargs={'pk': mac_block.pk})
         response = self.client.get(url, **self.header)
         self.assertEqual(len(response.data), get_config().PAGINATE_COUNT)
 
     def test_create_single_available_mac_address(self):
-        mac_prefix = MACPrefix.objects.create(prefix='BC:24:16:00:00:00', prefix_length=47)
-        url = reverse('dcim-api:macprefix-available-mac-addresses', kwargs={'pk': mac_prefix.pk})
-        self.add_permissions('dcim.view_macprefix', 'dcim.add_macaddress')
+        mac_block = MACBlock.objects.create(prefix='BC:24:16:00:00:00', prefix_length=47)
+        url = reverse('dcim-api:macblock-available-mac-addresses', kwargs={'pk': mac_block.pk})
+        self.add_permissions('dcim.view_macblock', 'dcim.add_macaddress')
 
         # Create both available MAC addresses with individual requests
         for i in range(2):
@@ -7510,9 +7511,9 @@ class MACPrefixTestCase(APIViewTestCases.APIViewTestCase):
         self.assertIn('detail', response.data)
 
     def test_create_multiple_available_mac_addresses(self):
-        mac_prefix = MACPrefix.objects.create(prefix='BC:24:16:00:00:00', prefix_length=46)
-        url = reverse('dcim-api:macprefix-available-mac-addresses', kwargs={'pk': mac_prefix.pk})
-        self.add_permissions('dcim.view_macprefix', 'dcim.add_macaddress')
+        mac_block = MACBlock.objects.create(prefix='BC:24:16:00:00:00', prefix_length=46)
+        url = reverse('dcim-api:macblock-available-mac-addresses', kwargs={'pk': mac_block.pk})
+        self.add_permissions('dcim.view_macblock', 'dcim.add_macaddress')
 
         # Try to create five MAC addresses (only four are available)
         data = [{'description': f'MAC address {i}'} for i in range(5)]

netbox/dcim/tests/test_filtersets.py

@@ -9171,37 +9171,37 @@ class MACAddressTestCase(TestCase, ChangeLoggedFilterSetTestMixin):
         params = {'primary': False}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
-    def test_mac_prefix(self):
-        mac_prefixes = (
-            MACPrefix.objects.create(prefix='00:00:00:01:00:00', prefix_length=32),
-            MACPrefix.objects.create(prefix='00:00:00:03:00:00', prefix_length=32),
+    def test_mac_block(self):
+        mac_blocks = (
+            MACBlock.objects.create(prefix='00:00:00:01:00:00', prefix_length=32),
+            MACBlock.objects.create(prefix='00:00:00:03:00:00', prefix_length=32),
         )
-        params = {'mac_prefix_id': [mac_prefixes[0].pk]}
+        params = {'mac_block_id': [mac_blocks[0].pk]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-        params = {'mac_prefix_id': [mac_prefixes[0].pk, mac_prefixes[1].pk]}
+        params = {'mac_block_id': [mac_blocks[0].pk, mac_blocks[1].pk]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
 
-class MACPrefixTestCase(TestCase, ChangeLoggedFilterSetTestMixin):
-    queryset = MACPrefix.objects.all()
-    filterset = MACPrefixFilterSet
+class MACBlockTestCase(TestCase, ChangeLoggedFilterSetTestMixin):
+    queryset = MACBlock.objects.all()
+    filterset = MACBlockFilterSet
     ignore_fields = ('_last_address',)
 
     @classmethod
     def setUpTestData(cls):
-        MACPrefix.objects.create(
-            prefix='BC:24:11:00:00:00', prefix_length=24, name='Prefix 1', enforce_unique=True,
+        MACBlock.objects.create(
+            prefix='BC:24:11:00:00:00', prefix_length=24, name='Block 1', enforce_unique=True,
             description='foobar1'
         )
-        MACPrefix.objects.create(
-            prefix='BC:24:11:50:00:00', prefix_length=28, name='Prefix 2', description='foobar2'
+        MACBlock.objects.create(
+            prefix='BC:24:11:50:00:00', prefix_length=28, name='Block 2', description='foobar2'
         )
-        MACPrefix.objects.create(
-            prefix='BC:24:12:00:00:00', prefix_length=36, name='Prefix 3', description='foobar3'
+        MACBlock.objects.create(
+            prefix='BC:24:12:00:00:00', prefix_length=36, name='Block 3', description='foobar3'
         )
 
     def test_q(self):
-        params = {'q': 'Prefix 1'}
+        params = {'q': 'Block 1'}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
         params = {'q': 'BC:24:11'}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
@@ -9215,7 +9215,7 @@ class MACPrefixTestCase(TestCase, ChangeLoggedFilterSetTestMixin):
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_name(self):
-        params = {'name': ['Prefix 1', 'Prefix 2']}
+        params = {'name': ['Block 1', 'Block 2']}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_enforce_unique(self):

netbox/dcim/tests/test_models.py

@@ -130,48 +130,48 @@ class MACAddressTestCase(TestCase):
         new_iface.full_clean()  # must not raise
 
 
-class MACPrefixTestCase(TestCase):
+class MACBlockTestCase(TestCase):
 
     def test_prefix_normalized(self):
-        mac_prefix = MACPrefix.objects.create(prefix='BC:24:11:12:34:56', prefix_length=24)
-        mac_prefix.refresh_from_db()
-        self.assertEqual(str(mac_prefix.prefix), 'BC:24:11:00:00:00')
-        self.assertEqual(str(mac_prefix.last_address), 'BC:24:11:FF:FF:FF')
-        self.assertEqual(str(mac_prefix._last_address), 'BC:24:11:FF:FF:FF')
-        self.assertEqual(str(mac_prefix), 'BC:24:11:00:00:00/24')
+        mac_block = MACBlock.objects.create(prefix='BC:24:11:12:34:56', prefix_length=24)
+        mac_block.refresh_from_db()
+        self.assertEqual(str(mac_block.prefix), 'BC:24:11:00:00:00')
+        self.assertEqual(str(mac_block.last_address), 'BC:24:11:FF:FF:FF')
+        self.assertEqual(str(mac_block._last_address), 'BC:24:11:FF:FF:FF')
+        self.assertEqual(str(mac_block), 'BC:24:11:00:00:00/24')
 
     def test_invalid_prefix(self):
         for prefix, prefix_length in (('invalid', 24), ('BC:24:11:00:00:00', 49), ('BC:24:11:00:00:00', 'x')):
-            mac_prefix = MACPrefix(prefix=prefix, prefix_length=prefix_length, enforce_unique=True)
-            self.assertIsNone(mac_prefix.first_address)
+            mac_block = MACBlock(prefix=prefix, prefix_length=prefix_length, enforce_unique=True)
+            self.assertIsNone(mac_block.first_address)
             with self.assertRaises(ValidationError):
-                mac_prefix.full_clean()
+                mac_block.full_clean()
 
     def test_duplicate_prefix_with_host_bits(self):
-        MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24)
-        mac_prefix = MACPrefix(prefix='BC:24:11:AA:BB:CC', prefix_length=24)
+        MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24)
+        mac_block = MACBlock(prefix='BC:24:11:AA:BB:CC', prefix_length=24)
         with self.assertRaises(ValidationError):
-            mac_prefix.full_clean()
+            mac_block.full_clean()
 
     def test_save_invalid_prefix(self):
-        with self.assertRaisesMessage(ValueError, 'Invalid MAC prefix'):
-            MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=0)
+        with self.assertRaisesMessage(ValueError, 'Invalid MAC address block'):
+            MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=0)
 
     def test_size(self):
-        self.assertEqual(MACPrefix(prefix='BC:24:11:00:00:00', prefix_length=24).size, 2 ** 24)
-        self.assertEqual(MACPrefix(prefix='BC:24:11:50:00:00', prefix_length=28).size, 2 ** 20)
-        self.assertEqual(MACPrefix(prefix='BC:24:11:00:00:01', prefix_length=48).size, 1)
+        self.assertEqual(MACBlock(prefix='BC:24:11:00:00:00', prefix_length=24).size, 2 ** 24)
+        self.assertEqual(MACBlock(prefix='BC:24:11:50:00:00', prefix_length=28).size, 2 ** 20)
+        self.assertEqual(MACBlock(prefix='BC:24:11:00:00:01', prefix_length=48).size, 1)
 
     def test_duplicate_prefix(self):
-        MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24)
-        mac_prefix = MACPrefix(prefix='BC:24:11:00:00:00', prefix_length=24)
+        MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24)
+        mac_block = MACBlock(prefix='BC:24:11:00:00:00', prefix_length=24)
         with self.assertRaises(ValidationError):
-            mac_prefix.full_clean()
-        # A prefix of a different length may share the same first address
-        MACPrefix(prefix='BC:24:11:00:00:00', prefix_length=28).full_clean()
+            mac_block.full_clean()
+        # A block of a different length may share the same first address
+        MACBlock(prefix='BC:24:11:00:00:00', prefix_length=28).full_clean()
 
     def test_get_mac_addresses(self):
-        mac_prefix = MACPrefix.objects.create(prefix='BC:24:11:50:00:00', prefix_length=28)
+        mac_block = MACBlock.objects.create(prefix='BC:24:11:50:00:00', prefix_length=28)
         MACAddress.objects.bulk_create((
             MACAddress(mac_address='BC:24:11:4F:FF:FF'),
             MACAddress(mac_address='BC:24:11:50:00:00'),
@@ -179,32 +179,32 @@ class MACPrefixTestCase(TestCase):
             MACAddress(mac_address='BC:24:11:60:00:00'),
         ))
         self.assertEqual(
-            sorted(str(mac.mac_address) for mac in mac_prefix.get_mac_addresses()),
+            sorted(str(mac.mac_address) for mac in mac_block.get_mac_addresses()),
             ['BC:24:11:50:00:00', 'BC:24:11:5F:FF:FF']
         )
 
-    def test_get_child_prefixes(self):
-        mac_prefixes = (
-            MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24),
-            MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=28),
-            MACPrefix.objects.create(prefix='BC:24:11:F0:00:00', prefix_length=28),
-            MACPrefix.objects.create(prefix='BC:24:12:00:00:00', prefix_length=28),
+    def test_get_child_blocks(self):
+        mac_blocks = (
+            MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24),
+            MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=28),
+            MACBlock.objects.create(prefix='BC:24:11:F0:00:00', prefix_length=28),
+            MACBlock.objects.create(prefix='BC:24:12:00:00:00', prefix_length=28),
         )
-        self.assertEqual(list(mac_prefixes[0].get_child_prefixes()), [mac_prefixes[1], mac_prefixes[2]])
-        self.assertEqual(list(mac_prefixes[1].get_child_prefixes()), [])
+        self.assertEqual(list(mac_blocks[0].get_child_blocks()), [mac_blocks[1], mac_blocks[2]])
+        self.assertEqual(list(mac_blocks[1].get_child_blocks()), [])
 
-    def test_mac_address_mac_prefix(self):
-        mac_prefixes = (
-            MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24),
-            MACPrefix.objects.create(prefix='BC:24:11:50:00:00', prefix_length=28),
+    def test_mac_address_mac_block(self):
+        mac_blocks = (
+            MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24),
+            MACBlock.objects.create(prefix='BC:24:11:50:00:00', prefix_length=28),
         )
-        self.assertEqual(MACAddress(mac_address='BC:24:11:51:00:00').mac_prefix, mac_prefixes[1])
-        self.assertEqual(MACAddress(mac_address='BC:24:11:61:00:00').mac_prefix, mac_prefixes[0])
-        self.assertIsNone(MACAddress(mac_address='BC:24:12:00:00:00').mac_prefix)
+        self.assertEqual(MACAddress(mac_address='BC:24:11:51:00:00').mac_block, mac_blocks[1])
+        self.assertEqual(MACAddress(mac_address='BC:24:11:61:00:00').mac_block, mac_blocks[0])
+        self.assertIsNone(MACAddress(mac_address='BC:24:12:00:00:00').mac_block)
 
     def test_available_mac_addresses(self):
-        mac_prefix = MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=45)
-        self.assertEqual(str(mac_prefix.get_first_available_mac_address()), 'BC:24:11:00:00:00')
+        mac_block = MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=45)
+        self.assertEqual(str(mac_block.get_first_available_mac_address()), 'BC:24:11:00:00:00')
 
         MACAddress.objects.bulk_create((
             MACAddress(mac_address='BC:24:11:00:00:00'),
@@ -212,52 +212,52 @@ class MACPrefixTestCase(TestCase):
             MACAddress(mac_address='BC:24:11:00:00:01'),  # Duplicate
             MACAddress(mac_address='BC:24:11:00:00:03'),
             MACAddress(mac_address='BC:24:11:00:00:07'),
-            MACAddress(mac_address='BC:24:11:00:00:08'),  # Outside the prefix
+            MACAddress(mac_address='BC:24:11:00:00:08'),  # Outside the block
         ))
-        self.assertEqual(str(mac_prefix.get_first_available_mac_address()), 'BC:24:11:00:00:02')
+        self.assertEqual(str(mac_block.get_first_available_mac_address()), 'BC:24:11:00:00:02')
         self.assertEqual(
-            [str(mac) for mac in mac_prefix.iter_available_mac_addresses()],
+            [str(mac) for mac in mac_block.iter_available_mac_addresses()],
             ['BC:24:11:00:00:02', 'BC:24:11:00:00:04', 'BC:24:11:00:00:05', 'BC:24:11:00:00:06']
         )
 
         # Fetching occupied addresses in batches finds the same gaps
         self.assertEqual(
-            list(mac_prefix._iter_occupied(batch_size=2)),
+            list(mac_block._iter_occupied(batch_size=2)),
             [int(EUI(mac)) for mac in ('BC:24:11:00:00:00', 'BC:24:11:00:00:01', 'BC:24:11:00:00:03',
                                        'BC:24:11:00:00:07')]
         )
 
     def test_no_available_mac_addresses(self):
-        mac_prefix = MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=47)
+        mac_block = MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=47)
         MACAddress.objects.bulk_create((
             MACAddress(mac_address='BC:24:11:00:00:00'),
             MACAddress(mac_address='BC:24:11:00:00:01'),
         ))
-        self.assertIsNone(mac_prefix.get_first_available_mac_address())
-        self.assertEqual(mac_prefix.utilization, 100)
+        self.assertIsNone(mac_block.get_first_available_mac_address())
+        self.assertEqual(mac_block.utilization, 100)
 
     def test_utilization(self):
-        mac_prefix = MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=46)
+        mac_block = MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=46)
         MACAddress.objects.bulk_create((
             MACAddress(mac_address='BC:24:11:00:00:00'),
             MACAddress(mac_address='BC:24:11:00:00:00'),  # Duplicate
             MACAddress(mac_address='BC:24:11:00:00:02'),
         ))
-        self.assertEqual(mac_prefix.utilization, 50)
-        annotated = MACPrefix.objects.annotate_mac_address_count().get(pk=mac_prefix.pk)
+        self.assertEqual(mac_block.utilization, 50)
+        annotated = MACBlock.objects.annotate_mac_address_count().get(pk=mac_block.pk)
         self.assertEqual(annotated.mac_address_count, 2)
         self.assertEqual(annotated.utilization, 50)
 
     def test_enforce_unique(self):
-        MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24, enforce_unique=True)
+        MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24, enforce_unique=True)
         MACAddress.objects.create(mac_address='BC:24:11:00:00:01')
         MACAddress.objects.create(mac_address='BC:24:12:00:00:01')
 
-        # A duplicate within the prefix is rejected
+        # A duplicate within the block is rejected
         with self.assertRaisesMessage(ValidationError, 'BC:24:11:00:00:00/24'):
             MACAddress(mac_address='BC:24:11:00:00:01').full_clean()
 
-        # A duplicate outside the prefix is permitted
+        # A duplicate Outside the block is permitted
         MACAddress(mac_address='BC:24:12:00:00:01').full_clean()
 
         # Saving an existing MAC address does not count it as its own duplicate
@@ -268,13 +268,13 @@ class MACPrefixTestCase(TestCase):
             MACAddress(mac_address='BC:24:11:00:00:01'),
             MACAddress(mac_address='BC:24:11:00:00:01'),
         ))
-        mac_prefix = MACPrefix(prefix='BC:24:11:00:00:00', prefix_length=24, enforce_unique=True)
+        mac_block = MACBlock(prefix='BC:24:11:00:00:00', prefix_length=24, enforce_unique=True)
         with self.assertRaisesMessage(ValidationError, 'BC:24:11:00:00:01'):
-            mac_prefix.full_clean()
+            mac_block.full_clean()
 
         # Uniqueness is not enforced by default
-        mac_prefix.enforce_unique = False
-        mac_prefix.full_clean()
+        mac_block.enforce_unique = False
+        mac_block.full_clean()
 
 
 class LocationTestCase(TestCase):

netbox/dcim/tests/test_tables.py

@@ -336,5 +336,5 @@ class MACAddressTableTestCase(TableTestCases.StandardTableTestCase):
     table = MACAddressTable
 
 
-class MACPrefixTableTestCase(TableTestCases.StandardTableTestCase):
-    table = MACPrefixTable
+class MACBlockTableTestCase(TableTestCases.StandardTableTestCase):
+    table = MACBlockTable

netbox/dcim/tests/test_views.py

@@ -6972,11 +6972,11 @@ class MACAddressTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         self.assertIn(b'quick-add-object', response.content)
         self.assertEqual(initial_count + 1, self._get_queryset().count())
 
-    def test_mac_prefixes_panel(self):
+    def test_mac_blocks_panel(self):
         """
-        The MAC address page lists the MAC prefixes containing it, only if the user can view MAC prefixes.
+        The MAC address page lists the MAC blocks containing it, only if the user can view MAC blocks.
         """
-        MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24, name='Prefix 1')
+        MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24, name='Block 1')
         mac_address = MACAddress.objects.create(mac_address='BC:24:11:00:00:01')
         panel_url = 'contains=BC%3A24%3A11%3A00%3A00%3A01'
 
@@ -6985,21 +6985,21 @@ class MACAddressTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         self.assertHttpStatus(response, 200)
         self.assertNotContains(response, panel_url)
 
-        self.add_permissions('dcim.view_macprefix')
+        self.add_permissions('dcim.view_macblock')
         response = self.client.get(mac_address.get_absolute_url())
         self.assertHttpStatus(response, 200)
         self.assertContains(response, panel_url)
 
 
-class MACPrefixTestCase(ViewTestCases.PrimaryObjectViewTestCase):
-    model = MACPrefix
+class MACBlockTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    model = MACBlock
 
     @classmethod
     def setUpTestData(cls):
-        mac_prefixes = (
-            MACPrefix.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24, name='Prefix 1'),
-            MACPrefix.objects.create(prefix='BC:24:12:00:00:00', prefix_length=24, name='Prefix 2'),
-            MACPrefix.objects.create(prefix='BC:24:13:00:00:00', prefix_length=24, name='Prefix 3'),
+        mac_blocks = (
+            MACBlock.objects.create(prefix='BC:24:11:00:00:00', prefix_length=24, name='Block 1'),
+            MACBlock.objects.create(prefix='BC:24:12:00:00:00', prefix_length=24, name='Block 2'),
+            MACBlock.objects.create(prefix='BC:24:13:00:00:00', prefix_length=24, name='Block 3'),
         )
 
         tags = create_tags('Alpha', 'Bravo', 'Charlie')
@@ -7007,24 +7007,24 @@ class MACPrefixTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         cls.form_data = {
             'prefix': EUI('BC:24:14:50:00:00'),
             'prefix_length': 28,
-            'name': 'Prefix X',
+            'name': 'Block X',
             'enforce_unique': True,
-            'description': 'New MAC prefix',
+            'description': 'New MAC block',
             'tags': [t.pk for t in tags],
         }
 
         cls.csv_data = (
             "prefix,prefix_length,name",
-            "BC:24:15:00:00:00,24,Prefix 4",
-            "BC:24:16:00:00:00,28,Prefix 5",
-            "BC:24:17:00:00:00,36,Prefix 6",
+            "BC:24:15:00:00:00,24,Block 4",
+            "BC:24:16:00:00:00,28,Block 5",
+            "BC:24:17:00:00:00,36,Block 6",
         )
 
         cls.csv_update_data = (
             "id,name,enforce_unique",
-            f"{mac_prefixes[0].pk},Prefix 7,true",
-            f"{mac_prefixes[1].pk},Prefix 8,true",
-            f"{mac_prefixes[2].pk},Prefix 9,false",
+            f"{mac_blocks[0].pk},Block 7,true",
+            f"{mac_blocks[1].pk},Block 8,true",
+            f"{mac_blocks[2].pk},Block 9,false",
         )
 
         cls.bulk_edit_data = {
@@ -7034,21 +7034,21 @@ class MACPrefixTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         }
 
     def test_create_duplicate_prefix_with_host_bits(self):
-        self.add_permissions('dcim.add_macprefix')
+        self.add_permissions('dcim.add_macblock')
         response = self.client.post(
-            reverse('dcim:macprefix_add'), {'prefix': 'BC:24:11:AA:BB:CC', 'prefix_length': 24}
+            reverse('dcim:macblock_add'), {'prefix': 'BC:24:11:AA:BB:CC', 'prefix_length': 24}
         )
         self.assertHttpStatus(response, 200)
-        self.assertEqual(MACPrefix.objects.filter(prefix='BC:24:11:00:00:00', prefix_length=24).count(), 1)
+        self.assertEqual(MACBlock.objects.filter(prefix='BC:24:11:00:00:00', prefix_length=24).count(), 1)
 
     def test_mac_addresses_panel(self):
         """
-        The MAC prefix page offers to add the first available MAC address within the prefix.
+        The MAC block page offers to add the first available MAC address within the block.
         """
-        self.add_permissions('dcim.view_macprefix', 'dcim.view_macaddress', 'dcim.add_macaddress')
-        mac_prefix = MACPrefix.objects.get(name='Prefix 1')
+        self.add_permissions('dcim.view_macblock', 'dcim.view_macaddress', 'dcim.add_macaddress')
+        mac_block = MACBlock.objects.get(name='Block 1')
         MACAddress.objects.create(mac_address='BC:24:11:00:00:00')
 
-        response = self.client.get(mac_prefix.get_absolute_url())
+        response = self.client.get(mac_block.get_absolute_url())
         self.assertHttpStatus(response, 200)
         self.assertContains(response, 'mac_address=BC%3A24%3A11%3A00%3A00%3A01')

netbox/dcim/ui/panels.py

@@ -478,7 +478,7 @@ class MACAddressPanel(panels.ObjectAttributesPanel):
     is_primary = attrs.BooleanAttr('is_primary', label=_('Primary for interface'))
 
 
-class MACPrefixPanel(panels.ObjectAttributesPanel):
+class MACBlockPanel(panels.ObjectAttributesPanel):
     prefix = attrs.TextAttr('prefix', label=_('Prefix'), style='font-monospace', copy_button=True)
     prefix_length = attrs.NumericAttr('prefix_length', label=_('Prefix length'))
     name = attrs.TextAttr('name')

netbox/dcim/urls.py

@@ -208,7 +208,7 @@ urlpatterns = [
 
     path('mac-addresses/', include(get_model_urls('dcim', 'macaddress', detail=False))),
     path('mac-addresses/<int:pk>/', include(get_model_urls('dcim', 'macaddress'))),
-    path('mac-prefixes/', include(get_model_urls('dcim', 'macprefix', detail=False))),
-    path('mac-prefixes/<int:pk>/', include(get_model_urls('dcim', 'macprefix'))),
+    path('mac-blocks/', include(get_model_urls('dcim', 'macblock', detail=False))),
+    path('mac-blocks/<int:pk>/', include(get_model_urls('dcim', 'macblock'))),
 
 ]

netbox/dcim/views.py

@@ -5871,8 +5871,8 @@ class MACAddressView(generic.ObjectView):
         right_panels=[
             CommentsPanel(),
             ObjectsTablePanel(
-                model='dcim.MACPrefix',
-                title=_('MAC Prefixes'),
+                model='dcim.MACBlock',
+                title=_('MAC Address Blocks'),
                 filters={'contains': lambda ctx: str(ctx['object'].mac_address)},
             ),
         ],
@@ -5955,25 +5955,25 @@ class MACAddressBulkDeleteView(generic.BulkDeleteView):
 
 
 #
-# MAC prefixes
+# MAC address blocks
 #
 
-@register_model_view(MACPrefix, 'list', path='', detail=False)
-class MACPrefixListView(generic.ObjectListView):
-    queryset = MACPrefix.objects.annotate_mac_address_count()
-    filterset = filtersets.MACPrefixFilterSet
-    filterset_form = forms.MACPrefixFilterForm
-    table = tables.MACPrefixTable
+@register_model_view(MACBlock, 'list', path='', detail=False)
+class MACBlockListView(generic.ObjectListView):
+    queryset = MACBlock.objects.annotate_mac_address_count()
+    filterset = filtersets.MACBlockFilterSet
+    filterset_form = forms.MACBlockFilterForm
+    table = tables.MACBlockTable
     actions = (AddObject, BulkImport, BulkExport, BulkEdit, BulkDelete)
 
 
-@register_model_view(MACPrefix)
-class MACPrefixView(generic.ObjectView):
-    queryset = MACPrefix.objects.all()
+@register_model_view(MACBlock)
+class MACBlockView(generic.ObjectView):
+    queryset = MACBlock.objects.all()
     template_name = 'generic/object.html'
     layout = layout.SimpleLayout(
         left_panels=[
-            panels.MACPrefixPanel(),
+            panels.MACBlockPanel(),
             TagsPanel(),
             CustomFieldsPanel(),
         ],
@@ -5984,7 +5984,7 @@ class MACPrefixView(generic.ObjectView):
             ObjectsTablePanel(
                 model='dcim.MACAddress',
                 title=_('MAC Addresses'),
-                filters={'mac_prefix_id': lambda ctx: ctx['object'].pk},
+                filters={'mac_block_id': lambda ctx: ctx['object'].pk},
                 actions=[
                     actions.AddObject(
                         'dcim.MACAddress',
@@ -5997,34 +5997,34 @@ class MACPrefixView(generic.ObjectView):
     )
 
 
-@register_model_view(MACPrefix, 'add', detail=False)
-@register_model_view(MACPrefix, 'edit')
-class MACPrefixEditView(generic.ObjectEditView):
-    queryset = MACPrefix.objects.all()
-    form = forms.MACPrefixForm
+@register_model_view(MACBlock, 'add', detail=False)
+@register_model_view(MACBlock, 'edit')
+class MACBlockEditView(generic.ObjectEditView):
+    queryset = MACBlock.objects.all()
+    form = forms.MACBlockForm
 
 
-@register_model_view(MACPrefix, 'delete')
-class MACPrefixDeleteView(generic.ObjectDeleteView):
-    queryset = MACPrefix.objects.all()
+@register_model_view(MACBlock, 'delete')
+class MACBlockDeleteView(generic.ObjectDeleteView):
+    queryset = MACBlock.objects.all()
 
 
-@register_model_view(MACPrefix, 'bulk_import', path='import', detail=False)
-class MACPrefixBulkImportView(generic.BulkImportView):
-    queryset = MACPrefix.objects.all()
-    model_form = forms.MACPrefixImportForm
+@register_model_view(MACBlock, 'bulk_import', path='import', detail=False)
+class MACBlockBulkImportView(generic.BulkImportView):
+    queryset = MACBlock.objects.all()
+    model_form = forms.MACBlockImportForm
 
 
-@register_model_view(MACPrefix, 'bulk_edit', path='edit', detail=False)
-class MACPrefixBulkEditView(generic.BulkEditView):
-    queryset = MACPrefix.objects.annotate_mac_address_count()
-    filterset = filtersets.MACPrefixFilterSet
-    table = tables.MACPrefixTable
-    form = forms.MACPrefixBulkEditForm
+@register_model_view(MACBlock, 'bulk_edit', path='edit', detail=False)
+class MACBlockBulkEditView(generic.BulkEditView):
+    queryset = MACBlock.objects.annotate_mac_address_count()
+    filterset = filtersets.MACBlockFilterSet
+    table = tables.MACBlockTable
+    form = forms.MACBlockBulkEditForm
 
 
-@register_model_view(MACPrefix, 'bulk_delete', path='delete', detail=False)
-class MACPrefixBulkDeleteView(generic.BulkDeleteView):
-    queryset = MACPrefix.objects.annotate_mac_address_count()
-    filterset = filtersets.MACPrefixFilterSet
-    table = tables.MACPrefixTable
+@register_model_view(MACBlock, 'bulk_delete', path='delete', detail=False)
+class MACBlockBulkDeleteView(generic.BulkDeleteView):
+    queryset = MACBlock.objects.annotate_mac_address_count()
+    filterset = filtersets.MACBlockFilterSet
+    table = tables.MACBlockTable

netbox/netbox/navigation/menu.py

@@ -121,7 +121,7 @@ DEVICES_MENU = Menu(
             label=_('Addressing'),
             items=(
                 get_model_item('dcim', 'macaddress', _('MAC Addresses')),
-                get_model_item('dcim', 'macprefix', _('MAC Prefixes')),
+                get_model_item('dcim', 'macblock', _('MAC Address Blocks')),
             ),
         ),
     ),