ipfabric_netbox 4.3.2b10__py3-none-any.whl → 4.3.2b11__py3-none-any.whl

ipfabric_netbox/utilities/ipfutils.py

@@ -14,7 +14,12 @@ from dcim.models import Device
 from dcim.models import Site
 from dcim.models import VirtualChassis
 from dcim.signals import assign_virtualchassis_master
-from dcim.signals import sync_cached_scope_fields
+
+try:
+    # Got added in NetBox 4.4.9
+    from dcim.signals import sync_cached_scope_fields
+except ImportError:
+    sync_cached_scope_fields = None
 from django.conf import settings
 from django.core.exceptions import MultipleObjectsReturned
 from django.core.exceptions import ObjectDoesNotExist
@@ -224,8 +229,11 @@ class DataRecord:
         self._hash = None  # Invalidate cached hash
 
 
-def order_members(members: list[dict]) -> dict[str, list[dict]]:
-    """Order VC members to dict, where key is master serial number and values are all members."""
+def order_members(members: list[dict], sn_column: str) -> dict[str, list[dict]]:
+    """Order stack members to dict, where key is master serial number and values are all members.
+    For stack members table we get `memberSn` column for member serial number.
+    For VSS chassis table we get `chassisSn` column for member serial number.
+    """
     devices = {}
 
     for member in members:
@@ -233,7 +241,7 @@ def order_members(members: list[dict]) -> dict[str, list[dict]]:
         # This can be spotted by checking if `sn` is different from `memberSn` for the master device
         # Plus `sn` will be IP of loopback in hex...
         master_serial = member.get("sn")
-        if master_serial and member.get("memberSn"):
+        if master_serial and member.get(sn_column):
             if master_serial in devices:
                 devices[master_serial].append(member)
             else:
@@ -265,17 +273,20 @@ def prepare_devices(
         if child_members := members.get(device.get("sn")):
             # This device is the VC master, and we're iterating over all it's members
             for child_member in child_members:
+                member_id = child_member.get("member") or child_member.get("chassisId")
+                member_sn = child_member.get("memberSn") or child_member.get(
+                    "chassisSn"
+                )
                 # There is physically no device with hostname matching the virtual chassis
                 # There are only members, so "hostname/1", "hostname/2", etc.
                 new_device = deepcopy(device)
-                new_device[
-                    "hostname"
-                ] = f"{device['hostname']}/{child_member.get('member')}"
+                new_device["hostname"] = f"{device['hostname']}/{member_id}"
                 new_device["virtual_chassis"] = child_member
-                if device.get("sn") != child_member.get("memberSn"):
+                if device.get("sn") != member_sn:
                     # VC members (non-master) are not in Device table, need to add them as new Device
-                    new_device["model"] = child_member.get("pn")
-                    new_device["sn"] = child_member.get("memberSn")
+                    # VSS Chassis have no model in the table, get it from master device
+                    new_device["model"] = child_member.get("pn") or device["model"]
+                    new_device["sn"] = member_sn
                     all_devices.append(new_device)
                 else:
                     # Master device, create the virtual chassis based on it
@@ -577,7 +588,16 @@ class IPFabricSyncRunner(object):
                     enabled_models.append("dcim.interface")
                 transform_maps = self.sync.get_transform_maps()
                 for endpoint in IPFabricEndpoint.objects.all():
-                    tms_for_endpoint = transform_maps.filter(source_endpoint=endpoint)
+                    # FIXME: Dirty hack to sync VSS, remove when IN-68 is getting done
+                    if endpoint.endpoint == "/technology/platforms/vss/chassis":
+                        tms_for_endpoint = transform_maps.filter(
+                            source_endpoint__endpoint="/technology/platforms/stack/members"
+                        )
+                    else:
+                        tms_for_endpoint = transform_maps.filter(
+                            source_endpoint=endpoint
+                        )
+
                     if not tms_for_endpoint.exists():
                         raise SyncError(
                             f"No transform map found for endpoint `{endpoint.endpoint}`."
@@ -612,30 +632,46 @@ class IPFabricSyncRunner(object):
         return data
 
     @cache
-    def get_transform_map(self, app: str, model: str) -> "IPFabricTransformMap":
+    def get_transform_map(
+        self, app: str, model: str, endpoint: str = None
+    ) -> "IPFabricTransformMap":
         """Get transform map for given app and model. Cached to improve performance."""
-        return self.transform_maps.get(
-            target_model__app_label=app, target_model__model=model
-        )
+        filter_kwargs = {
+            "target_model__app_label": app,
+            "target_model__model": model,
+        }
+        if endpoint:
+            filter_kwargs["source_endpoint__endpoint"] = endpoint
+        return self.transform_maps.get(**filter_kwargs)
 
     def create_new_data_records(
-        self, app: str, model: str, data: list[dict] | dict[str, list[dict]]
+        self,
+        app: str,
+        model: str,
+        data: list[dict] | dict[str, list[dict]],
+        endpoint: str = None,
     ) -> set[DataRecord]:
         """Create DataRecord objects for given app, model and data list if enabled in settings."""
         if not self.sync.parameters.get(f"{app}.{model}"):
             return set()
         if isinstance(data, dict):
             # Data is either already list or full data where we have to choose the list
-            transform_map = self.get_transform_map(app=app, model=model)
+            transform_map = self.get_transform_map(
+                app=app, model=model, endpoint=endpoint
+            )
             data = data.get(transform_map.source_endpoint.endpoint, [])
         return set(
-            self.create_new_data_record(app=app, model=model, data=item)
+            self.create_new_data_record(
+                app=app, model=model, data=item, endpoint=endpoint
+            )
             for item in data
         )
 
-    def create_new_data_record(self, app: str, model: str, data: dict) -> DataRecord:
+    def create_new_data_record(
+        self, app: str, model: str, data: dict, endpoint: str = None
+    ) -> DataRecord:
         """Extract only relevant source data according to transform map configuration."""
-        transform_map = self.get_transform_map(app=app, model=model)
+        transform_map = self.get_transform_map(app=app, model=model, endpoint=endpoint)
         model_string = f"{app}.{model}"
         try:
             source_data = transform_map.strip_source_data(data)
@@ -647,66 +683,75 @@ class IPFabricSyncRunner(object):
             model_string=model_string, data=source_data, transform_map=transform_map
         )
 
-    def preprocess_data(self, data: dict) -> dict[str, set[DataRecord]]:
-        # Set those records that can't be iterated separately
-        # Others are as empty set to define order which is shown in UI progress
-        records = {
-            "dcim.site": self.create_new_data_records(
-                app="dcim", model="site", data=data
-            ),
-            "dcim.manufacturer": set(),
-            "dcim.devicetype": set(),
-            "dcim.platform": set(),
-            "dcim.devicerole": set(),
-            "dcim.device": set(),
-            "dcim.virtualchassis": set(),
-            "dcim.interface": set(),
-            "dcim.macaddress": set(),
-            "dcim.inventoryitem": self.create_new_data_records(
-                app="dcim",
-                model="inventoryitem",
-                data=data,
-            ),
-            "ipam.vlan": self.create_new_data_records(
-                app="ipam",
-                model="vlan",
-                data=data,
-            ),
-            "ipam.vrf": self.create_new_data_records(
-                app="ipam",
-                model="vrf",
-                data=data,
-            ),
-            "ipam.prefix": self.create_new_data_records(
-                app="ipam",
-                model="prefix",
-                data=data,
-            ),
-            "ipam.ipaddress": set(),
+    def _get_custom_preprocessor(
+        self, model_string: str, endpoint: str
+    ) -> Callable | None:
+        """
+        Get custom preprocessing function for a model+endpoint combination if one exists.
+
+        Args:
+            model_string: The model in 'app.model' format (e.g., 'dcim.virtualchassis')
+            endpoint: The source endpoint (e.g., '/technology/platforms/stack/members')
+
+        Returns:
+            Callable preprocessor function or None if no custom preprocessor exists
+        """
+        preprocessors = {
+            # Devices and related models processed together (from /inventory/devices)
+            ("dcim.device", "/inventory/devices"): self._preprocess_devices,
+            ("dcim.manufacturer", "/inventory/devices"): self._preprocess_devices,
+            ("dcim.devicetype", "/inventory/devices"): self._preprocess_devices,
+            ("dcim.platform", "/inventory/devices"): self._preprocess_devices,
+            ("dcim.devicerole", "/inventory/devices"): self._preprocess_devices,
+            # Virtual chassis from stack members
+            (
+                "dcim.virtualchassis",
+                "/technology/platforms/stack/members",
+            ): self._preprocess_devices,
+            # Interfaces and MAC addresses processed together
+            ("dcim.interface", "/inventory/interfaces"): self._preprocess_interfaces,
+            ("dcim.macaddress", "/inventory/interfaces"): self._preprocess_interfaces,
+            # IP addresses need interface data
+            (
+                "ipam.ipaddress",
+                "/technology/addressing/managed-ip/ipv4",
+            ): self._preprocess_ipaddresses,
         }
 
-        if self.sync.parameters.get("dcim.virtualchassis"):
-            self.logger.log_info("Preparing virtual chassis members", obj=self.sync)
-            members = order_members(data.get("/technology/platforms/stack/members", []))
-        else:
-            members = []
+        return preprocessors.get((model_string, endpoint))
 
-        if self.sync.parameters.get("dcim.device") or self.sync.parameters.get(
-            "dcim.virtualchassis"
+    def _preprocess_devices(self, data: dict, records: dict) -> None:
+        """Custom preprocessing for devices - single iteration for efficiency."""
+        if not (
+            self.sync.parameters.get("dcim.device")
+            or self.sync.parameters.get("dcim.virtualchassis")
+            or self.sync.parameters.get("dcim.interface")
+            or self.sync.parameters.get("dcim.macaddress")
+            or self.sync.parameters.get("ipam.ipaddress")
         ):
-            self.logger.log_info("Preparing devices", obj=self.sync)
-            devices, virtualchassis = prepare_devices(
-                data.get("/inventory/devices", []), members
+            return
+
+        # Prepare virtual chassis members once
+        members = {}
+        if self.sync.parameters.get("dcim.virtualchassis"):
+            self.logger.log_info("Preparing virtual chassis members", obj=self.sync)
+            members = order_members(
+                data.get("/technology/platforms/stack/members", []), "memberSn"
             )
-        else:
-            # We can skip iterating over devices since we don't need stack members for the rest of the models
-            devices, virtualchassis = data.get("/inventory/devices", []), []
+            members.update(
+                order_members(
+                    data.get("/technology/platforms/vss/chassis", []), "chassisSn"
+                )
+            )
+
+        self.logger.log_info("Preparing devices", obj=self.sync)
+        devices, virtualchassis = prepare_devices(
+            data.get("/inventory/devices", []), members
+        )
 
-        # We need to store primary IPs of Devices to assign them later
-        # since they are not stored on Device object directly
-        # TODO: This will be later replaced when we are able to sync from multiple API tables to 1 model
         device_primary_ips = {}
 
+        # Single iteration creating records for all related models
         for device in devices:
             if self.sync.parameters.get("dcim.manufacturer"):
                 records["dcim.manufacturer"].add(
@@ -714,40 +759,55 @@ class IPFabricSyncRunner(object):
                         app="dcim", model="manufacturer", data=device
                     )
                 )
+
             if self.sync.parameters.get("dcim.devicetype"):
                 records["dcim.devicetype"].add(
                     self.create_new_data_record(
                         app="dcim", model="devicetype", data=device
                     )
                 )
+
             if self.sync.parameters.get("dcim.platform"):
                 records["dcim.platform"].add(
                     self.create_new_data_record(
                         app="dcim", model="platform", data=device
                     )
                 )
+
             if self.sync.parameters.get("dcim.devicerole"):
                 records["dcim.devicerole"].add(
                     self.create_new_data_record(
                         app="dcim", model="devicerole", data=device
                     )
                 )
-            # This field is required by Device transform maps, but is set only when Device is part of VC.
+
             if "virtual_chassis" not in device:
                 device["virtual_chassis"] = None
+
             if self.sync.parameters.get("dcim.device"):
                 records["dcim.device"].add(
                     self.create_new_data_record(app="dcim", model="device", data=device)
                 )
+
             device_primary_ips[device.get("sn")] = device.get("loginIp")
 
+        self._device_primary_ips = device_primary_ips
         records["dcim.virtualchassis"] = self.create_new_data_records(
             app="dcim", model="virtualchassis", data=virtualchassis
         )
 
-        # `nameOriginal` is human-readable interface name hidden column in IP Fabric
-        # This allows us to use it instead of the `intName`
-        # But it can be customized using transform maps, so we need to use the current value
+    def _preprocess_interfaces(self, data: dict, records: dict) -> None:
+        """Custom preprocessing for interfaces and MAC addresses."""
+        if not (
+            self.sync.parameters.get("dcim.interface")
+            or self.sync.parameters.get("dcim.macaddress")
+            or self.sync.parameters.get("ipam.ipaddress")
+        ):
+            return
+
+        if not hasattr(self, "_device_primary_ips"):
+            self._preprocess_devices(data=data, records=records)
+
         interface_key = "nameOriginal"
         try:
             int_transform_map = self.get_transform_map(app="dcim", model="interface")
@@ -755,61 +815,127 @@ class IPFabricSyncRunner(object):
             interface_key = int_name_field_map.source_field
         except Exception as e:
             self.logger.log_failure(
-                f"Error collecting information about transform map for interface name: {e}",
-                obj=self.sync,
+                f"Error collecting transform map info: {e}", obj=self.sync
             )
             raise SyncError(f"Error collecting source column name for interface: {e}")
 
         # Store human-readable interface names to use them later for IP Addresses
         readable_int_names = {}
-        if (
-            self.sync.parameters.get("dcim.interface")
-            or self.sync.parameters.get("dcim.macaddress")
-            or self.sync.parameters.get("ipam.ipaddress")
-        ):
-            self.logger.log_info("Preparing Interfaces", obj=self.sync)
-            for interface in data.get("/inventory/interfaces", []):
-                if self.sync.parameters.get("dcim.interface"):
-                    interface_record = self.create_new_data_record(
-                        app="dcim", model="interface", data=interface
-                    )
-                    interface_record.data["loginIp"] = device_primary_ips.get(
-                        interface.get("sn")
-                    )
-                    records["dcim.interface"].add(interface_record)
-                readable_int_names[
-                    f"{interface.get('sn')}_{interface.get('intName')}"
-                ] = interface.get(interface_key)
-                if self.sync.parameters.get("dcim.macaddress"):
-                    records["dcim.macaddress"].add(
-                        self.create_new_data_record(
-                            app="dcim", model="macaddress", data=interface
-                        )
+        self.logger.log_info("Preparing Interfaces", obj=self.sync)
+
+        for interface in data.get("/inventory/interfaces", []):
+            if self.sync.parameters.get("dcim.interface"):
+                interface_record = self.create_new_data_record(
+                    app="dcim", model="interface", data=interface
+                )
+                interface_record.data["loginIp"] = self._device_primary_ips.get(
+                    interface.get("sn")
+                )
+                records["dcim.interface"].add(interface_record)
+
+            readable_int_names[
+                f"{interface.get('sn')}_{interface.get('intName')}"
+            ] = interface.get(interface_key)
+
+            if self.sync.parameters.get("dcim.macaddress"):
+                records["dcim.macaddress"].add(
+                    self.create_new_data_record(
+                        app="dcim", model="macaddress", data=interface
                     )
+                )
+
+        self._readable_int_names = readable_int_names
+
+    def _preprocess_ipaddresses(self, data: dict, records: dict) -> None:
+        """Custom preprocessing for IP addresses."""
+        if not self.sync.parameters.get("ipam.ipaddress"):
+            return
+
+        if not hasattr(self, "_readable_int_names"):
+            self._preprocess_interfaces(data=data, records=records)
+
+        self.logger.log_info("Preparing IP Addresses", obj=self.sync)
+        for ip in data.get("/technology/addressing/managed-ip/ipv4", []):
+            ip["nameOriginal"] = self._readable_int_names.get(
+                f"{ip.get('sn')}_{ip.get('intName')}"
+            )
+            if not ip["nameOriginal"]:
+                continue
+
+            ipaddress_record = self.create_new_data_record(
+                app="ipam", model="ipaddress", data=ip
+            )
+            ipaddress_record.data["is_primary"] = ip.get(
+                "sn"
+            ) in self._device_primary_ips and self._device_primary_ips.get(
+                ip.get("sn")
+            ) == ipaddress_record.data.get(
+                "ip"
+            )
+            records["ipam.ipaddress"].add(ipaddress_record)
 
-        if self.sync.parameters.get("ipam.ipaddress"):
-            self.logger.log_info("Preparing IP Addresses", obj=self.sync)
-            for ip in data.get("/technology/addressing/managed-ip/ipv4", []):
-                # We get `nameOriginal` from Interface table to get human-readable name instead fo `intName`
-                ip["nameOriginal"] = readable_int_names.get(
-                    f"{ip.get('sn')}_{ip.get('intName')}"
+    def preprocess_data(self, data: dict) -> dict[str, set[DataRecord]]:
+        """
+        Preprocess data using hierarchical transform map order.
+
+        Iterates over transform maps in dependency order (parents before children),
+        using custom preprocessing functions where available or direct record creation.
+        Each transform map is processed exactly once, avoiding duplicate iterations.
+        """
+        # Get transform maps in hierarchical order (now returns transform maps directly!)
+        group_ids = self.sync.parameters.get("groups", [])
+        transform_maps_hierarchy = self.sync.get_model_hierarchy(group_ids=group_ids)
+
+        # Initialize records dict for all models (extract unique model strings)
+        records = {}
+        seen_models = set()
+        for transform_map in transform_maps_hierarchy:
+            model_string = f"{transform_map.target_model.app_label}.{transform_map.target_model.model}"
+            if model_string not in seen_models:
+                records[model_string] = set()
+                seen_models.add(model_string)
+
+        # Track which custom preprocessors have run (to avoid duplication)
+        # Use (preprocessor, endpoint) tuple to allow same preprocessor for different endpoints
+        preprocessors_run = set()
+
+        # Process each transform map in hierarchical order
+        for transform_map in transform_maps_hierarchy:
+            app = transform_map.target_model.app_label
+            model = transform_map.target_model.model
+            model_string = f"{app}.{model}"
+            endpoint = transform_map.source_endpoint.endpoint
+
+            # Skip if not enabled in sync parameters
+            if not self.sync.parameters.get(model_string):
+                continue
+
+            # Check for custom preprocessor (pass endpoint for endpoint-specific preprocessing)
+            preprocessor = self._get_custom_preprocessor(model_string, endpoint)
+
+            # Create unique key combining preprocessor function and endpoint
+            preprocessor_key = (preprocessor, endpoint) if preprocessor else None
+
+            if preprocessor and preprocessor_key not in preprocessors_run:
+                # Run custom preprocessor (may populate multiple models)
+                self.logger.log_info(
+                    f"Running custom preprocessor for `{model_string}` from `{endpoint}`",
+                    obj=self.sync,
                 )
-                # Let's skip IPs we cannot assign to an interface
-                if not ip["nameOriginal"]:
-                    continue
-                ipaddress_record = self.create_new_data_record(
-                    app="ipam", model="ipaddress", data=ip
+                preprocessor(data, records)
+                preprocessors_run.add(preprocessor_key)
+            elif not preprocessor:
+                # Standard processing: use the transform map directly (no need to filter!)
+                self.logger.log_info(
+                    f"Preparing `{model_string}` from `{endpoint}`", obj=self.sync
                 )
-                # Store whether this IP is primary for the device
-                ipaddress_record.data["is_primary"] = ip.get(
-                    "sn"
-                ) in device_primary_ips and device_primary_ips.get(
-                    ip.get("sn")
-                ) == ipaddress_record.data.get(
-                    "ip"
+                records[model_string].update(
+                    self.create_new_data_records(
+                        app=app, model=model, data=data, endpoint=endpoint
+                    )
                 )
-                records["ipam.ipaddress"].add(ipaddress_record)
 
+        # Log statistics
         for model_string, records_set in records.items():
             if self.settings.get(model_string) and len(records_set):
                 self.logger.init_statistics(model_string, len(records_set))
@@ -883,56 +1009,6 @@ class IPFabricSyncRunner(object):
             self.sync_item(item, cf, ingestion, stats)
             self.events_clearer.increment()
 
-    @handle_errors
-    def sync_devices(
-        self,
-        devices: set[DataRecord],
-        cf: bool = False,
-        ingestion: "IPFabricIngestion" = None,
-    ) -> None:
-        """Sync devices separately to handle resetting primary IP."""
-        if not self.settings.get("dcim.device"):
-            self.logger.log_info(
-                "Did not ask to sync devices, skipping.", obj=self.sync
-            )
-            return
-
-        for device in devices:
-            device_obj: "Device | None" = self.sync_item(
-                record=device, cf=cf, ingestion=ingestion
-            )
-
-            if (
-                device_obj is None
-                or device_obj.primary_ip4 is None
-                or device.data.get("loginIp") is not None
-            ):
-                self.events_clearer.increment()
-                continue
-
-            # If device has primary IP assigned in NetBox, but not in IP Fabric, remove it
-            try:
-                connection_name = self.get_db_connection_name()
-                device_obj.refresh_from_db(using=connection_name)
-                device_obj.snapshot()
-                device_obj.primary_ip4 = None
-                device_obj.save(using=connection_name)
-            except Exception as err:
-                _, issue = self.create_or_get_sync_issue(
-                    exception=err,
-                    ingestion=self.ingestion,
-                    message="Error removing primary IP current device.",
-                    model_string=device.model_string,
-                    data=device.data,
-                )
-                self.events_clearer.increment()
-                raise IPAddressPrimaryRemovalError(
-                    data=device.data,
-                    model_string=device.model_string,
-                    issue_id=issue.pk,
-                ) from err
-            self.events_clearer.increment()
-
     @handle_errors
     def sync_ipaddress(self, ip_address: DataRecord) -> "IPAddress | None":
         """Sync a single IP Address to NetBox, separated to use @handle_errors."""
@@ -1037,14 +1113,16 @@ class IPFabricSyncRunner(object):
         self.logger.log_info("Starting data sync.", obj=self.sync)
         try:
             # This signal does not call for snapshot(), causing issue with branching plugin
-            signals.post_save.disconnect(sync_cached_scope_fields, sender=Site)
+            if sync_cached_scope_fields is not None:
+                signals.post_save.disconnect(sync_cached_scope_fields, sender=Site)
             self.sync_items(
                 items=records["dcim.site"],
                 cf=self.sync.update_custom_fields,
                 ingestion=ingestion,
             )
         finally:
-            signals.post_save.connect(sync_cached_scope_fields, sender=Site)
+            if sync_cached_scope_fields is not None:
+                signals.post_save.connect(sync_cached_scope_fields, sender=Site)
         self.sync_items(items=records["dcim.manufacturer"])
         self.sync_items(items=records["dcim.devicetype"])
         self.sync_items(items=records["dcim.platform"])
@@ -1055,8 +1133,8 @@ class IPFabricSyncRunner(object):
                 assign_virtualchassis_master, sender=VirtualChassis
             )
             self.sync_items(items=records["dcim.virtualchassis"])
-            self.sync_devices(
-                devices=records["dcim.device"],
+            self.sync_items(
+                items=records["dcim.device"],
                 cf=self.sync.update_custom_fields,
                 ingestion=ingestion,
             )

ipfabric_netbox/utilities/transform_map.py

@@ -181,12 +181,15 @@ class RelationshipRecord(Record):
 class TransformMapRecord:
     def __init__(
         self,
-        source_model: str,
         target_model: str,
         fields: tuple[FieldRecord, ...] = tuple(),
         relationships: tuple[RelationshipRecord, ...] = tuple(),
+        # Support both source_model string and source_endpoint string for backward compatibility
+        source_model: str | None = None,
+        source_endpoint: str | None = None,
     ):
         self.source_model = source_model
+        self.source_endpoint = source_endpoint
         self.target_model = target_model
         self.fields = fields
         self.relationships = relationships
@@ -208,10 +211,20 @@ def do_change(
         for change in changes:
             app, model = change.target_model.split(".")
             try:
-                transform_map = IPFabricTransformMap.objects.get(
-                    source_model=change.source_model,
-                    target_model=ContentType.objects.get(app_label=app, model=model),
-                )
+                if change.source_model:
+                    transform_map = IPFabricTransformMap.objects.get(
+                        source_model=change.source_model,
+                        target_model=ContentType.objects.get(
+                            app_label=app, model=model
+                        ),
+                    )
+                else:
+                    transform_map = IPFabricTransformMap.objects.get(
+                        source_endpoint__endpoint=change.source_endpoint,
+                        target_model=ContentType.objects.get(
+                            app_label=app, model=model
+                        ),
+                    )
             except IPFabricTransformMap.DoesNotExist:
                 continue
 

{ipfabric_netbox-4.3.2b10.dist-info → ipfabric_netbox-4.3.2b11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipfabric_netbox
-Version: 4.3.2b10
+Version: 4.3.2b11
 Summary: NetBox plugin to sync IP Fabric data into NetBox
 License: MIT
 Keywords: netbox,ipfabric,plugin,sync
@@ -25,7 +25,7 @@ Requires-Dist: ipfabric (>=7.0.0,<7.1.0) ; extra == "ipfabric_7_0" and extra !=
 Requires-Dist: ipfabric (>=7.2.0,<7.3.0) ; extra != "ipfabric_7_0" and extra == "ipfabric_7_2" and extra != "ipfabric_7_3" and extra != "ipfabric_7_5"
 Requires-Dist: ipfabric (>=7.3.0,<7.4.0) ; extra != "ipfabric_7_0" and extra != "ipfabric_7_2" and extra == "ipfabric_7_3" and extra != "ipfabric_7_5"
 Requires-Dist: ipfabric (>=7.5.0,<7.6.0) ; extra != "ipfabric_7_0" and extra != "ipfabric_7_2" and extra != "ipfabric_7_3" and extra == "ipfabric_7_5"
-Requires-Dist: netboxlabs-netbox-branching (==0.7.0)
+Requires-Dist: netboxlabs-netbox-branching (>=0.7.0)
 Requires-Dist: netutils
 Project-URL: Bug Tracker, https://gitlab.com/ip-fabric/integrations/ipfabric-netbox-sync/-/issues
 Project-URL: Homepage, https://gitlab.com/ip-fabric/integrations/ipfabric-netbox-sync
@@ -66,8 +66,7 @@ These are the required NetBox versions for corresponding plugin version. Any oth
 
 | Netbox Version | Plugin Version |
 |----------------|----------------|
-| 4.4.9 and up   | 5.0.0 and up   |
-| 4.4.0 - 4.4.9  | 4.3.0 - 4.3.2  |
+| 4.4.0 and up   | 4.3.0 and up   |
 | 4.3.0 - 4.3.7  | 4.2.2          |
 | 4.3.0 - 4.3.6  | 4.0.0 - 4.2.1  |
 | 4.2.4 - 4.2.9  | 3.2.2 - 3.2.4  |