netbox-data-import 2.6.0__tar.gz → 2.7.0__tar.gz

{netbox_data_import-2.6.0 → netbox_data_import-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netbox-data-import
-Version: 2.6.0
+Version: 2.7.0
 Summary: NetBox plugin for importing data from external DCIM systems
 Author: Marcin Zieba
 License-Expression: Apache-2.0
@@ -17,6 +17,7 @@ License-File: LICENSE
 Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: google-re2>=1.1.20251105
 Requires-Dist: openpyxl>=3.1
+Requires-Dist: packaging>=24
 Requires-Dist: pyyaml>=6
 Requires-Dist: requests>=2.33.0
 Dynamic: license-file
@@ -31,7 +32,7 @@ Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
 [![Coverage](https://img.shields.io/endpoint?url=https://marcinpsk.github.io/netbox-data-import-plugin/coverage/badge.json)](https://marcinpsk.github.io/netbox-data-import-plugin/coverage/)
 [![License](https://img.shields.io/github/license/marcinpsk/netbox-data-import-plugin)](LICENSE)
 [![Python](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/)
-[![NetBox](https://img.shields.io/badge/NetBox-%E2%89%A54.6.0-blue)](https://github.com/netbox-community/netbox)
+[![NetBox](https://img.shields.io/badge/NetBox-%E2%89%A54.6.9-blue)](https://github.com/netbox-community/netbox)
 
 A NetBox plugin for importing device inventory and rack layouts from external DCIM systems via configurable field mappings.
 
@@ -50,11 +51,11 @@ Currently supports importing from Excel (`.xlsx`) workbooks with a flat, one-row
 
 ## Requirements
 
-- NetBox ≥ 4.6.0
+- NetBox ≥ 4.6.9
 - Python ≥ 3.12
 
 Cable trace import verifies each pass-through against the `PortMapping` model, which replaced the
-single rear-port reference on a front port in NetBox 4.5. The plugin supports NetBox 4.6 and later.
+single rear-port reference on a front port in NetBox 4.5. The plugin supports NetBox 4.6.9 and later.
 
 ## Installation
 

{netbox_data_import-2.6.0 → netbox_data_import-2.7.0}/README.md

@@ -8,7 +8,7 @@ Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
 [![Coverage](https://img.shields.io/endpoint?url=https://marcinpsk.github.io/netbox-data-import-plugin/coverage/badge.json)](https://marcinpsk.github.io/netbox-data-import-plugin/coverage/)
 [![License](https://img.shields.io/github/license/marcinpsk/netbox-data-import-plugin)](LICENSE)
 [![Python](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/)
-[![NetBox](https://img.shields.io/badge/NetBox-%E2%89%A54.6.0-blue)](https://github.com/netbox-community/netbox)
+[![NetBox](https://img.shields.io/badge/NetBox-%E2%89%A54.6.9-blue)](https://github.com/netbox-community/netbox)
 
 A NetBox plugin for importing device inventory and rack layouts from external DCIM systems via configurable field mappings.
 
@@ -27,11 +27,11 @@ Currently supports importing from Excel (`.xlsx`) workbooks with a flat, one-row
 
 ## Requirements
 
-- NetBox ≥ 4.6.0
+- NetBox ≥ 4.6.9
 - Python ≥ 3.12
 
 Cable trace import verifies each pass-through against the `PortMapping` model, which replaced the
-single rear-port reference on a front port in NetBox 4.5. The plugin supports NetBox 4.6 and later.
+single rear-port reference on a front port in NetBox 4.5. The plugin supports NetBox 4.6.9 and later.
 
 ## Installation
 

{netbox_data_import-2.6.0 → netbox_data_import-2.7.0}/netbox_data_import/__init__.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from netbox.plugins import PluginConfig
 
-__version__ = "2.6.0"
+__version__ = "2.7.0"
 
 
 class NetBoxDataImportConfig(PluginConfig):
@@ -17,8 +17,9 @@ class NetBoxDataImportConfig(PluginConfig):
     base_url = "data-import"
     author = "Marcin Zieba"
     author_email = "marcinpsk@gmail.com"
-    min_version = "4.6.0"
+    min_version = "4.6.9"
     graphql_schema = "graphql.schema.schema"
+    middleware = ["netbox_data_import.branching.BranchRefusalMiddleware"]
 
     default_settings: dict[str, Any] = {
         # A deployment that names no allowlist reaches no origin, rather than every origin.
@@ -40,10 +41,12 @@ class NetBoxDataImportConfig(PluginConfig):
             raise ImproperlyConfigured(f"Plugin {cls.__module__} has an invalid configuration: {exc}") from exc
 
     def ready(self):
-        """Import the modules NetBox does not load, so their job and task registrations run."""
+        """Import the modules NetBox does not load, and register with netbox-branching when it is installed."""
         super().ready()
 
-        from . import jobs, termination_proposal
+        from . import branching, jobs, termination_proposal
+
+        branching.register()
 
 
 config = NetBoxDataImportConfig

{netbox_data_import-2.6.0 → netbox_data_import-2.7.0}/netbox_data_import/api/views.py

@@ -8,6 +8,7 @@ from rest_framework import mixins, permissions, viewsets
 from rest_framework.exceptions import PermissionDenied, ValidationError
 from rest_framework.permissions import DjangoModelPermissions
 
+from ..filters import ImportProfileFilterSet, InferenceBackendFilterSet
 from ..field_keys import SELECT_TERMINATION_TASK, parse_termination_field_key
 from ..models import (
     locked_profile_policy,
@@ -69,6 +70,7 @@ class ImportProfileViewSet(NetBoxModelViewSet):
         "tags", "column_mappings", "class_role_mappings", "device_type_mappings"
     )
     serializer_class = ImportProfileSerializer
+    filterset_class = ImportProfileFilterSet
 
 
 class _ProfileScopedQuerySetMixin(viewsets.GenericViewSet):
@@ -291,3 +293,4 @@ class InferenceBackendViewSet(NetBoxModelViewSet):
 
     queryset = InferenceBackend.objects.prefetch_related("tags")
     serializer_class = InferenceBackendSerializer
+    filterset_class = InferenceBackendFilterSet

netbox_data_import-2.7.0/netbox_data_import/branching.py

@@ -0,0 +1,236 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2026 Marcin Zieba <marcinpsk@gmail.com>
+"""The one owner of every netbox-branching fact the plugin relies on.
+
+netbox-branching is optional. Without it, every function here is a no-op.
+"""
+
+from core.choices import ObjectChangeActionChoices
+from django.apps import apps
+from django.contrib.messages import get_messages
+from django.core.exceptions import ImproperlyConfigured, MiddlewareNotUsed
+from django.db import models
+from django.http import JsonResponse
+from django.shortcuts import render
+from packaging.version import Version
+from utilities.api import is_api_request
+
+APP_LABEL = "netbox_data_import"
+BRANCHING_APP_LABEL = "netbox_branching"
+REFUSAL_CODE = "branch_not_supported"
+# The design covers netbox-branching 1.2.x; 1.1.x also has register_branching_resolver.
+MINIMUM_BRANCHING_RELEASE = (1, 2)
+
+
+class BranchActive(Exception):
+    """A plugin entry point was reached while a netbox-branching branch is active."""
+
+
+def installed() -> bool:
+    """Return whether netbox-branching is an installed app."""
+    return apps.is_installed(BRANCHING_APP_LABEL)
+
+
+def active_branch():
+    """Return the active Branch, or None when no branch is active or netbox-branching is absent."""
+    if not installed():
+        return None
+    from netbox_branching.contextvars import active_branch as branch_context
+    from netbox_branching.models import Branch
+
+    branch = branch_context.get()
+    # A header naming a branch that is not ready puts netbox-branching's 400 response in the context.
+    return branch if isinstance(branch, Branch) else None
+
+
+# An anonymous caller is refused without the name or the state of any branch.
+ANONYMOUS_REFUSAL = "NetBox Data Import runs on main only, and this request selects a branch."
+
+
+def refusal_message(branch) -> str:
+    """Return the one message every refused entry point shows."""
+    if branch is None:
+        return "NetBox Data Import runs on main only, and this request selects a branch that is not active."
+    # Typographic quotes need no HTML escaping, so the page, the REST detail and GraphQL show one text.
+    return f"NetBox Data Import runs on main only, and the active branch is \u201c{branch.name}\u201d."
+
+
+def refuse_branch() -> None:
+    """Raise BranchActive when a branch is active."""
+    branch = active_branch()
+    if branch is not None:
+        raise BranchActive(refusal_message(branch))
+
+
+def fail_job_in_branch(runner) -> None:
+    """Fail a background job with the refusal in its log when its worker has a branch active."""
+    from core.exceptions import JobFailed
+
+    try:
+        refuse_branch()
+    except BranchActive as exc:
+        refusal = exc
+    else:
+        return
+    runner.logger.error(str(refusal))
+    raise JobFailed(str(refusal)) from refusal
+
+
+def _selects_a_branch(request) -> bool:
+    """Return whether a request names a branch, in netbox-branching's own order of precedence."""
+    from netbox_branching.constants import BRANCH_HEADER, COOKIE_NAME, QUERY_PARAM
+    from netbox_branching.utilities import is_api_request
+
+    # netbox-branching reads the header on REST and GraphQL requests only.
+    if is_api_request(request) and BRANCH_HEADER in request.headers:
+        return True
+    if QUERY_PARAM in request.GET:
+        return bool(request.GET[QUERY_PARAM])
+    return COOKIE_NAME in request.COOKIES
+
+
+def request_refusal(request) -> str | None:
+    """Return the refusal message for a request that has a branch active or selected, else None."""
+    if not installed():
+        return None
+    branch = active_branch()
+    if branch is None and not _selects_a_branch(request):
+        return None
+    if not request.user.is_authenticated:
+        return ANONYMOUS_REFUSAL
+    return refusal_message(branch)
+
+
+def _is_plugin_view(view_func) -> bool:
+    owner = getattr(view_func, "view_class", None) or getattr(view_func, "cls", None) or view_func
+    module = getattr(owner, "__module__", None) or ""
+    return module == APP_LABEL or module.startswith(f"{APP_LABEL}.")
+
+
+class BranchRefusalMiddleware:
+    """Refuse a request to a plugin-owned view while a branch is active or selected."""
+
+    def __init__(self, get_response):
+        if not installed():
+            raise MiddlewareNotUsed
+        self.get_response = get_response
+
+    def __call__(self, request):
+        """Pass the request on; the refusal needs the resolved view, so it happens in process_view."""
+        return self.get_response(request)
+
+    def process_view(self, request, view_func, view_args, view_kwargs):
+        """Answer 409 in place of the plugin view: JSON for the REST API, a page for the UI."""
+        if not _is_plugin_view(view_func):
+            return None
+        message = request_refusal(request)
+        if message is None:
+            return None
+        if is_api_request(request):
+            return JsonResponse({"detail": message, "code": REFUSAL_CODE}, status=409)
+        # The plugin's scripts ask for JSON and show the `error` of an `ok: false` envelope.
+        if request.get_preferred_type(["text/html", "application/json"]) == "application/json":
+            return JsonResponse({"ok": False, "error": message, "code": REFUSAL_CODE}, status=409)
+        if request.user.is_authenticated:
+            return render(request, "netbox_data_import/branch_refused.html", {"message": message}, status=409)
+        # netbox-branching queues messages that name the branch; reading them here deletes them unseen.
+        list(get_messages(request))
+        # The full layout shows the branch selector, so an anonymous caller gets the bare page.
+        return render(
+            request,
+            "netbox_data_import/branch_refused_anonymous.html",
+            {"message": message, "messages": ()},
+            status=409,
+        )
+
+
+def _branchable_references(model: type[models.Model]) -> set[type[models.Model]]:
+    """Return the branchable models outside the plugin that a concrete foreign key of the model references."""
+    from netbox_branching.utilities import supports_branching
+
+    return {
+        field.related_model
+        for field in model._meta.concrete_fields
+        if isinstance(field, models.ForeignKey)
+        and field.related_model._meta.app_label != APP_LABEL
+        and supports_branching(field.related_model)
+    }
+
+
+def is_branchable(model: type[models.Model]) -> bool | None:
+    """Resolve branching support for a plugin model, and defer (None) for every other model.
+
+    A plugin model is branchable when one of its concrete foreign keys reaches a branchable model
+    outside the plugin: a core delete in a branch then cascades into that table, which must exist
+    in the branch schema.
+    """
+    if model._meta.app_label != APP_LABEL:
+        return None
+    return bool(_branchable_references(model))
+
+
+def _unrevertable_models() -> set[type[models.Model]]:
+    """Return the models whose delete a revert cannot undo without losing plugin data."""
+    from extras.models import Tag, TaggedItem
+
+    # A Tag delete removes Import Profile assignments in main, and a sync records a TaggedItem delete.
+    unrevertable = {Tag, TaggedItem}
+    for model in apps.get_app_config(APP_LABEL).get_models():
+        if references := _branchable_references(model):
+            unrevertable |= {model, *references}
+    return unrevertable
+
+
+def validate_revert(branch):
+    """Refuse a revert of a branch that deleted an object the plugin's data depends on.
+
+    Revert replays the branch's ObjectChange rows, and plugin data has none, except the synthetic
+    deletes that a sync records. So a revert cannot restore the plugin data such a delete removed.
+    """
+    from django.contrib.contenttypes.models import ContentType
+    from netbox_branching.utilities import BranchActionIndicator
+
+    content_types = ContentType.objects.get_for_models(*_unrevertable_models())
+    models_by_type = {content_type.pk: model for model, content_type in content_types.items()}
+    deleted = (
+        branch.get_changes()
+        .filter(action=ObjectChangeActionChoices.ACTION_DELETE, changed_object_type__in=models_by_type)
+        .order_by()
+        .values_list("changed_object_type", flat=True)
+        .distinct()
+    )
+    names = sorted(str(models_by_type[type_id]._meta.verbose_name) for type_id in deleted)
+    if not names:
+        return BranchActionIndicator(True)
+    return BranchActionIndicator(
+        False,
+        "NetBox Data Import data cannot be restored by a revert, and this branch deleted objects of these "
+        f"types: {', '.join(names)}.",
+    )
+
+
+def register() -> None:
+    """Register the resolver and the revert validator, and refuse a configuration that overrides the resolver."""
+    if not installed():
+        return
+    release = apps.get_app_config(BRANCHING_APP_LABEL).version
+    # Compare the release segment only, so a 1.2 pre-release is not refused.
+    if Version(release).release < MINIMUM_BRANCHING_RELEASE:
+        raise ImproperlyConfigured(
+            f"{APP_LABEL}: netbox-branching {release} is installed; this plugin needs 1.2 or later."
+        )
+    from netbox_branching.models import Branch
+    from netbox_branching.utilities import register_branching_resolver, supports_branching
+
+    register_branching_resolver(is_branchable)
+    Branch.register_preaction_check(validate_revert, "revert")
+    overridden = sorted(
+        model._meta.label
+        for model in apps.get_app_config(APP_LABEL).get_models()
+        if supports_branching(model) != is_branchable(model)
+    )
+    if overridden:
+        raise ImproperlyConfigured(
+            f"{APP_LABEL}: netbox-branching disagrees with the plugin on branching for {', '.join(overridden)}. "
+            f"Remove {APP_LABEL} models from the netbox_branching exempt_models setting."
+        )

{netbox_data_import-2.6.0 → netbox_data_import-2.7.0}/netbox_data_import/contact_resolution.py

@@ -478,12 +478,14 @@ class PrimaryContactResolver:
             assignment = None
             if action == "replace":
                 assignment = ContactAssignment.objects.get(pk=plan["primary_assignment_id"])
+                assignment.snapshot()
                 assignment.contact = contact
                 assignment.full_clean()
                 assignment.save(update_fields=["contact"])
                 enforce_saved_object_permission(assignment, user, "change")
             elif action == "demote_and_promote":
                 previous = ContactAssignment.objects.get(pk=plan["primary_assignment_id"])
+                previous.snapshot()
                 previous.priority = "secondary"
                 previous.full_clean()
                 previous.save(update_fields=["priority"])
@@ -498,6 +500,7 @@ class PrimaryContactResolver:
                 assignment.save()
                 enforce_saved_object_permission(assignment, user, "add")
             elif assignment.priority != "primary":
+                assignment.snapshot()
                 assignment.priority = "primary"
                 assignment.full_clean()
                 assignment.save(update_fields=["priority"])

netbox_data_import-2.7.0/netbox_data_import/filters.py

@@ -0,0 +1,29 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
+from django.db.models import Q
+from netbox.filtersets import NetBoxModelFilterSet
+from .models import ImportProfile, InferenceBackend
+
+
+class ImportProfileFilterSet(NetBoxModelFilterSet):
+    """FilterSet for ImportProfile, supporting name substring search."""
+
+    class Meta:
+        model = ImportProfile
+        fields = ["name", "source_adapter"]
+
+    def search(self, queryset, name, value):
+        """Filter profiles by name substring."""
+        return queryset.filter(name__icontains=value)
+
+
+class InferenceBackendFilterSet(NetBoxModelFilterSet):
+    """FilterSet for InferenceBackend, supporting key and display name search."""
+
+    class Meta:
+        model = InferenceBackend
+        fields = ["backend_key", "display_name", "adapter_type", "response_mode", "enabled"]
+
+    def search(self, queryset, name, value):
+        """Filter backends by key or display name substring."""
+        return queryset.filter(Q(backend_key__icontains=value) | Q(display_name__icontains=value))

{netbox_data_import-2.6.0 → netbox_data_import-2.7.0}/netbox_data_import/forms.py

@@ -6,9 +6,11 @@ from django import forms
 from django.utils.html import format_html
 from dcim.models import Site, Location
 from tenancy.models import Tenant
-from netbox.forms import NetBoxModelBulkEditForm, NetBoxModelForm, NetBoxModelImportForm
-from utilities.forms.fields import DynamicModelChoiceField
-from .adapters import get_adapter, selectable_adapter_choices
+from netbox.forms import NetBoxModelBulkEditForm, NetBoxModelFilterSetForm, NetBoxModelForm, NetBoxModelImportForm
+from utilities.forms import BOOLEAN_WITH_BLANK_CHOICES, add_blank_choice
+from utilities.forms.fields import DynamicModelChoiceField, TagFilterField
+from utilities.forms.rendering import FieldSet
+from .adapters import adapter_choices, get_adapter, selectable_adapter_choices
 from .catalog import CATALOG
 from .models import (
     CableClassMapping,
@@ -200,6 +202,18 @@ class ImportProfileBulkEditForm(NetBoxModelBulkEditForm):
     nullable_fields = ("description",)
 
 
+class ImportProfileFilterForm(NetBoxModelFilterSetForm):
+    """Filters tab of the Import Profile list."""
+
+    model = ImportProfile
+    fieldsets = (
+        FieldSet("q", "filter_id", "tag"),
+        FieldSet("source_adapter", name="Attributes"),
+    )
+    source_adapter = forms.ChoiceField(choices=lambda: add_blank_choice(adapter_choices()), required=False)
+    tag = TagFilterField(model)
+
+
 class ColumnMappingForm(forms.ModelForm):
     """Form for creating and editing ColumnMapping instances."""
 
@@ -381,6 +395,20 @@ class InferenceBackendForm(NetBoxModelForm):
         }
 
 
+class InferenceBackendFilterForm(NetBoxModelFilterSetForm):
+    """Filters tab of the AI backend list."""
+
+    model = InferenceBackend
+    fieldsets = (
+        FieldSet("q", "filter_id", "tag"),
+        FieldSet("adapter_type", "response_mode", "enabled", name="Attributes"),
+    )
+    adapter_type = forms.ChoiceField(choices=add_blank_choice(InferenceBackend.ADAPTER_TYPES), required=False)
+    response_mode = forms.ChoiceField(choices=add_blank_choice(InferenceBackend.RESPONSE_MODES), required=False)
+    enabled = forms.NullBooleanField(required=False, widget=forms.Select(choices=BOOLEAN_WITH_BLANK_CHOICES))
+    tag = TagFilterField(model)
+
+
 class ImportSetupForm(forms.Form):
     """Form for the import wizard step 1: select profile, upload file, choose site/location/tenant."""
 

{netbox_data_import-2.6.0 → netbox_data_import-2.7.0}/netbox_data_import/graphql/schema.py

@@ -5,24 +5,38 @@
 
 import strawberry
 import strawberry_django
+from strawberry.permission import BasePermission
+
+from netbox_data_import import branching
 
 from .types import CableClassMappingType, ImportProfileType
 
 
+class MainOnly(BasePermission):
+    """Refuse a plugin field on the same terms as the plugin's REST and UI views."""
+
+    def has_permission(self, source, info, **kwargs) -> bool:
+        """Raise BranchActive, whose message becomes the GraphQL error, for a refused request."""
+        message = branching.request_refusal(info.context.request)
+        if message is not None:
+            raise branching.BranchActive(message)
+        return True
+
+
 @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()
+    import_profile: ImportProfileType = strawberry_django.field(permission_classes=[MainOnly])
+    import_profile_list: list[ImportProfileType] = strawberry_django.field(permission_classes=[MainOnly])
 
 
 @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()
+    cable_class_mapping: CableClassMappingType = strawberry_django.field(permission_classes=[MainOnly])
+    cable_class_mapping_list: list[CableClassMappingType] = strawberry_django.field(permission_classes=[MainOnly])
 
 
 schema = [ImportProfilesQuery, CableClassMappingsQuery]

{netbox_data_import-2.6.0 → netbox_data_import-2.7.0}/netbox_data_import/import_engine.py

@@ -15,7 +15,7 @@ from typing import cast
 from django.core.exceptions import ValidationError
 from django.db import DatabaseError
 
-from . import adapter_config, adapters, catalog, target_modules
+from . import adapter_config, adapters, branching, catalog, target_modules
 from .models import FailureReason, ImportExecution, SourceDocument, locked_profile_policy
 from .netbox_reader import NetBoxReader, PlanningTargetUnavailable
 from .object_permissions import ObjectPermissionDenied, clear_user_permission_caches
@@ -159,6 +159,7 @@ class ImportEngine:
         progress_callback=None,
     ) -> ImportExecution:
         """Apply selected units from one accepted serialized plan and return their audit row."""
+        branching.refuse_branch()
         accepted = ImportPlan.from_dict(accepted_plan)
         selected_identities = tuple(selection)
         if not selected_identities:

{netbox_data_import-2.6.0 → netbox_data_import-2.7.0}/netbox_data_import/ip_assignment.py

@@ -284,6 +284,8 @@ def apply(target: IPTarget, user=None):
     action = "change" if address is not None else "add"
     if address is None:
         address = IPAddress(address=target.address, vrf=target.interface.vrf)
+    else:
+        address.snapshot()
     address.assigned_object = target.interface
     address.full_clean()
     address.save()