netbox-data-import 2.1.0__tar.gz → 2.3.0__tar.gz

{netbox_data_import-2.1.0 → netbox_data_import-2.3.0}/PKG-INFO

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

{netbox_data_import-2.1.0 → netbox_data_import-2.3.0}/netbox_data_import/__init__.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from netbox.plugins import PluginConfig
 
-__version__ = "2.1.0"
+__version__ = "2.3.0"
 
 
 class NetBoxDataImportConfig(PluginConfig):
@@ -40,10 +40,10 @@ class NetBoxDataImportConfig(PluginConfig):
             raise ImproperlyConfigured(f"Plugin {cls.__module__} has an invalid configuration: {exc}") from exc
 
     def ready(self):
-        """Import the jobs module, which NetBox does not load, so its @system_job registration runs."""
+        """Import the modules NetBox does not load, so their job and task registrations run."""
         super().ready()
 
-        from . import jobs
+        from . import jobs, termination_proposal
 
 
 config = NetBoxDataImportConfig

{netbox_data_import-2.1.0 → netbox_data_import-2.3.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,
@@ -19,6 +22,8 @@ from ..models import (
     ColumnTransformRule,
     SourceResolution,
     ImportExecution,
+    InferenceBackend,
+    ResolutionProposal,
     validate_adapter_target_module,
     validate_contact_candidate_resolution,
     validate_section_applicability,
@@ -61,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."""
@@ -143,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."""
 
@@ -278,3 +312,94 @@ class ImportExecutionSerializer(serializers.ModelSerializer):
             "failure_detail",
         ]
         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."""
+
+    class Meta:
+        model = ResolutionProposal
+        fields = [
+            "id",
+            "profile",
+            "task_type",
+            "field_key",
+            "status",
+            "source_evidence",
+            "resolved_device_type",
+            "resolved_device_id",
+            "prompt_version",
+            "response_schema_version",
+            "candidate_snapshot",
+            "requested_by",
+            "created",
+            "last_updated",
+            "outcome",
+            "selected_candidate_id",
+            "selected_object_type",
+            "selected_object_id",
+            "explanation",
+            "backend_metadata",
+            "response_diagnostic",
+            "failure_reason",
+            "decision",
+            "decided_by",
+            "decided_at",
+            "written_resolution",
+        ]
+        read_only_fields = fields
+
+
+class ResolutionProposalHistorySerializer(serializers.ModelSerializer):
+    """Serialize one attempt summary for profile-scoped field history."""
+
+    class Meta:
+        model = ResolutionProposal
+        fields = ["id", "created", "status", "outcome", "decision", "failure_reason"]
+        read_only_fields = fields
+
+
+class InferenceBackendSerializer(NetBoxModelSerializer):
+    """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",
+            *InferenceBackendForm.Meta.fields,
+            "custom_fields",
+            "created",
+            "last_updated",
+        ]
+        brief_fields = ["id", "url", "display", "backend_key", "display_name", "enabled"]

{netbox_data_import-2.1.0 → netbox_data_import-2.3.0}/netbox_data_import/api/urls.py

@@ -2,10 +2,13 @@
 # Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
 """URL router for the data-import plugin API."""
 
+from django.urls import path
 from netbox.api.routers import NetBoxRouter
 
 from .views import (
     ImportProfileViewSet,
+    CableClassMappingViewSet,
+    CableImportSourceViewSet,
     ColumnMappingViewSet,
     ClassRoleMappingViewSet,
     DeviceTypeMappingViewSet,
@@ -13,10 +16,15 @@ from .views import (
     ColumnTransformRuleViewSet,
     SourceResolutionViewSet,
     ImportExecutionViewSet,
+    InferenceBackendViewSet,
+    ResolutionProposalHistoryViewSet,
+    ResolutionProposalViewSet,
 )
 
 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)
@@ -24,6 +32,15 @@ router.register("ignored-devices", IgnoredDeviceViewSet)
 router.register("column-transforms", ColumnTransformRuleViewSet)
 router.register("source-resolutions", SourceResolutionViewSet)
 router.register("executions", ImportExecutionViewSet)
+router.register("ai-backends", InferenceBackendViewSet)
+router.register("resolution-proposals", ResolutionProposalViewSet)
 
 app_name = "netbox_data_import"
-urlpatterns = router.urls
+urlpatterns = [
+    path(
+        "resolution-proposal-history/",
+        ResolutionProposalHistoryViewSet.as_view({"get": "list"}),
+        name="resolutionproposalhistory-list",
+    ),
+    *router.urls,
+]

netbox_data_import-2.3.0/netbox_data_import/api/views.py

@@ -0,0 +1,293 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
+"""DRF viewsets for the data-import plugin API."""
+
+from django.http import Http404
+from netbox.api.viewsets import NetBoxModelViewSet
+from rest_framework import mixins, permissions, viewsets
+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,
+    ImportProfile,
+    CableClassMapping,
+    CableImportSource,
+    ColumnMapping,
+    ClassRoleMapping,
+    DeviceTypeMapping,
+    IgnoredDevice,
+    ColumnTransformRule,
+    SourceResolution,
+    ImportExecution,
+    InferenceBackend,
+    ResolutionProposal,
+)
+from ..object_permissions import (
+    ObjectPermissionDenied,
+    delete_permission_scoped_objects,
+    save_permission_scoped_object,
+)
+from .serializers import (
+    ImportProfileSerializer,
+    CableClassMappingSerializer,
+    CableImportSourceSerializer,
+    ColumnMappingSerializer,
+    ClassRoleMappingSerializer,
+    DeviceTypeMappingSerializer,
+    IgnoredDeviceSerializer,
+    ColumnTransformRuleSerializer,
+    SourceResolutionSerializer,
+    ImportExecutionSerializer,
+    InferenceBackendSerializer,
+    ResolutionProposalHistorySerializer,
+    ResolutionProposalSerializer,
+)
+
+
+class DjangoModelPermissionsWithView(DjangoModelPermissions):
+    """Extends DjangoModelPermissions to require view_* permission for GET requests.
+
+    The stock DjangoModelPermissions does not map GET to any model permission,
+    so list/retrieve endpoints are accessible to any authenticated user.  This
+    subclass closes that gap.
+    """
+
+    perms_map = {
+        **DjangoModelPermissions.perms_map,
+        "GET": ["%(app_label)s.view_%(model_name)s"],
+        "HEAD": ["%(app_label)s.view_%(model_name)s"],
+        "OPTIONS": [],
+    }
+
+
+class ImportProfileViewSet(NetBoxModelViewSet):
+    """CRUD viewset for ImportProfile (NetBoxModel)."""
+
+    queryset = ImportProfile.objects.prefetch_related(
+        "tags", "column_mappings", "class_role_mappings", "device_type_mappings"
+    )
+    serializer_class = ImportProfileSerializer
+
+
+class _ProfileScopedQuerySetMixin(viewsets.GenericViewSet):
+    """Restrict profile-owned rows and validate their optional profile filter."""
+
+    def get_queryset(self):
+        """Return viewable rows, filtered by a valid profile ID when supplied."""
+        qs = super().get_queryset().restrict(self.request.user, "view")
+        profile_id = self.request.query_params.get("profile_id")
+        if profile_id is not None:
+            try:
+                profile_id = int(profile_id)
+            except (TypeError, ValueError) as exc:
+                raise ValidationError({"profile_id": "Enter a whole number."}) from exc
+            qs = qs.filter(profile_id=profile_id)
+        return qs
+
+
+class _PluginModelViewSet(_ProfileScopedQuerySetMixin, viewsets.ModelViewSet):
+    """Base class for plain-model viewsets in this plugin."""
+
+    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."""
+
+    queryset = ColumnMapping.objects.select_related("profile")
+    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."""
+
+    queryset = ClassRoleMapping.objects.select_related("profile", "rack_type")
+    serializer_class = ClassRoleMappingSerializer
+
+
+class DeviceTypeMappingViewSet(_PluginModelViewSet):
+    """CRUD viewset for DeviceTypeMapping."""
+
+    queryset = DeviceTypeMapping.objects.select_related("profile")
+    serializer_class = DeviceTypeMappingSerializer
+
+
+class IgnoredDeviceViewSet(_PluginModelViewSet):
+    """CRUD viewset for IgnoredDevice."""
+
+    queryset = IgnoredDevice.objects.select_related("profile")
+    serializer_class = IgnoredDeviceSerializer
+
+
+class ColumnTransformRuleViewSet(_PluginModelViewSet):
+    """CRUD viewset for ColumnTransformRule."""
+
+    queryset = ColumnTransformRule.objects.select_related("profile")
+    serializer_class = ColumnTransformRuleSerializer
+
+
+class SourceResolutionViewSet(_PluginModelViewSet):
+    """CRUD viewset for SourceResolution (rerere)."""
+
+    queryset = SourceResolution.objects.select_related("profile")
+    serializer_class = SourceResolutionSerializer
+
+
+class ImportExecutionViewSet(_ProfileScopedQuerySetMixin, viewsets.ReadOnlyModelViewSet):
+    """Read-only viewset for the Import Execution audit history."""
+
+    queryset = ImportExecution.objects.select_related("profile")
+    serializer_class = ImportExecutionSerializer
+    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."""
+
+    queryset = ResolutionProposal.objects.select_related("profile")
+    serializer_class = ResolutionProposalSerializer
+    permission_classes = [permissions.IsAuthenticated, DjangoModelPermissionsWithView]
+
+    def get_queryset(self):
+        """Return proposals only for profiles that the actor can view."""
+        profile_scope = ImportProfile.objects.restrict(self.request.user, "view")
+        return super().get_queryset().filter(profile__in=profile_scope)
+
+
+class ResolutionProposalHistoryViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
+    """Read one field's complete paginated history with workspace permissions."""
+
+    queryset = ResolutionProposal.objects.none()
+    serializer_class = ResolutionProposalHistorySerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get_queryset(self):
+        """Return one profile field's history when the actor can view that profile."""
+        profile_values = self.request.query_params.getlist("profile_id")
+        field_values = self.request.query_params.getlist("field_key")
+        if len(profile_values) != 1 or not profile_values[0]:
+            raise ValidationError({"profile_id": "Provide one whole-number profile ID."})
+        if len(field_values) != 1 or not field_values[0]:
+            raise ValidationError({"field_key": "Provide one canonical termination field key."})
+        try:
+            profile_id = int(profile_values[0])
+        except (TypeError, ValueError) as exc:
+            raise ValidationError({"profile_id": "Provide one whole-number profile ID."}) from exc
+        try:
+            parse_termination_field_key(field_values[0])
+        except ValueError as exc:
+            raise ValidationError({"field_key": "Provide one canonical termination field key."}) from exc
+        if not ImportProfile.objects.restrict(self.request.user, "view").filter(pk=profile_id).exists():
+            raise Http404
+        return (
+            ResolutionProposal.objects.filter(
+                profile_id=profile_id,
+                task_type=SELECT_TERMINATION_TASK,
+                field_key=field_values[0],
+            )
+            .select_related("profile")
+            .order_by("-created", "-pk")
+        )
+
+
+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.1.0 → netbox_data_import-2.3.0}/netbox_data_import/cable_target.py

@@ -303,7 +303,7 @@ def _source_record(trace, segment_index: int) -> dict:
     }
 
 
-def _visible_devices(netbox_reader, names) -> dict[str, list]:
+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
 
@@ -313,6 +313,8 @@ def _visible_devices(netbox_reader, names) -> dict[str, list]:
     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)
@@ -324,6 +326,20 @@ def _visible_devices(netbox_reader, names) -> dict[str, list]:
     return grouped
 
 
+def resolved_device_for(field_key: str, netbox_reader, *, _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
+
+
+_RESOLVED_DEVICE_UNSET = object()
+
+
 def eligible_terminations(
     field_key: str,
     netbox_reader,
@@ -331,6 +347,8 @@ def eligible_terminations(
     profile,
     search: str = "",
     limit: int = ELIGIBLE_TERMINATION_LIMIT,
+    _resolved_device=_RESOLVED_DEVICE_UNSET,
+    _lock_rows: bool = False,
 ) -> EligibleTerminations:
     """Return one page of candidates for a canonical termination field key.
 
@@ -340,12 +358,15 @@ def eligible_terminations(
     query.
     """
     parsed = parse_termination_field_key(field_key)
-    device_name, kind = parsed["device"], parsed["kind"]
+    kind = parsed["kind"]
     accessor = _READER_ACCESSOR_BY_KIND[kind]
-    devices = _visible_devices(netbox_reader, [device_name]).get(identity_text(device_name), [])
-    if len(devices) != 1:
+    device = (
+        resolved_device_for(field_key, netbox_reader, _lock_rows=_lock_rows)
+        if _resolved_device is _RESOLVED_DEVICE_UNSET
+        else _resolved_device
+    )
+    if device is None:
         return EligibleTerminations(candidates=(), total=0)
-    device = devices[0]
     candidates = getattr(netbox_reader, accessor)().filter(device_id=device.pk)
     if parsed["role"] == MAPPED_PEER_ROLE:
         from .models import TerminationResolution, index_digest
@@ -399,6 +420,8 @@ def eligible_terminations(
         )
     if search:
         candidates = candidates.filter(name__icontains=search)
+    if _lock_rows:
+        tuple(candidates.order_by("pk").select_for_update(of=("self",)).values_list("pk", flat=True))
     candidates = candidates.order_by("name", "pk")
     return EligibleTerminations(candidates=tuple(candidates[:limit]), total=candidates.count())
 

netbox_data_import-2.3.0/netbox_data_import/graphql/schema.py

@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
+
+"""GraphQL queries registered with NetBox."""
+
+import strawberry
+import strawberry_django
+
+from .types import CableClassMappingType, ImportProfileType
+
+
+@strawberry.type(name="Query")
+class ImportProfilesQuery:
+    """Expose import profile detail and list queries."""
+
+    import_profile: ImportProfileType = strawberry_django.field()
+    import_profile_list: list[ImportProfileType] = strawberry_django.field()
+
+
+@strawberry.type(name="Query")
+class CableClassMappingsQuery:
+    """Expose CableClass mapping detail and list queries."""
+
+    cable_class_mapping: CableClassMappingType = strawberry_django.field()
+    cable_class_mapping_list: list[CableClassMappingType] = strawberry_django.field()
+
+
+schema = [ImportProfilesQuery, CableClassMappingsQuery]
+
+__all__ = ("CableClassMappingsQuery", "ImportProfilesQuery", "schema")

netbox_data_import-2.3.0/netbox_data_import/graphql/types.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
+
+"""GraphQL object types for import profile configuration."""
+
+import strawberry_django
+from netbox.graphql.types import BaseObjectType, NetBoxObjectType
+
+from netbox_data_import.models import CableClassMapping, ImportProfile
+
+from .filters import ImportProfileFilter
+
+_type_kwargs = {"fields": "__all__", "pagination": True}
+if ImportProfileFilter is not None:  # pragma: no cover
+    _type_kwargs["filters"] = ImportProfileFilter
+
+
+@strawberry_django.type(ImportProfile, **_type_kwargs)
+class ImportProfileType(NetBoxObjectType):
+    """One saved source-file import configuration."""
+
+
+@strawberry_django.type(
+    CableClassMapping,
+    fields=[
+        "id",
+        "profile",
+        "cable_class",
+        "cable_type_resolved",
+        "cable_type",
+        "cable_profile_resolved",
+        "cable_profile",
+    ],
+    pagination=True,
+)
+class CableClassMappingType(BaseObjectType):
+    """One trace CableClass policy decision."""
+
+    profile: ImportProfileType
+
+
+__all__ = ("CableClassMappingType", "ImportProfileType")