netbox-data-import 2.2.0__tar.gz → 2.4.0__tar.gz

{netbox_data_import-2.2.0 → netbox_data_import-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netbox-data-import
-Version: 2.2.0
+Version: 2.4.0
 Summary: NetBox plugin for importing data from external DCIM systems
 Author: Marcin Zieba
 License-Expression: Apache-2.0

{netbox_data_import-2.2.0 → netbox_data_import-2.4.0}/netbox_data_import/__init__.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from netbox.plugins import PluginConfig
 
-__version__ = "2.2.0"
+__version__ = "2.4.0"
 
 
 class NetBoxDataImportConfig(PluginConfig):

{netbox_data_import-2.2.0 → netbox_data_import-2.4.0}/netbox_data_import/adapters.py

@@ -13,13 +13,14 @@ the NetBox boundary.
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING
 
 from .catalog import OutputKind, has_implemented_module
+from .values import identity_text
 
 if TYPE_CHECKING:
-    from .trace_workbook import SourceTrace
+    from .source_trace import SourceTrace
 
 
 class UnknownSourceAdapter(Exception):
@@ -39,6 +40,16 @@ class SourceDiagnostic:
     row_number: int | None = None
 
 
+def _foreign_row_number(row) -> int | None:
+    """Return the source row a foreign row states, so its diagnostic can name a location."""
+    provenance = getattr(row, "provenance", ())
+    if provenance:
+        return provenance[0].row_start
+    if isinstance(row, dict):
+        return row.get("_row_number")
+    return None
+
+
 @dataclass(frozen=True)
 class SourceBatch:
     """The typed source items and source diagnostics from one file (section 1)."""
@@ -48,6 +59,46 @@ class SourceBatch:
     diagnostics: tuple[SourceDiagnostic, ...] = ()
     unused_columns: dict[str, dict] = field(default_factory=dict)
 
+    def __post_init__(self):
+        """Exclude a row the output kinds cannot carry, and mark a Trace with empty Device references."""
+        from .source_trace import SourceTrace
+
+        trace_batch = OutputKind.SOURCE_TRACE in self.output_kinds
+        expected = SourceTrace if trace_batch else dict
+        carries = "Source Traces" if trace_batch else "source rows"
+        rows = []
+        diagnostics = list(self.diagnostics)
+        for row in self.rows:
+            if not isinstance(row, expected):
+                # Excluded here, because every reader below reads the row the output kinds declare.
+                diagnostics.append(
+                    SourceDiagnostic(
+                        code="source.row_type_unexpected",
+                        message=f"This batch carries {carries} only; got {type(row).__name__}.",
+                        row_number=_foreign_row_number(row),
+                    )
+                )
+                continue
+            if not trace_batch:
+                rows.append(row)
+                continue
+            summary = row.endpoint_summary
+            references = [summary.from_termination, summary.to_termination, *row.corroboration]
+            for segment in row.segments:
+                references.extend((segment.left, segment.right))
+            if all(identity_text(reference.device) for reference in references):
+                rows.append(row)
+                continue
+            diagnostic = SourceDiagnostic(
+                code="trace.device_required",
+                message="A Source Trace Termination Reference must name a Device.",
+                row_number=row.provenance[0].row_start,
+            )
+            diagnostics.append(diagnostic)
+            rows.append(replace(row, errors=(*row.errors, diagnostic)))
+        object.__setattr__(self, "rows", tuple(rows))
+        object.__setattr__(self, "diagnostics", tuple(diagnostics))
+
 
 class SourceAdapter:
     """Base class for a Source Adapter declaration."""

{netbox_data_import-2.2.0 → netbox_data_import-2.4.0}/netbox_data_import/api/serializers.py

@@ -10,8 +10,11 @@ from rest_framework import serializers
 
 from ..adapters import DEFAULT_ADAPTER_KEY, get_adapter, selectable_adapter_choices
 from ..catalog import CATALOG
+from ..forms import InferenceBackendForm
 from ..models import (
     ImportProfile,
+    CableClassMapping,
+    CableImportSource,
     ColumnMapping,
     ClassRoleMapping,
     DeviceTypeMapping,
@@ -63,6 +66,17 @@ class PolicySectionSerializer(PolicySectionApplicabilityMixin, ValidatedModelSer
     def validate_policy_row(self, attrs):
         """Check the fields this model resolves through the catalog. Subclasses override."""
 
+    def model_cleaned_values(self):
+        """Return request values after applying the model's canonical normalization."""
+        values = dict(self.validated_data)
+        if self.instance is None:
+            instance = self.Meta.model(**values)
+            instance.full_clean(validate_unique=False)
+        else:
+            # ValidatedModelSerializer.validate() applies request values and full_clean() to this instance.
+            instance = self.instance
+        return {name: getattr(instance, name) for name in values}
+
 
 def _validate_target_keys(instance, attrs, names, *, allow_candidates=True, required=False):
     """Reject a target key the profile's Source Adapter cannot supply."""
@@ -145,6 +159,24 @@ class ColumnMappingSerializer(PolicySectionSerializer):
         _validate_target_keys(self.instance, attrs, ("target_field",), required=True)
 
 
+class CableClassMappingSerializer(PolicySectionSerializer):
+    """Serializer for CableClassMapping policy decisions."""
+
+    class Meta:
+        model = CableClassMapping
+        fields = [
+            "id",
+            "url",
+            "display",
+            "profile",
+            "cable_class",
+            "cable_type_resolved",
+            "cable_type",
+            "cable_profile_resolved",
+            "cable_profile",
+        ]
+
+
 class _RackTypeSlugField(serializers.SlugRelatedField):
     """SlugRelatedField for RackType that defers the queryset import."""
 
@@ -282,6 +314,30 @@ class ImportExecutionSerializer(serializers.ModelSerializer):
         read_only_fields = fields
 
 
+class CableImportSourceSerializer(serializers.ModelSerializer):
+    """Read-only serializer for one Cable provenance record."""
+
+    class Meta:
+        model = CableImportSource
+        fields = [
+            "id",
+            "cable",
+            "profile",
+            "trace_identity",
+            "segment_index",
+            "from_text",
+            "to_text",
+            "direction",
+            "workbook_fingerprint",
+            "sheet",
+            "block_ordinal",
+            "row_start",
+            "row_end",
+            "export_timestamp",
+        ]
+        read_only_fields = fields
+
+
 class ResolutionProposalSerializer(serializers.ModelSerializer):
     """Read-only serializer for the Resolution Proposal audit record."""
 
@@ -328,28 +384,20 @@ class ResolutionProposalHistorySerializer(serializers.ModelSerializer):
 
 
 class InferenceBackendSerializer(NetBoxModelSerializer):
-    """Serialize one Inference Backend row, without its credential reference.
+    """Serialize one Inference Backend row with a write-only credential reference.
 
     NetBox resolves this class by model name to freeze a delete event payload.
     """
 
+    credential_reference = serializers.JSONField(write_only=True)
+
     class Meta:
         model = InferenceBackend
         fields = [
             "id",
             "url",
             "display",
-            "backend_key",
-            "display_name",
-            "adapter_type",
-            "api_root",
-            "model",
-            "authentication",
-            "response_mode",
-            "connect_timeout",
-            "read_timeout",
-            "enabled",
-            "tags",
+            *InferenceBackendForm.Meta.fields,
             "custom_fields",
             "created",
             "last_updated",

{netbox_data_import-2.2.0 → netbox_data_import-2.4.0}/netbox_data_import/api/urls.py

@@ -7,6 +7,8 @@ from netbox.api.routers import NetBoxRouter
 
 from .views import (
     ImportProfileViewSet,
+    CableClassMappingViewSet,
+    CableImportSourceViewSet,
     ColumnMappingViewSet,
     ClassRoleMappingViewSet,
     DeviceTypeMappingViewSet,
@@ -21,6 +23,8 @@ from .views import (
 
 router = NetBoxRouter()
 router.register("profiles", ImportProfileViewSet)
+router.register("cable-class-mappings", CableClassMappingViewSet)
+router.register("cable-provenance", CableImportSourceViewSet)
 router.register("column-mappings", ColumnMappingViewSet)
 router.register("class-role-mappings", ClassRoleMappingViewSet)
 router.register("device-type-mappings", DeviceTypeMappingViewSet)

{netbox_data_import-2.2.0 → netbox_data_import-2.4.0}/netbox_data_import/api/views.py

@@ -3,16 +3,17 @@
 """DRF viewsets for the data-import plugin API."""
 
 from django.http import Http404
-from netbox.api.viewsets import NetBoxModelViewSet, NetBoxReadOnlyModelViewSet
+from netbox.api.viewsets import NetBoxModelViewSet
 from rest_framework import mixins, permissions, viewsets
-from rest_framework.exceptions import ValidationError
+from rest_framework.exceptions import PermissionDenied, ValidationError
 from rest_framework.permissions import DjangoModelPermissions
 
 from ..field_keys import SELECT_TERMINATION_TASK, parse_termination_field_key
 from ..models import (
     locked_profile_policy,
-    locked_resolution_policy,
     ImportProfile,
+    CableClassMapping,
+    CableImportSource,
     ColumnMapping,
     ClassRoleMapping,
     DeviceTypeMapping,
@@ -23,8 +24,15 @@ from ..models import (
     InferenceBackend,
     ResolutionProposal,
 )
+from ..object_permissions import (
+    ObjectPermissionDenied,
+    delete_permission_scoped_objects,
+    save_permission_scoped_object,
+)
 from .serializers import (
     ImportProfileSerializer,
+    CableClassMappingSerializer,
+    CableImportSourceSerializer,
     ColumnMappingSerializer,
     ClassRoleMappingSerializer,
     DeviceTypeMappingSerializer,
@@ -84,6 +92,72 @@ class _PluginModelViewSet(_ProfileScopedQuerySetMixin, viewsets.ModelViewSet):
 
     permission_classes = [permissions.IsAuthenticated, DjangoModelPermissionsWithView]
 
+    def perform_create(self, serializer):
+        """Create one policy row inside its profile and object-permission scope."""
+        model = serializer.Meta.model
+        profile_id = serializer.validated_data["profile"].pk
+        try:
+            with locked_profile_policy(profile_id):
+                serializer.run_validation(serializer.initial_data)
+                values = serializer.model_cleaned_values()
+                profile = values.pop("profile")
+                result = save_permission_scoped_object(
+                    self.request.user,
+                    model,
+                    {"pk": None, "profile": profile},
+                    values,
+                    on_existing="reject",
+                )
+        except ImportProfile.DoesNotExist:
+            raise Http404 from None
+        except ObjectPermissionDenied as exc:
+            raise PermissionDenied from exc
+        serializer.instance = result.instance
+
+    def perform_update(self, serializer):
+        """Update one policy row under every affected profile and object scope."""
+        model = serializer.Meta.model
+        row_pk = serializer.instance.pk
+        stored_profile_id = model.objects.filter(pk=row_pk).values_list("profile_id", flat=True).first()
+        if stored_profile_id is None:
+            raise Http404
+        requested_profile = serializer.validated_data.get("profile")
+        requested_profile_id = requested_profile.pk if requested_profile is not None else stored_profile_id
+        try:
+            with locked_profile_policy(stored_profile_id, requested_profile_id):
+                serializer.instance = model.objects.get(pk=row_pk, profile_id=stored_profile_id)
+                serializer.run_validation(serializer.initial_data)
+                result = save_permission_scoped_object(
+                    self.request.user,
+                    model,
+                    {"pk": row_pk, "profile_id": stored_profile_id},
+                    serializer.model_cleaned_values(),
+                )
+        except (model.DoesNotExist, ImportProfile.DoesNotExist):
+            raise Http404 from None
+        except ObjectPermissionDenied as exc:
+            raise PermissionDenied from exc
+        serializer.instance = result.instance
+
+    def perform_destroy(self, instance):
+        """Delete one policy row under its current profile and object scope."""
+        model = type(instance)
+        profile_id = model.objects.filter(pk=instance.pk).values_list("profile_id", flat=True).first()
+        if profile_id is None:
+            raise Http404
+        try:
+            with locked_profile_policy(profile_id):
+                deleted = delete_permission_scoped_objects(
+                    self.request.user,
+                    model.objects.filter(pk=instance.pk, profile_id=profile_id),
+                )
+                if deleted != 1:
+                    raise Http404
+        except ImportProfile.DoesNotExist:
+            raise Http404 from None
+        except ObjectPermissionDenied as exc:
+            raise PermissionDenied from exc
+
 
 class ColumnMappingViewSet(_PluginModelViewSet):
     """CRUD viewset for ColumnMapping."""
@@ -92,6 +166,13 @@ class ColumnMappingViewSet(_PluginModelViewSet):
     serializer_class = ColumnMappingSerializer
 
 
+class CableClassMappingViewSet(_PluginModelViewSet):
+    """CRUD viewset for CableClassMapping."""
+
+    queryset = CableClassMapping.objects.select_related("profile")
+    serializer_class = CableClassMappingSerializer
+
+
 class ClassRoleMappingViewSet(_PluginModelViewSet):
     """CRUD viewset for ClassRoleMapping."""
 
@@ -120,53 +201,12 @@ class ColumnTransformRuleViewSet(_PluginModelViewSet):
     serializer_class = ColumnTransformRuleSerializer
 
 
-def _revalidate_against_the_stored_row(serializer):
-    """Read the resolution again and check the request against the row as it now stands.
-
-    save() writes every field, so a request that changed another field first would otherwise be
-    undone. The whole validation runs again rather than validate() alone, because the field checks
-    read the stored row too, and the profile lock makes this reading of it authoritative. The
-    result is discarded: the values are the request's own, which the first pass already holds.
-    """
-    serializer.instance = SourceResolution.objects.get(pk=serializer.instance.pk)
-    serializer.run_validation(serializer.initial_data)
-
-
 class SourceResolutionViewSet(_PluginModelViewSet):
     """CRUD viewset for SourceResolution (rerere)."""
 
     queryset = SourceResolution.objects.select_related("profile")
     serializer_class = SourceResolutionSerializer
 
-    # Each write serializes against an executing import, which holds the same profile row.
-    def perform_create(self, serializer):
-        """Create the resolution under the profile lock."""
-        try:
-            with locked_profile_policy(serializer.validated_data["profile"].pk):
-                serializer.save()
-        except ImportProfile.DoesNotExist:
-            # The profile is read to validate the request, and can be deleted before the lock.
-            raise Http404 from None
-
-    def perform_update(self, serializer):
-        """Update the resolution under its profile lock."""
-        # ValidatedModelSerializer.validate() writes the request values onto the instance, so only
-        # its primary key still names the stored row.
-        try:
-            with locked_resolution_policy(serializer.instance.pk):
-                _revalidate_against_the_stored_row(serializer)
-                serializer.save()
-        except (SourceResolution.DoesNotExist, ImportProfile.DoesNotExist):
-            raise Http404 from None
-
-    def perform_destroy(self, instance):
-        """Delete the resolution under its profile lock."""
-        try:
-            with locked_resolution_policy(instance.pk):
-                instance.delete()
-        except (SourceResolution.DoesNotExist, ImportProfile.DoesNotExist):
-            raise Http404 from None
-
 
 class ImportExecutionViewSet(_ProfileScopedQuerySetMixin, viewsets.ReadOnlyModelViewSet):
     """Read-only viewset for the Import Execution audit history."""
@@ -176,6 +216,27 @@ class ImportExecutionViewSet(_ProfileScopedQuerySetMixin, viewsets.ReadOnlyModel
     permission_classes = [permissions.IsAuthenticated, DjangoModelPermissionsWithView]
 
 
+class CableImportSourceViewSet(_ProfileScopedQuerySetMixin, viewsets.ReadOnlyModelViewSet):
+    """Read-only viewset for per-Cable import provenance."""
+
+    queryset = CableImportSource.objects.select_related("cable", "profile")
+    serializer_class = CableImportSourceSerializer
+    permission_classes = [permissions.IsAuthenticated, DjangoModelPermissionsWithView]
+
+    def get_queryset(self):
+        """Apply the profile scope and an optional Cable ID filter."""
+        profile_scope = ImportProfile.objects.restrict(self.request.user, "view")
+        qs = super().get_queryset().filter(profile__in=profile_scope)
+        cable_id = self.request.query_params.get("cable_id")
+        if cable_id is not None:
+            try:
+                cable_id = int(cable_id)
+            except (TypeError, ValueError) as exc:
+                raise ValidationError({"cable_id": "Enter a whole number."}) from exc
+            qs = qs.filter(cable_id=cable_id)
+        return qs
+
+
 class ResolutionProposalViewSet(_ProfileScopedQuerySetMixin, viewsets.ReadOnlyModelViewSet):
     """Read-only viewset for Resolution Proposal history."""
 
@@ -225,12 +286,8 @@ class ResolutionProposalHistoryViewSet(mixins.ListModelMixin, viewsets.GenericVi
         )
 
 
-class InferenceBackendViewSet(NetBoxReadOnlyModelViewSet):
-    """Read-only viewset for Inference Backend rows.
-
-    Read-only on purpose: a backend row carries the destination NetBox itself calls, and the UI form
-    is the one place that validates the `api_root` trust boundary against the allowlist.
-    """
+class InferenceBackendViewSet(NetBoxModelViewSet):
+    """CRUD viewset whose configuration fields derive from the Inference Backend form."""
 
     queryset = InferenceBackend.objects.prefetch_related("tags")
     serializer_class = InferenceBackendSerializer

{netbox_data_import-2.2.0 → netbox_data_import-2.4.0}/netbox_data_import/cable_target.py

@@ -36,6 +36,13 @@ from .field_keys import (
 from .object_permissions import enforce_saved_object_permission
 from .plan import Diagnostic, Disposition, PlannedChange, Severity, SynchronizationUnit
 from .target_runtime import DeletedObject, PreconditionFailed
+from .trace_device_resolution import (
+    STALE as DEVICE_STALE,
+    collect_trace_device_evidence,
+    resolve_trace_devices,
+    resolved_trace_device,
+    source_device_key,
+)
 from .values import identity_text, source_text
 
 CABLE_STATUS = "connected"
@@ -207,7 +214,9 @@ class _TraceAnalysis:
     segments: list = field(default_factory=list)
     proven: dict = field(default_factory=dict)
     policies: dict = field(default_factory=dict)
+    devices: dict = field(default_factory=dict)
     terminations: dict = field(default_factory=dict)
+    resolution_started: bool = False
     topology_read: bool = False
     logical_cable: Any = None
     retains_logical_cable: bool = False
@@ -303,38 +312,19 @@ def _source_record(trace, segment_index: int) -> dict:
     }
 
 
-def _visible_devices(netbox_reader, names, *, _lock_rows=False) -> dict[str, list]:
-    """Return the visible Devices at the import target, grouped by comparison name."""
-    from django.db.models import Q
-
-    wanted = {identity_text(name) for name in names if identity_text(name)}
-    if not wanted:
-        return {}
-    devices = netbox_reader.devices()
-    if netbox_reader.site is not None:
-        devices = devices.filter(site=netbox_reader.site)
-    if _lock_rows:
-        devices = devices.order_by("pk").select_for_update(of=("self",))
-    lookup = Q()
-    for name in sorted(wanted):
-        lookup |= Q(name__iexact=name)
-    grouped: dict[str, list] = {}
-    for device in devices.filter(lookup):
-        comparison = identity_text(device.name)
-        if comparison in wanted:
-            grouped.setdefault(comparison, []).append(device)
-    return grouped
-
-
-def resolved_device_for(field_key: str, netbox_reader, *, _lock_rows=False):
+def resolved_device_for(field_key: str, netbox_reader, *, profile, _lock_rows=False):
     """Return the one visible Device a termination field key names, or None when it names no single one.
 
     A proposal freezes this reference and revalidates it, so the retrieval and the freshness check
     have to agree on what "the resolved Device" means.
     """
     device_name = parse_termination_field_key(field_key)["device"]
-    devices = _visible_devices(netbox_reader, [device_name], _lock_rows=_lock_rows).get(identity_text(device_name), [])
-    return devices[0] if len(devices) == 1 else None
+    return resolved_trace_device(
+        profile=profile,
+        reader=netbox_reader,
+        source_label=device_name,
+        lock_rows=_lock_rows,
+    )
 
 
 _RESOLVED_DEVICE_UNSET = object()
@@ -361,7 +351,7 @@ def eligible_terminations(
     kind = parsed["kind"]
     accessor = _READER_ACCESSOR_BY_KIND[kind]
     device = (
-        resolved_device_for(field_key, netbox_reader, _lock_rows=_lock_rows)
+        resolved_device_for(field_key, netbox_reader, profile=profile, _lock_rows=_lock_rows)
         if _resolved_device is _RESOLVED_DEVICE_UNSET
         else _resolved_device
     )
@@ -430,6 +420,7 @@ class _CableBatch:
     """Plan every Source Trace in one batch, so an identical shared segment plans once."""
 
     def __init__(self, traces, profile, netbox_reader, *, lock_plan_references: bool = False):
+        traces = tuple(traces)
         self.profile = profile
         self.reader = netbox_reader
         self.actor = netbox_reader.actor
@@ -445,7 +436,14 @@ class _CableBatch:
         self._occupied: dict[tuple[str, int], _ExistingCable] = {}
         self._mapping_rows: dict[str, Any] | None = None
         self._stored = self._stored_resolutions()
-        self._devices = self._load_devices()
+        active_traces = (analysis.trace for analysis in self.analyses if not analysis.stopped)
+        self._device_evidence = collect_trace_device_evidence(active_traces)
+        self._device_resolutions = resolve_trace_devices(
+            profile=self.profile,
+            reader=self.reader,
+            evidence=self._device_evidence,
+            lock_rows=self.lock_plan_references,
+        )
         self._resolve_terminations()
         self._load_mappings()
         self._build_segments()
@@ -512,16 +510,6 @@ class _CableBatch:
         ).select_related("selected_object_type")
         return {row.field_key: row for row in rows}
 
-    def _load_devices(self) -> dict[str, list]:
-        """Return the visible Devices every planned trace names, grouped by comparison name."""
-        names = [
-            reference.device
-            for analysis in self.analyses
-            if not analysis.stopped
-            for reference in self._references(analysis.trace)
-        ]
-        return _visible_devices(self.reader, names)
-
     def _components_for(self, device_id: int, kind: str) -> dict[str, list]:
         """Return one Device's terminations of one kind, grouped by comparison name."""
         cached = self._components.get((device_id, kind))
@@ -537,6 +525,7 @@ class _CableBatch:
         for analysis in self.analyses:
             if analysis.stopped:
                 continue
+            analysis.resolution_started = True
             resolved: dict[tuple, _Termination] = {}
             for reference in self._references(analysis.trace):
                 if reference.identity_key in resolved:
@@ -548,19 +537,24 @@ class _CableBatch:
 
     def _resolve_one(self, analysis: _TraceAnalysis, reference) -> _Termination | None:
         """Return the NetBox object one Termination Reference names, or record the open decision."""
-        devices = self._devices.get(identity_text(reference.device), [])
-        if len(devices) != 1:
-            analysis.block("trace.device_unresolved", {**_reference_display(reference), "matches": len(devices)})
+        resolution = self._device_resolutions[source_device_key(reference.device)]
+        analysis.devices.setdefault(resolution.evidence.key, resolution.to_question())
+        if resolution.device is None:
+            code = "trace.device_resolution_stale" if resolution.state == DEVICE_STALE else "trace.device_unresolved"
+            analysis.block(
+                code,
+                {**_reference_display(reference), "matches": resolution.exact_match_count},
+            )
             # With no resolved Device there is nothing to pick from, so the picker cannot help here.
             self._record_resolution(
                 analysis,
                 reference,
                 UNRESOLVED,
                 None,
-                reason=f"The source names {len(devices)} matching Devices, so no port list applies.",
+                reason="Resolve the source Device before choosing one of its ports.",
             )
             return None
-        device = devices[0]
+        device = resolution.device
         stored = self._stored.get(_field_key(reference))
         if stored is not None:
             termination = self._stored_termination(analysis, reference, device, stored)
@@ -1222,9 +1216,11 @@ class _CableBatch:
             },
             "segments": segments,
             "logical_cable": self._logical_cable_display(analysis),
+            "resolution_started": analysis.resolution_started,
             "topology_known": analysis.topology_read,
             # A unit with no changes proposes nothing, so the panel must not offer to delete one.
             "deletes_logical_cable": writes and analysis.deleted_logical_cable is not None,
+            "devices": list(analysis.devices.values()),
             "terminations": list(analysis.terminations.values()),
         }
 

{netbox_data_import-2.2.0 → netbox_data_import-2.4.0}/netbox_data_import/catalog.py

@@ -259,6 +259,7 @@ POLICY_SECTIONS: tuple[PolicySection, ...] = (
     PolicySection("source_resolutions", "Source Resolutions", _DEVICE_ONLY),
     PolicySection("device_existing_matches", "Device Existing Matches", _DEVICE_ONLY),
     PolicySection("ignored_field_differences", "Ignored Field Differences", _DEVICE_ONLY),
+    PolicySection("trace_device_resolutions", "Trace Device Resolutions", _TRACE_ONLY),
     PolicySection("termination_resolutions", "Termination Resolutions", _TRACE_ONLY),
     PolicySection("cable_class_mappings", "CableClass Mappings", _TRACE_ONLY),
 )