forward-netbox 2.0.0__tar.gz → 2.0.2__tar.gz

{forward_netbox-2.0.0 → forward_netbox-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forward-netbox
-Version: 2.0.0
+Version: 2.0.2
 Summary: NetBox plugin to sync Forward data into NetBox via built-in NQE queries
 License: MIT
 License-File: LICENSE
@@ -31,7 +31,9 @@ Forward 26.6 is the baseline for async NQE.
 
 | Plugin Release | NetBox Version | Status |
 | --- | --- | --- |
-| `v2.0.0` | `4.6.3` required; needs netbox-branching `1.1.0+` | Current release; Breaking 2.0 — single-branch is the only execution path. Removed the per-shard branching/fast-bootstrap/resumable executor, 10k-change budget sharding, and the execution-ledger run-history; dropped the backend/max-changes/scheduler-overlap selectors |
+| `v2.0.2` | `4.6.3` required; needs netbox-branching `1.1.0+` | Current release; Patch: apply_device_scope_tags now works with multiple include tags in `any` match mode — each device is tagged with exactly the include tag(s) it carries (resolved per-device at fetch time), instead of skipping. Also silences the spurious `Skipping untagged VLAN 1` warning (VID 1 is NetBox's implicit access default and is intentionally not imported). No engine/schema changes; drop-in from `2.0.1`, no org republish |
+| `v2.0.1` | `4.6.3` required; needs netbox-branching `1.1.0+` | Superseded by `v2.0.2`; Patch: fixes two 2.0.0 regressions an operator hits immediately — a false `netbox_branching is not installed; syncs will fail` startup warning (the dependency check used the wrong distribution name), and a 500 on the Sync list page (`KeyError: 'available'` from a removed execution-ledger summary). No engine or data changes; drop-in upgrade from `2.0.0` |
+| `v2.0.0` | `4.6.3` required; needs netbox-branching `1.1.0+` | Superseded by `v2.0.1`; Breaking 2.0 — single-branch is the only execution path. Removed the per-shard branching/fast-bootstrap/resumable executor, 10k-change budget sharding, and the execution-ledger run-history; dropped the backend/max-changes/scheduler-overlap selectors |
 | `v1.7.2` | `4.6.3` required (4.5.x dropped); needs netbox-branching `1.1.0+` | Superseded by `v2.0.0`; Collection-gap diagnostics: per-reason backfill breakdown + staleness, growth/trend escalation, per-device collection result, ACI delete safety valve, opt-in auto-tag |
 | `v1.7.1` | `4.5.9` and `4.6.2` validated; shared branch for `4.5.x` and `4.6.x` with capability-gated 4.6 features | Superseded by `v1.7.2`; ACI BD/L3Out graduation + FHRP churn fix (replaces yanked 1.7.0 and 1.6.2) |
 | `v1.7.0` | `4.5.9` and `4.6.2` validated; shared branch for `4.5.x` and `4.6.x` with capability-gated 4.6 features | Superseded by `v1.7.1`; ACI bridge domain and L3Out NQE maps; query publish hardening |

{forward_netbox-2.0.0 → forward_netbox-2.0.2}/README.md

@@ -8,7 +8,9 @@ Forward 26.6 is the baseline for async NQE.
 
 | Plugin Release | NetBox Version | Status |
 | --- | --- | --- |
-| `v2.0.0` | `4.6.3` required; needs netbox-branching `1.1.0+` | Current release; Breaking 2.0 — single-branch is the only execution path. Removed the per-shard branching/fast-bootstrap/resumable executor, 10k-change budget sharding, and the execution-ledger run-history; dropped the backend/max-changes/scheduler-overlap selectors |
+| `v2.0.2` | `4.6.3` required; needs netbox-branching `1.1.0+` | Current release; Patch: apply_device_scope_tags now works with multiple include tags in `any` match mode — each device is tagged with exactly the include tag(s) it carries (resolved per-device at fetch time), instead of skipping. Also silences the spurious `Skipping untagged VLAN 1` warning (VID 1 is NetBox's implicit access default and is intentionally not imported). No engine/schema changes; drop-in from `2.0.1`, no org republish |
+| `v2.0.1` | `4.6.3` required; needs netbox-branching `1.1.0+` | Superseded by `v2.0.2`; Patch: fixes two 2.0.0 regressions an operator hits immediately — a false `netbox_branching is not installed; syncs will fail` startup warning (the dependency check used the wrong distribution name), and a 500 on the Sync list page (`KeyError: 'available'` from a removed execution-ledger summary). No engine or data changes; drop-in upgrade from `2.0.0` |
+| `v2.0.0` | `4.6.3` required; needs netbox-branching `1.1.0+` | Superseded by `v2.0.1`; Breaking 2.0 — single-branch is the only execution path. Removed the per-shard branching/fast-bootstrap/resumable executor, 10k-change budget sharding, and the execution-ledger run-history; dropped the backend/max-changes/scheduler-overlap selectors |
 | `v1.7.2` | `4.6.3` required (4.5.x dropped); needs netbox-branching `1.1.0+` | Superseded by `v2.0.0`; Collection-gap diagnostics: per-reason backfill breakdown + staleness, growth/trend escalation, per-device collection result, ACI delete safety valve, opt-in auto-tag |
 | `v1.7.1` | `4.5.9` and `4.6.2` validated; shared branch for `4.5.x` and `4.6.x` with capability-gated 4.6 features | Superseded by `v1.7.2`; ACI BD/L3Out graduation + FHRP churn fix (replaces yanked 1.7.0 and 1.6.2) |
 | `v1.7.0` | `4.5.9` and `4.6.2` validated; shared branch for `4.5.x` and `4.6.x` with capability-gated 4.6 features | Superseded by `v1.7.1`; ACI bridge domain and L3Out NQE maps; query publish hardening |

forward_netbox-2.0.2/forward_netbox/__init__.py

@@ -0,0 +1,115 @@
+try:
+    from netbox.plugins import PluginConfig
+except ModuleNotFoundError:  # pragma: no cover - tooling imports outside NetBox
+    PluginConfig = object
+
+
+class NetboxForwardConfig(PluginConfig):
+    name = "forward_netbox"
+    verbose_name = "NetBox Forward Plugin"
+    description = "Sync Forward data into NetBox using built-in NQE queries."
+    version = "2.0.2"
+    base_url = "forward"
+    min_version = "4.6.3"
+
+    def ready(self):
+        super().ready()
+        from . import signals  # noqa: F401
+
+        _check_runtime_dependencies()
+
+
+def _check_runtime_dependencies():
+    """Warn at startup about a missing/old ``netbox_branching`` dependency.
+
+    The single-branch ingest path hard-depends on netbox-branching 1.1.0
+    internals (SquashMergeStrategy collapse/cycle-split/FK-graph, the
+    squash_dependency_graph_built signal, branch.connection_name, the
+    ObjectChange read router). A missing or pre-1.1.0 install otherwise only
+    surfaces mid-sync as an opaque failure. This logs (never raises) so NetBox
+    startup is unaffected.
+
+    "Installed and enabled" is tested by IMPORTABILITY, not the distribution
+    name: NetBox only loads the module when it is listed in PLUGINS, and the
+    PyPI distribution is ``netboxlabs-netbox-branching`` (not the import name
+    ``netbox_branching``), so keying the check off a single dist name produced a
+    false "not installed" warning on every boot even when it was active.
+    """
+    import logging
+
+    log = logging.getLogger("forward_netbox")
+    floor = (1, 1, 0)
+    label = "netbox_branching"
+
+    try:
+        import netbox_branching  # noqa: F401
+    except Exception:
+        log.warning(
+            "forward_netbox requires the %s plugin for branch-staged syncs, but "
+            "it is not installed/enabled; syncs will fail. Install "
+            "netboxlabs-netbox-branching (>=1.1.0), add 'netbox_branching' to "
+            "PLUGINS in configuration.py, and run migrations.",
+            label,
+        )
+        return
+
+    resolved = _resolved_branching_version()
+    if resolved is None:
+        # Installed/importable but the version could not be resolved (unusual
+        # packaging). Do not cry wolf — the import succeeded, so syncs can run.
+        log.info("forward_netbox runtime dependency %s installed", label)
+        return
+
+    log.info("forward_netbox runtime dependency %s==%s", label, resolved)
+    if _version_tuple(resolved) < floor:
+        log.warning(
+            "forward_netbox requires %s>=%s but found %s; syncs will fail (the "
+            "plugin reuses netbox-branching 1.1.0 internals). Upgrade "
+            "netboxlabs-netbox-branching.",
+            label,
+            ".".join(str(part) for part in floor),
+            resolved,
+        )
+
+
+def _resolved_branching_version():
+    """Best-effort netbox-branching version, robust to the distribution name.
+
+    The PyPI distribution is ``netboxlabs-netbox-branching``; older/forks may use
+    ``netbox-branching``. Fall back to the module's ``__version__``.
+    """
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version
+
+    for dist in ("netboxlabs-netbox-branching", "netbox-branching"):
+        try:
+            return version(dist)
+        except PackageNotFoundError:
+            continue
+        except Exception:  # pragma: no cover - never block startup
+            return None
+    try:
+        import netbox_branching
+
+        return getattr(netbox_branching, "__version__", None)
+    except Exception:  # pragma: no cover - never block startup
+        return None
+
+
+def _version_tuple(value):
+    """Best-effort (major, minor, patch) tuple from a version string."""
+    parts = []
+    for chunk in str(value).split(".")[:3]:
+        digits = ""
+        for char in chunk:
+            if char.isdigit():
+                digits += char
+            else:
+                break
+        parts.append(int(digits) if digits else 0)
+    while len(parts) < 3:
+        parts.append(0)
+    return tuple(parts)
+
+
+config = NetboxForwardConfig

{forward_netbox-2.0.0 → forward_netbox-2.0.2}/forward_netbox/tables.py

@@ -16,8 +16,6 @@ from .models import ForwardNQEMap
 from .models import ForwardSource
 from .models import ForwardSync
 from .models import ForwardValidationRun
-from .utilities.execution_ledger import execution_run_failure_summary
-from .utilities.execution_ledger import latest_execution_run
 from .utilities.json_safe import json_safe_value
 
 
@@ -90,13 +88,15 @@ class ForwardSyncTable(NetBoxTable):
         return getattr(value, "name", "---") if value else "---"
 
     def render_latest_failure(self, value, record):
-        summary = execution_run_failure_summary(latest_execution_run(record))
-        if not summary["available"]:
+        # 2.0 removed the execution-run ledger; surface the latest ingestion's
+        # failed-change count (the always-populated 2.0 failure signal) instead.
+        ingestion = record.forwardingestion_set.last()
+        failed = getattr(ingestion, "failed_change_count", 0) or 0
+        if not failed:
             return "---"
         return format_html(
-            '<span title="{}">{}</span>',
-            summary["error"],
-            summary["message"],
+            '<span class="text-danger">{}</span>',
+            _("{n} failed change(s)").format(n=failed),
         )
 
     class Meta(NetBoxTable.Meta):

forward_netbox-2.0.2/forward_netbox/tests/test_device_scope_tagging.py

@@ -0,0 +1,167 @@
+from unittest.mock import Mock
+
+from dcim.models import Device
+from django.test import TestCase
+from extras.models import Tag
+
+from forward_netbox.models import ForwardSource
+from forward_netbox.models import ForwardSync
+from forward_netbox.utilities.sync import ForwardSyncRunner
+from forward_netbox.utilities.sync_device import apply_dcim_device
+
+
+class DeviceScopeTaggingTest(TestCase):
+    """apply_device_scope_tags tags each device with exactly the include tags it
+    carries. The per-device matched-tag map is resolved at fetch time and set on
+    the runner (runner._scope_matched_tags) by the executor."""
+
+    def _source(
+        self, *, apply_scope_tags, include_tags=("N.Patel",), include_match="any"
+    ):
+        return ForwardSource.objects.create(
+            name=f"scope-src-{ForwardSource.objects.count()}",
+            type="saas",
+            url="https://fwd.app",
+            status="ready",
+            parameters={
+                "username": "u@example.com",
+                "password": "p",
+                "verify": True,
+                "network_id": "net-1",
+                "device_tag_include_tags": list(include_tags),
+                "device_tag_include_match": include_match,
+                "apply_device_scope_tags": apply_scope_tags,
+            },
+        )
+
+    def _sync(self, source):
+        return ForwardSync.objects.create(
+            name=f"scope-sync-{source.pk}",
+            source=source,
+            parameters={"snapshot_id": "latestProcessed"},
+        )
+
+    def _runner(self, sync, matched=None):
+        runner = ForwardSyncRunner(
+            sync=sync, ingestion=None, client=None, logger_=Mock()
+        )
+        runner._scope_matched_tags = dict(matched or {})
+        return runner
+
+    def _row(self, name="dev-1"):
+        return {
+            "name": name,
+            "site": "site-a",
+            "site_slug": "site-a",
+            "role": "role-a",
+            "role_slug": "role-a",
+            "role_color": "9e9e9e",
+            "manufacturer": "Cisco",
+            "manufacturer_slug": "cisco",
+            "device_type": "model-a",
+            "device_type_slug": "model-a",
+            "platform": "",
+            "platform_slug": "",
+            "status": "active",
+        }
+
+    def test_scope_tag_applied_when_enabled(self):
+        sync = self._sync(self._source(apply_scope_tags=True))
+        runner = self._runner(sync, matched={"dev-1": ["N.Patel"]})
+        apply_dcim_device(runner, self._row())
+
+        device = Device.objects.get(name="dev-1")
+        self.assertEqual(
+            sorted(device.tags.values_list("name", flat=True)), ["N.Patel"]
+        )
+        self.assertEqual(Tag.objects.filter(name="N.Patel").count(), 1)
+
+    def test_scope_tag_not_applied_when_disabled(self):
+        sync = self._sync(self._source(apply_scope_tags=False))
+        runner = self._runner(sync, matched={"dev-1": ["N.Patel"]})
+        apply_dcim_device(runner, self._row())
+
+        device = Device.objects.get(name="dev-1")
+        self.assertEqual(list(device.tags.all()), [])
+        self.assertFalse(Tag.objects.filter(name="N.Patel").exists())
+
+    def test_reapply_does_not_duplicate_tag(self):
+        sync = self._sync(self._source(apply_scope_tags=True))
+        apply_dcim_device(self._runner(sync, {"dev-1": ["N.Patel"]}), self._row())
+        # Fresh runner (cleared caches) re-applies the same device -> idempotent.
+        apply_dcim_device(self._runner(sync, {"dev-1": ["N.Patel"]}), self._row())
+
+        device = Device.objects.get(name="dev-1")
+        self.assertEqual(device.tags.filter(name="N.Patel").count(), 1)
+
+    def test_multi_tag_any_applies_only_carried_tags(self):
+        # The previously-skipped case: multiple include tags, "any" mode. The
+        # device carries only TagA, so it gets only TagA — never TagB.
+        sync = self._sync(
+            self._source(
+                apply_scope_tags=True,
+                include_tags=["TagA", "TagB"],
+                include_match="any",
+            )
+        )
+        runner = self._runner(sync, matched={"dev-1": ["TagA"]})
+        apply_dcim_device(runner, self._row())
+
+        device = Device.objects.get(name="dev-1")
+        self.assertEqual(sorted(device.tags.values_list("name", flat=True)), ["TagA"])
+        self.assertFalse(device.tags.filter(name="TagB").exists())
+
+    def test_multi_tag_all_mode_applies_all(self):
+        # "all" mode: every in-scope device carries every include tag (the
+        # resolver yields the full set), so all are applied — identical to before.
+        sync = self._sync(
+            self._source(
+                apply_scope_tags=True,
+                include_tags=["TagA", "TagB"],
+                include_match="all",
+            )
+        )
+        runner = self._runner(sync, matched={"dev-1": ["TagA", "TagB"]})
+        apply_dcim_device(runner, self._row())
+
+        device = Device.objects.get(name="dev-1")
+        self.assertEqual(
+            sorted(device.tags.values_list("name", flat=True)), ["TagA", "TagB"]
+        )
+
+    def test_stale_scope_tag_removed_user_tag_preserved(self):
+        # A device that drops a Forward include tag between syncs loses the
+        # corresponding scope tag, but unrelated (user/feature) tags are kept.
+        sync = self._sync(
+            self._source(
+                apply_scope_tags=True,
+                include_tags=["TagA", "TagB"],
+                include_match="any",
+            )
+        )
+        apply_dcim_device(self._runner(sync, {"dev-1": ["TagA", "TagB"]}), self._row())
+        device = Device.objects.get(name="dev-1")
+        user_tag, _ = Tag.objects.get_or_create(name="owner-x", slug="owner-x")
+        device.tags.add(user_tag)
+        self.assertEqual(
+            sorted(device.tags.values_list("name", flat=True)),
+            ["TagA", "TagB", "owner-x"],
+        )
+
+        # Re-sync: device now carries only TagA.
+        apply_dcim_device(self._runner(sync, {"dev-1": ["TagA"]}), self._row())
+        device.refresh_from_db()
+        self.assertEqual(
+            sorted(device.tags.values_list("name", flat=True)),
+            ["TagA", "owner-x"],
+        )
+
+    def test_unmatched_device_gets_no_scope_tags(self):
+        # A device absent from the matched map (e.g. exclude-only scope) is left
+        # untagged and does not crash.
+        sync = self._sync(self._source(apply_scope_tags=True))
+        runner = self._runner(sync, matched={})
+        apply_dcim_device(runner, self._row())
+
+        device = Device.objects.get(name="dev-1")
+        self.assertEqual(list(device.tags.all()), [])

{forward_netbox-2.0.0 → forward_netbox-2.0.2}/forward_netbox/tests/test_models.py

@@ -1591,6 +1591,23 @@ class ForwardSyncModelTest(TestCase):
     def test_sync_table_shows_scheduled_by_default(self):
         self.assertIn("scheduled", ForwardSyncTable.Meta.default_columns)
 
+    def test_sync_table_latest_failure_renders_without_ledger(self):
+        # Regression: render_latest_failure called the removed execution-ledger
+        # stubs and indexed summary["available"] -> KeyError, 500'ing the sync
+        # list page in 2.0. It must render from the ingestion's failed-change
+        # count and never crash.
+        from forward_netbox.models import ForwardIngestion
+
+        sync = ForwardSync.objects.create(name="lf-sync", source=self.source)
+        table = ForwardSyncTable(ForwardSync.objects.filter(pk=sync.pk))
+        # No ingestion -> graceful dash.
+        self.assertEqual(table.render_latest_failure(value=None, record=sync), "---")
+        # Failed changes -> surfaced count, still no crash.
+        ForwardIngestion.objects.create(sync=sync, failed_change_count=3)
+        rendered = str(table.render_latest_failure(value=None, record=sync))
+        self.assertIn("3", rendered)
+        self.assertNotIn("available", rendered)
+
     @patch("forward_netbox.models.ForwardSource.get_client")
     @patch(
         "forward_netbox.utilities.single_branch_executor.ForwardSingleBranchExecutor"

forward_netbox-2.0.2/forward_netbox/tests/test_runtime_dependency_check.py

@@ -0,0 +1,59 @@
+import logging
+from unittest.mock import patch
+
+from django.test import SimpleTestCase
+
+from forward_netbox import _check_runtime_dependencies
+from forward_netbox import _resolved_branching_version
+
+
+class RuntimeDependencyCheckTest(SimpleTestCase):
+    """Guards the netbox_branching startup dependency check.
+
+    Regression: the check keyed off the distribution name ``netbox-branching``,
+    but the PyPI distribution is ``netboxlabs-netbox-branching`` — so
+    importlib.metadata.version() always raised PackageNotFoundError and the
+    plugin logged a false "netbox_branching is not installed; syncs will fail"
+    warning on EVERY boot, even when branching was installed and active.
+    """
+
+    def _capture(self):
+        logger = logging.getLogger("forward_netbox")
+        with self.assertLogs(logger, level="INFO") as cm:
+            _check_runtime_dependencies()
+        return "\n".join(cm.output)
+
+    def test_resolves_version_by_correct_distribution_name(self):
+        # netbox-branching is installed as the netboxlabs-netbox-branching dist.
+        self.assertIsNotNone(_resolved_branching_version())
+
+    def test_no_false_not_installed_warning_when_installed(self):
+        out = self._capture()
+        self.assertNotIn("not installed", out)
+        self.assertNotIn("syncs will fail", out)
+
+    def test_warns_when_below_floor(self):
+        with patch("forward_netbox._resolved_branching_version", return_value="1.0.4"):
+            out = self._capture()
+        self.assertIn("netbox_branching>=1.1.0", out)
+        self.assertIn("syncs will fail", out)
+
+    def test_warns_when_not_importable(self):
+        real_import = (
+            __builtins__["__import__"]
+            if isinstance(__builtins__, dict)
+            else __builtins__.__import__
+        )
+
+        def fake_import(name, *args, **kwargs):
+            if name == "netbox_branching":
+                raise ImportError("simulated missing plugin")
+            return real_import(name, *args, **kwargs)
+
+        logger = logging.getLogger("forward_netbox")
+        with patch("builtins.__import__", side_effect=fake_import):
+            with self.assertLogs(logger, level="WARNING") as cm:
+                _check_runtime_dependencies()
+        out = "\n".join(cm.output)
+        self.assertIn("not installed/enabled", out)
+        self.assertIn("PLUGINS", out)

forward_netbox-2.0.2/forward_netbox/tests/test_scope_matched_tags.py

@@ -0,0 +1,80 @@
+from unittest.mock import Mock
+
+from django.test import TestCase
+
+from forward_netbox.models import ForwardSource
+from forward_netbox.models import ForwardSync
+from forward_netbox.utilities.query_fetch import ForwardQueryContext
+from forward_netbox.utilities.query_fetch_execution import ForwardQueryFetcher
+
+
+class ScopeMatchedTagsResolveTest(TestCase):
+    """The inline scope resolver returns, per in-scope device, exactly the
+    include tags that device carries (the apply_device_scope_tags per-device map),
+    intersected at resolve time so the persisted payload stays small."""
+
+    def _fetcher(self, client):
+        source = ForwardSource.objects.create(
+            name=f"smt-src-{ForwardSource.objects.count()}",
+            type="saas",
+            url="https://fwd.app",
+            status="ready",
+            parameters={
+                "username": "u",
+                "password": "p",
+                "verify": True,
+                "network_id": "net-1",
+            },
+        )
+        sync = ForwardSync.objects.create(
+            name=f"smt-sync-{source.pk}",
+            source=source,
+            parameters={"snapshot_id": "latestProcessed"},
+        )
+        return ForwardQueryFetcher(sync=sync, client=client, logger_=Mock())
+
+    def test_resolve_returns_per_device_intersection(self):
+        client = Mock()
+        client.run_nqe_query.return_value = [
+            {"name": "d1", "site": "s", "tagNames": ["TagA", "TagX"]},
+            {"name": "d2", "site": "s", "tagNames": ["TagB"]},
+            {"name": "d3", "site": "s", "tagNames": ["TagA", "TagB"]},
+            {"name": "d4", "site": "s", "tagNames": ["TagX"]},
+        ]
+        names, sites, matched = self._fetcher(client)._resolve_scoped_tag_scope(
+            network_id="net-1",
+            snapshot_id="snap",
+            include_tags=["TagA", "TagB"],
+            exclude_tags=[],
+            include_match="any",
+        )
+        self.assertEqual(
+            matched, {"d1": ["TagA"], "d2": ["TagB"], "d3": ["TagA", "TagB"]}
+        )
+        # d4 carries none of the include tags -> not in the map (no tagging).
+        self.assertNotIn("d4", matched)
+        # The query must request tagNames.
+        query = client.run_nqe_query.call_args.kwargs["query"]
+        self.assertIn("tagNames: device.tagNames", query)
+
+    def test_resolve_no_tags_returns_empty_map(self):
+        result = self._fetcher(Mock())._resolve_scoped_tag_scope(
+            network_id="net-1",
+            snapshot_id="snap",
+            include_tags=[],
+            exclude_tags=[],
+            include_match="any",
+        )
+        self.assertEqual(result, (set(), set(), {}))
+
+    def test_context_as_dict_carries_full_matched_map(self):
+        ctx = ForwardQueryContext(
+            network_id="net-1",
+            snapshot_selector="latestProcessed",
+            snapshot_id="snap",
+            scoped_matched_tags={"d1": ["TagA"], "d2": ["TagB"]},
+        )
+        # The branch apply path reads this back — it must be the full map, not a count.
+        self.assertEqual(
+            ctx.as_dict()["scoped_matched_tags"], {"d1": ["TagA"], "d2": ["TagB"]}
+        )

{forward_netbox-2.0.0 → forward_netbox-2.0.2}/forward_netbox/utilities/apply_engine_bulk.py

@@ -1105,7 +1105,7 @@ def bulk_orm_apply_device(runner, rows: list[dict[str, Any]]):
 
     from ..exceptions import ForwardDependencySkipError
     from ..exceptions import ForwardSearchError
-    from .sync_device import _scope_tags
+    from .sync_device import _scope_tags_enabled
     from .sync_device import apply_dcim_device
 
     update_field_names = ["site", "role", "device_type", "platform", "serial", "status"]
@@ -1138,7 +1138,7 @@ def bulk_orm_apply_device(runner, rows: list[dict[str, Any]]):
 
     # Opt-in per-device scope tagging is an adapter side effect; keep exact parity
     # by delegating the whole batch when it is enabled.
-    if _scope_tags(runner):
+    if _scope_tags_enabled(runner):
         for row in rows:
             _delegate(row)
         runner.events_clearer.clear()

{forward_netbox-2.0.0 → forward_netbox-2.0.2}/forward_netbox/utilities/multi_branch_lifecycle.py

@@ -85,6 +85,11 @@ def run_item_in_branch(executor, item, context, ingestion, branch, *, total_plan
         logger_=executor.logger,
     )
     runner._model_coalesce_fields[item.model_string] = item.coalesce_fields
+    # Per-device scope-tag map resolved at fetch time (apply_device_scope_tags);
+    # without this, branched syncs would tag nothing.
+    runner._scope_matched_tags = {
+        str(k): list(v) for k, v in (context.get("scoped_matched_tags") or {}).items()
+    }
     ingestion.snapshot_selector = context["snapshot_selector"]
     ingestion.snapshot_id = context["snapshot_id"]
     ingestion.snapshot_info = context["snapshot_info"]