ipfabric_netbox 4.1.0b3__py3-none-any.whl → 4.1.0b5__py3-none-any.whl

ipfabric_netbox/__init__.py

@@ -6,7 +6,7 @@ class NetboxIPFabricConfig(PluginConfig):
     name = "ipfabric_netbox"
     verbose_name = "NetBox IP Fabric SoT Plugin"
     description = "Sync IP Fabric into NetBox"
-    version = "4.1.0b3"
+    version = "4.1.0b5"
     base_url = "ipfabric"
     min_version = "4.2.4"
 

ipfabric_netbox/api/nested_serializers.py

@@ -10,7 +10,6 @@ from ipfabric_netbox.models import IPFabricSource
 from ipfabric_netbox.models import IPFabricSync
 from ipfabric_netbox.models import IPFabricTransformMap
 
-# from .serializers import IPFabricSyncSerializer
 
 __all__ = (
     "NestedIPFabricSourceSerializer",

ipfabric_netbox/api/serializers.py

@@ -7,8 +7,10 @@ from rest_framework import serializers
 
 from .nested_serializers import NestedIPFabricSnapshotSerializer
 from .nested_serializers import NestedIPFabricSourceSerializer
+from .nested_serializers import NestedIPFabricSyncSerializer
 from .nested_serializers import NestedIPFabricTransformMapSerializer
 from ipfabric_netbox.models import IPFabricIngestion
+from ipfabric_netbox.models import IPFabricIngestionIssue
 from ipfabric_netbox.models import IPFabricRelationshipField
 from ipfabric_netbox.models import IPFabricSnapshot
 from ipfabric_netbox.models import IPFabricSource
@@ -23,7 +25,9 @@ __all__ = (
     "IPFabricRelationshipFieldSerializer",
     "IPFabricTransformFieldSerializer",
     "IPFabricTransformMapSerializer",
+    "IPFabricTransformMapGroupSerializer",
     "IPFabricIngestionSerializer",
+    "IPFabricIngestionIssueSerializer",
     "IPFabricSourceSerializer",
 )
 
@@ -133,7 +137,7 @@ class IPFabricTransformFieldSerializer(NetBoxModelSerializer):
 
 class IPFabricIngestionSerializer(NetBoxModelSerializer):
     branch = BranchSerializer(read_only=True)
-    sync = IPFabricSyncSerializer(read_only=True)
+    sync = NestedIPFabricSyncSerializer(read_only=True)
 
     class Meta:
         model = IPFabricIngestion
@@ -145,6 +149,24 @@ class IPFabricIngestionSerializer(NetBoxModelSerializer):
         ]
 
 
+class IPFabricIngestionIssueSerializer(NetBoxModelSerializer):
+    ingestion = IPFabricIngestionSerializer(read_only=True)
+
+    class Meta:
+        model = IPFabricIngestionIssue
+        fields = [
+            "id",
+            "ingestion",
+            "timestamp",
+            "model",
+            "message",
+            "raw_data",
+            "coalesce_fields",
+            "defaults",
+            "exception",
+        ]
+
+
 class IPFabricSourceSerializer(NetBoxModelSerializer):
     status = ChoiceField(choices=DataSourceStatusChoices)
     url = serializers.URLField()

ipfabric_netbox/api/urls.py

@@ -1,6 +1,7 @@
 # api/urls.py
 from netbox.api.routers import NetBoxRouter
 
+from ipfabric_netbox.api.views import IPFabricIngestionIssueViewSet
 from ipfabric_netbox.api.views import IPFabricIngestionViewSet
 from ipfabric_netbox.api.views import IPFabricRelationshipFieldiewSet
 from ipfabric_netbox.api.views import IPFabricSnapshotViewSet
@@ -18,6 +19,7 @@ router.register("transform-map-group", IPFabricTransformMapGroupViewSet)
 router.register("transform-map", IPFabricTransformMapViewSet)
 router.register("sync", IPFabricSyncViewSet)
 router.register("ingestion", IPFabricIngestionViewSet)
+router.register("ingestion-issues", IPFabricIngestionIssueViewSet)
 router.register("transform-field", IPFabricTransformFieldiewSet)
 router.register("relationship-field", IPFabricRelationshipFieldiewSet)
 urlpatterns = router.urls

ipfabric_netbox/api/views.py

@@ -5,6 +5,7 @@ from rest_framework.decorators import action
 from rest_framework.response import Response
 from utilities.query import count_related
 
+from .serializers import IPFabricIngestionIssueSerializer
 from .serializers import IPFabricIngestionSerializer
 from .serializers import IPFabricRelationshipFieldSerializer
 from .serializers import IPFabricSnapshotSerializer
@@ -18,6 +19,7 @@ from ipfabric_netbox.filtersets import IPFabricSourceFilterSet
 from ipfabric_netbox.filtersets import IPFabricTransformFieldFilterSet
 from ipfabric_netbox.models import IPFabricData
 from ipfabric_netbox.models import IPFabricIngestion
+from ipfabric_netbox.models import IPFabricIngestionIssue
 from ipfabric_netbox.models import IPFabricRelationshipField
 from ipfabric_netbox.models import IPFabricSnapshot
 from ipfabric_netbox.models import IPFabricSource
@@ -59,6 +61,11 @@ class IPFabricIngestionViewSet(NetBoxReadOnlyModelViewSet):
     serializer_class = IPFabricIngestionSerializer
 
 
+class IPFabricIngestionIssueViewSet(NetBoxReadOnlyModelViewSet):
+    queryset = IPFabricIngestionIssue.objects.all()
+    serializer_class = IPFabricIngestionIssueSerializer
+
+
 class IPFabricSnapshotViewSet(NetBoxModelViewSet):
     queryset = IPFabricSnapshot.objects.all()
     serializer_class = IPFabricSnapshotSerializer

ipfabric_netbox/exceptions.py

@@ -1,24 +1,81 @@
+from typing import TYPE_CHECKING
+
 from core.exceptions import SyncError
 
+if TYPE_CHECKING:
+    from .models import IPFabricIngestionIssue
+    from .models import IPFabricIngestion
+
+
+class IngestionIssue(Exception):
+    """
+    This exception is used to indicate an issue during the ingestion process.
+    """
 
-class ErrorMixin(Exception):
+    # Store created issue object ID if it exists for this exception
+    issue_id = None
     model: str = ""
     defaults: dict[str, str] = {}
     coalesce_fields: dict[str, str] = {}
 
-    def __init__(self, model: str, context: dict, data: dict = None):
+    def __init__(self, model: str, data: dict, context: dict = None, issue_id=None):
         super().__init__()
         self.model = model
-        self.data = data or {}
+        self.data = data
+        context = context or {}
         self.defaults = context.pop("defaults", {})
         self.coalesce_fields = context
+        self.issue_id = issue_id
 
 
-class SearchError(ErrorMixin, LookupError):
+class SearchError(IngestionIssue, LookupError):
+    def __init__(self, message: str, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.message = message
+
     def __str__(self):
-        return f"{self.model} with these keys not found: {self.coalesce_fields}."
+        return self.message
 
 
-class SyncDataError(ErrorMixin, SyncError):
+class SyncDataError(IngestionIssue, SyncError):
     def __str__(self):
         return f"Sync failed for {self.model}: coalesce_fields={self.coalesce_fields} defaults={self.defaults}."
+
+
+class IPAddressDuplicateError(IngestionIssue, SyncError):
+    def __str__(self):
+        return f"IP address {self.data.get('address')} already exists in {self.model} with coalesce_fields={self.coalesce_fields}."
+
+
+def create_or_get_sync_issue(
+    exception: Exception,
+    ingestion: "IPFabricIngestion",
+    message: str = None,
+    model: str = None,
+    context: dict = None,
+    data: dict = None,
+) -> (bool, "IPFabricIngestionIssue"):
+    """
+    Helper function to handle sync errors and create IPFabricIngestionIssue if needed.
+    """
+    context = context or {}
+
+    # TODO: This is to prevent circular import issues, clean it up later.
+    from .models import IPFabricIngestionIssue
+
+    if not hasattr(exception, "issue_id") or not exception.issue_id:
+        issue = IPFabricIngestionIssue.objects.create(
+            ingestion=ingestion,
+            exception=exception.__class__.__name__,
+            message=message or getattr(exception, "message", str(exception)),
+            model=model,
+            coalesce_fields={k: v for k, v in context.items() if k not in ["defaults"]},
+            defaults=context.get("defaults", dict()),
+            raw_data=data or dict(),
+        )
+        if hasattr(exception, "issue_id"):
+            exception.issue_id = issue.id
+        return True, issue
+    else:
+        issue = IPFabricIngestionIssue.objects.get(id=exception.issue_id)
+        return False, issue

ipfabric_netbox/filtersets.py

@@ -10,6 +10,7 @@ from netbox_branching.models import ChangeDiff
 
 from .models import IPFabricData
 from .models import IPFabricIngestion
+from .models import IPFabricIngestionIssue
 from .models import IPFabricSnapshot
 from .models import IPFabricSource
 from .models import IPFabricSync
@@ -37,6 +38,35 @@ class IPFabricIngestionChangeFilterSet(BaseFilterSet):
         )
 
 
+class IPFabricIngestionIssueFilterSet(BaseFilterSet):
+    q = django_filters.CharFilter(method="search")
+
+    class Meta:
+        model = IPFabricIngestionIssue
+        fields = [
+            "model",
+            "timestamp",
+            "raw_data",
+            "coalesce_fields",
+            "defaults",
+            "exception",
+            "message",
+        ]
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(model__icontains=value)
+            | Q(timestamp__icontains=value)
+            | Q(raw_data__icontains=value)
+            | Q(coalesce_fields__icontains=value)
+            | Q(defaults__icontains=value)
+            | Q(exception__icontains=value)
+            | Q(message__icontains=value)
+        )
+
+
 class IPFabricDataFilterSet(BaseFilterSet):
     q = django_filters.CharFilter(method="search")
 

ipfabric_netbox/migrations/0015_ipfabricingestionissue.py

@@ -0,0 +1,48 @@
+# Generated by Django 5.2 on 2025-07-11 19:39
+import django.db.models.deletion
+import django.utils.timezone
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        (
+            "ipfabric_netbox",
+            "0014_ipfabrictransformmapgroup_ipfabrictransformmap_group",
+        ),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="IPFabricIngestionIssue",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False
+                    ),
+                ),
+                ("timestamp", models.DateTimeField(default=django.utils.timezone.now)),
+                ("model", models.CharField(blank=True, max_length=100, null=True)),
+                ("message", models.TextField()),
+                ("raw_data", models.TextField(blank=True, default="")),
+                ("coalesce_fields", models.TextField(blank=True, default="")),
+                ("defaults", models.TextField(blank=True, default="")),
+                ("exception", models.TextField()),
+                (
+                    "ingestion",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="issues",
+                        to="ipfabric_netbox.ipfabricingestion",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "IP Fabric Ingestion Issue",
+                "verbose_name_plural": "IP Fabric Ingestion Issues",
+                "ordering": ["timestamp"],
+            },
+        ),
+    ]

ipfabric_netbox/models.py

@@ -236,6 +236,8 @@ class IPFabricTransformMap(NetBoxModel):
         target_class = self.target_model.model_class()
         queryset = target_class.objects.using(connection_name)
 
+        # Don't change context since it's used in case of exception for IPFabricIngestionIssue
+        context = deepcopy(context)
         defaults = context.pop("defaults", {})
 
         with transaction.atomic(using=connection_name):
@@ -967,6 +969,29 @@ class IPFabricIngestion(JobsMixin, models.Model):
         )
 
 
+class IPFabricIngestionIssue(models.Model):
+    objects = RestrictedQuerySet.as_manager()
+
+    ingestion = models.ForeignKey(
+        to="IPFabricIngestion", on_delete=models.CASCADE, related_name="issues"
+    )
+    timestamp = models.DateTimeField(default=timezone.now)
+    model = models.CharField(max_length=100, blank=True, null=True)
+    message = models.TextField()
+    raw_data = models.TextField(blank=True, default="")
+    coalesce_fields = models.TextField(blank=True, default="")
+    defaults = models.TextField(blank=True, default="")
+    exception = models.TextField()
+
+    class Meta:
+        ordering = ["timestamp"]
+        verbose_name = "IP Fabric Ingestion Issue"
+        verbose_name_plural = "IP Fabric Ingestion Issues"
+
+    def __str__(self):
+        return f"[{self.timestamp}] {self.message}"
+
+
 class IPFabricData(models.Model):
     snapshot_data = models.ForeignKey(
         to=IPFabricSnapshot,

ipfabric_netbox/tables.py

@@ -8,6 +8,7 @@ from netbox_branching.models import ChangeDiff
 
 from .models import IPFabricData
 from .models import IPFabricIngestion
+from .models import IPFabricIngestionIssue
 from .models import IPFabricRelationshipField
 from .models import IPFabricSnapshot
 from .models import IPFabricSource
@@ -199,6 +200,28 @@ class IPFabricIngestionChangesTable(NetBoxTable):
         default_columns = ("object", "action", "object_type", "actions")
 
 
+class IPFabricIngestionIssuesTable(NetBoxTable):
+    id = tables.Column(verbose_name=_("ID"))
+    exception = tables.Column(verbose_name="Exception Type")
+    message = tables.Column(verbose_name="Error Message")
+    actions = None
+
+    class Meta(NetBoxTable.Meta):
+        model = IPFabricIngestionIssue
+        fields = (
+            "model",
+            "timestamp",
+            "raw_data",
+            "coalesce_fields",
+            "defaults",
+            "exception",
+            "message",
+        )
+        default_columns = ("model", "exception", "message")
+        empty_text = _("No Ingestion Issues found")
+        order_by = "id"
+
+
 class DeviceIPFTable(tables.Table):
     hostname = Column()
 

ipfabric_netbox/templates/ipfabric_netbox/ipfabricingestion.html

@@ -36,6 +36,11 @@
 </div>
 {% endblock control-buttons %}
 
+{% block tabs %}
+  <div id="object_tabs" hx-swap-oob="true">
+    {% include 'ipfabric_netbox/partials/object_tabs.html' with object=object %}
+  </div>
+{% endblock tabs %}
 
 {% block content %}
 <div class="row mb-3">
@@ -70,7 +75,6 @@
             <th scope="row">Ingestion Status</th>
               <td><div id="ingestion_status" hx-swap-oob="true">{% include 'ipfabric_netbox/partials/ingestion_status.html' with object=object %}</div></td>
               <!-- <td >{% badge object.sync.get_status_display bg_color=object.sync.get_status_color %}</td> -->
-            </div>
           </tr>
           <tr>
             <th scope="row">Snapshot</th>
@@ -88,59 +92,26 @@
     {% plugin_left_page object %}
   </div>
   <div class="col col-md-6">
-    <div class="card">
-      <h5 class="card-header">Statistics</h5>
-      <div class="card-body">
-        <table class="table table-hover attr-table">
-          <tr>
-            <th scope="row">Created</th>
-            <td>
-              {% if object.num_created %}
-              {{ object.num_created }}
-              {% else %}
-              {{ ''|placeholder }}
-              {% endif %}
-            </td>
-          </tr>
-          <tr>
-            <th scope="row">Updated</th>
-            <td>
-              {% if object.num_updated %}
-              {{ object.num_updated }}
-              {% else %}
-              {{ ''|placeholder }}
-              {% endif %}
-            </td>
-          </tr>
-          <tr>
-            <th scope="row">Deleted</th>
-            <td>
-              {% if object.num_deleted %}
-              {{ object.num_deleted }}
-              {% else %}
-              {{ ''|placeholder }}
-              {% endif %}
-            </td>
-          </tr>
-        </table>
-      </div>
+    <div id="ingestion_statistics" hx-swap-oob="true">
+      {% include 'ipfabric_netbox/partials/ingestion_statistics.html' with object=object %}
     </div>
-    <div id="ingestion_progress">
+    <div id="ingestion_progress" hx-swap-oob="true">
       {% include 'ipfabric_netbox/partials/ingestion_progress.html' %}
     </div>
     <!-- {% include 'inc/panels/related_objects.html' %} -->
     {% include 'inc/panels/custom_fields.html' %}
     {% plugin_right_page object %}
   </div>
-</div>
-<div class="row mb-3">
-  <div class="col col-md-12" {% if not object.job.completed %} hx-get="{% url 'plugins:ipfabric_netbox:ipfabricingestion_logs' pk=object.pk %}?type=info"
-    hx-trigger="every 5s" hx-target="#ingestion_logs" hx-select="#ingestion_logs" hx-select-oob="#ingestion_status:innerHTML"
-    hx-swap="innerHTML" {% endif %}>
-    <div id="ingestion_logs">{% include 'ipfabric_netbox/partials/job_logs.html' with job=object.job %}</div>
+  <div class="row mb-3">
+    <div class="col col-md-12" {% if not object.job.completed %} hx-get="{% url 'plugins:ipfabric_netbox:ipfabricingestion_logs' pk=object.pk %}?type=info"
+      hx-trigger="every 5s" hx-target="#ingestion_logs" hx-select="#ingestion_logs" hx-select-oob="#ingestion_status:innerHTML,#ingestion_progress:innerHTML,#ingestion_statistics:innerHTML,#object_tabs:innerHTML"
+      hx-swap="innerHTML" {% endif %}>
+      <div id="ingestion_logs">{% include 'ipfabric_netbox/partials/job_logs.html' with job=object.job %}</div>
+    </div>
   </div>
+</div>
 {% endblock content %}
 
-  {% block modals %}
-  {% include 'inc/htmx_modal.html' with size='lg' %}
-  {% endblock modals %}
+{% block modals %}
+{% include 'inc/htmx_modal.html' with size='lg' %}
+{% endblock modals %}

ipfabric_netbox/templates/ipfabric_netbox/partials/ingestion_all.html

@@ -1,4 +1,9 @@
-
+<div id="object_tabs" hx-swap-oob="true">
+  {% include 'ipfabric_netbox/partials/object_tabs.html' with object=object %}
+</div>
+<div id="ingestion_statistics" hx-swap-oob="true">
+  {% include 'ipfabric_netbox/partials/ingestion_statistics.html' with object=object %}
+</div>
 <div id="ingestion_status" hx-swap-oob="true">
   {% include 'ipfabric_netbox/partials/ingestion_status.html' with object=object %}
 </div>

ipfabric_netbox/templates/ipfabric_netbox/partials/ingestion_statistics.html

@@ -0,0 +1,37 @@
+<div class="card">
+  <h5 class="card-header">Statistics</h5>
+  <div class="card-body">
+    <table class="table table-hover attr-table">
+      <tr>
+        <th scope="row">Created</th>
+        <td>
+          {% if object.num_created %}
+          {{ object.num_created }}
+          {% else %}
+          {{ ''|placeholder }}
+          {% endif %}
+        </td>
+      </tr>
+      <tr>
+        <th scope="row">Updated</th>
+        <td>
+          {% if object.num_updated %}
+          {{ object.num_updated }}
+          {% else %}
+          {{ ''|placeholder }}
+          {% endif %}
+        </td>
+      </tr>
+      <tr>
+        <th scope="row">Deleted</th>
+        <td>
+          {% if object.num_deleted %}
+          {{ object.num_deleted }}
+          {% else %}
+          {{ ''|placeholder }}
+          {% endif %}
+        </td>
+      </tr>
+    </table>
+  </div>
+</div>

ipfabric_netbox/templates/ipfabric_netbox/partials/ingestion_status.html

@@ -1 +1 @@
-{% badge object.sync.get_status_display bg_color=object.sync.get_status_color %}
+{% badge object.sync.get_status_display bg_color=object.sync.get_status_color %} {% if object.errors and object.errors.count %}(with {{ object.errors.count }} issues){% endif %}

ipfabric_netbox/templates/ipfabric_netbox/partials/object_tabs.html

@@ -0,0 +1,12 @@
+{% load helpers %}
+{% load tabs %}
+
+<ul class="nav nav-tabs" role="presentation">
+  {# Primary tab #}
+  <li class="nav-item">
+    <a class="nav-link{% if not tab %} active{% endif %}" href="{{ object.get_absolute_url }}">{{ object|meta:"verbose_name"|bettertitle }}</a>
+  </li>
+
+  {# Include tabs for registered model views #}
+  {% model_view_tabs object %}
+</ul>

ipfabric_netbox/utilities/ipfutils.py

@@ -3,6 +3,7 @@ import logging
 from importlib import metadata
 from typing import Callable
 from typing import TYPE_CHECKING
+from typing import TypeVar
 
 from core.choices import DataSourceStatusChoices
 from core.exceptions import SyncError
@@ -21,24 +22,22 @@ from netbox.config import get_config
 from netutils.utils import jinja2_convenience_function
 
 from ..choices import IPFabricSourceTypeChoices
+from ..exceptions import create_or_get_sync_issue
+from ..exceptions import IPAddressDuplicateError
 from ..exceptions import SearchError
 from ..exceptions import SyncDataError
 from .nbutils import device_serial_max_length
 from .nbutils import order_devices
 from .nbutils import order_members
 
-FAILED_CREATE_INSTANCE_TEMPLATE = (
-    "Failed to create instance of '{model}': <br/>"
-    "message: '{err}'<br/>"
-    "raw data: '{data}'<br/>"
-    "context: '{context}'<br/>"
-)
-
 if TYPE_CHECKING:
     from ..models import IPFabricIngestion
+    from ipam.models import IPAddress
 
 logger = logging.getLogger("ipfabric_netbox.utilities.ipf_utils")
 
+ModelTypeVar = TypeVar("ModelTypeVar", bound=Model)
+
 
 def slugify_text(value):
     return slugify(value)
@@ -98,7 +97,7 @@ class IPFabric(object):
                 formatted_snapshots[snapshot_ref] = (description, snapshot.snapshot_id)
         return formatted_snapshots
 
-    def get_sites(self, snapshot=None) -> dict():
+    def get_sites(self, snapshot=None) -> list:
         if snapshot:
             raw_sites = self.ipf.inventory.sites.all(snapshot_id=snapshot)
         else:
@@ -159,6 +158,9 @@ class IPFabricSyncRunner(object):
             except Exception as err:
                 # Log the error to logger outside of job - console/file
                 logger.error(err, exc_info=True)
+                if hasattr(err, "issue_id") and err.issue_id:
+                    # The error is already logged to user, no need to log it again
+                    return None
                 # Logging section for logs inside job - facing user
                 self = args[0]
                 if isinstance(err, SearchError):
@@ -172,6 +174,11 @@ class IPFabricSyncRunner(object):
                             f"Syncing `{err.model}` is disabled in settings, but hit above error trying to find the correct item. Please check your transform maps and/or existing data.",
                             obj=self.sync,
                         )
+                if isinstance(err, IPAddressDuplicateError):
+                    self.logger.log_warning(
+                        f"IP Address `{err.data.get('address')}` already exists in `{err.model}` with coalesce fields: `{err.coalesce_fields}`. Please check your transform maps and/or existing data.",
+                        obj=self.sync,
+                    )
                 else:
                     self.logger.log_failure(
                         f"Syncing failed with: `{err}`. See above error for more details.",
@@ -203,13 +210,21 @@ class IPFabricSyncRunner(object):
         except Exception as err:
             message = f"Error getting context for `{model}`."
             if isinstance(err, ObjectDoesNotExist):
-                message += " Could not find related object using on template in transform maps."
+                message += (
+                    " Could not find related object using template in transform maps."
+                )
             elif isinstance(err, MultipleObjectsReturned):
                 message += " Multiple objects returned using on template in transform maps, the template is not strict enough."
-            self.logger.log_failure(
-                f"<b>{message}</b><br/>data: `{data}`<br/>error: `{err}`", obj=self.sync
+            _, issue = create_or_get_sync_issue(
+                exception=err,
+                ingestion=self.ingestion,
+                message=message,
+                model=model,
+                data=data,
             )
-            raise SyncError(err) from err
+            raise SearchError(
+                message=message, data=data, model=model, issue_id=issue.id
+            ) from err
 
         queryset = transform_map.target_model.model_class().objects
 
@@ -228,25 +243,50 @@ class IPFabricSyncRunner(object):
                 context.pop("defaults", None)
                 object = queryset.using(connection_name).get(**context)
         except queryset.model.DoesNotExist as err:
-            self.logger.log_failure(
-                f"<b>`{model}` with these keys not found: `{context}`.</b><br/>Original data: `{data}`.",
-                obj=self.sync,
+            message = f"Instance of `{model}` not found."
+            _, issue = create_or_get_sync_issue(
+                exception=err,
+                ingestion=self.ingestion,
+                message=message,
+                model=model,
+                context=context,
+                data=data,
             )
-            raise SearchError(model=model, context=context, data=data) from err
+            raise SearchError(
+                message=message,
+                model=model,
+                context=context,
+                data=data,
+                issue_id=issue.id,
+            ) from err
         except queryset.model.MultipleObjectsReturned as err:
-            self.logger.log_failure(
-                f"<b>Multiple `{model}` with these keys found: `{context}`.</b><br/>Original data: `{data}`.",
-                obj=self.sync,
+            message = f"Multiple instances of `{model}` found."
+            _, issue = create_or_get_sync_issue(
+                exception=err,
+                ingestion=self.ingestion,
+                message=message,
+                model=model,
+                context=context,
+                data=data,
             )
-            raise SearchError(model=model, context=context, data=data) from err
+            raise SearchError(
+                message=message,
+                model=model,
+                context=context,
+                data=data,
+                issue_id=issue.id,
+            ) from err
         except Exception as err:
-            self.logger.log_failure(
-                FAILED_CREATE_INSTANCE_TEMPLATE.format(
-                    model=model, err=err, data=data, context=context
-                ),
-                obj=self.sync,
+            _, issue = create_or_get_sync_issue(
+                exception=err,
+                ingestion=self.ingestion,
+                model=model,
+                context=context,
+                data=data,
             )
-            raise SyncDataError(model=model, context=context, data=data) from err
+            raise SyncDataError(
+                model=model, context=context, data=data, issue_id=issue.id
+            ) from err
 
         return object
 
@@ -436,7 +476,6 @@ class IPFabricSyncRunner(object):
             f"{len(data.get('ipaddress', []))} management IP's collected",
             obj=self.sync.snapshot_data.source,
         )
-
         self.logger.log_info("Ordering devices", obj=self.sync)
 
         members = order_members(data.get("virtualchassis", []))
@@ -526,11 +565,29 @@ class IPFabricSyncRunner(object):
         )
 
     @handle_errors
-    def sync_model(self, app_label: str, model: str, data: dict | None) -> Model | None:
+    def sync_model(
+        self,
+        app_label: str,
+        model: str,
+        data: dict | None,
+        stats: bool = True,
+        sync: bool = False,
+    ) -> ModelTypeVar | None:
         """Sync a single item to NetBox."""
+        # The `sync` param is a workaround since we need to get some models (Device...) even when not syncing them.
+        if not sync:
+            return None
+
         if not data:
             return None
-        return self.get_model_or_update(app_label, model, data)
+
+        instance = self.get_model_or_update(app_label, model, data)
+
+        # Only log when we successfully synced the item and asked for it
+        if stats:
+            self.logger.increment_statistics(model=model)
+
+        return instance
 
     def sync_items(
         self,
@@ -548,11 +605,14 @@ class IPFabricSyncRunner(object):
             return
 
         for item in items:
-            synced_object = self.sync_model(app_label=app_label, model=model, data=item)
+            synced_object = self.sync_model(
+                app_label=app_label,
+                model=model,
+                data=item,
+                sync=self.settings.get(model),
+            )
             if synced_object is None:
                 continue
-            # Only log when we successfully synced the item
-            self.logger.increment_statistics(model=model)
 
             if cf:
                 synced_object.snapshot()
@@ -588,22 +648,40 @@ class IPFabricSyncRunner(object):
         devices_total = len(devices)
 
         for device in devices:
-            if self.sync_model("dcim", "manufacturer", device) is None:
-                continue
-            if self.sync_model("dcim", "devicetype", device) is None:
-                continue
-            if self.sync_model("dcim", "platform", device) is None:
-                continue
-            if self.sync_model("dcim", "devicerole", device) is None:
-                continue
+            self.sync_model(
+                "dcim", "manufacturer", device, sync=self.settings.get("manufacturer")
+            )
+            self.sync_model(
+                "dcim", "devicetype", device, sync=self.settings.get("devicetype")
+            )
+            self.sync_model(
+                "dcim", "platform", device, sync=self.settings.get("platform")
+            )
+            self.sync_model(
+                "dcim", "devicerole", device, sync=self.settings.get("devicerole")
+            )
 
             virtual_chassis = device.get("virtual_chassis", {})
-            self.sync_model("dcim", "virtualchassis", virtual_chassis)
+            self.sync_model(
+                "dcim",
+                "virtualchassis",
+                virtual_chassis,
+                False,
+                sync=self.settings.get("virtualchassis"),
+            )
 
-            if (device_object := self.sync_model("dcim", "device", device)) is None:
-                continue
+            # We need to get a Device instance even when not syncing it but syncing Interfaces, IPs or MACs
+            device_object: Device | None = self.sync_model(
+                "dcim",
+                "device",
+                device,
+                sync=self.settings.get("device")
+                or self.settings.get("interface")
+                or self.settings.get("ipaddress")
+                or self.settings.get("macaddress"),
+            )
 
-            if self.settings.get("device"):
+            if device_object and self.settings.get("device"):
                 device_object.snapshot()
                 device_object.custom_field_data[
                     "ipfabric_source"
@@ -612,23 +690,26 @@ class IPFabricSyncRunner(object):
                     device_object.custom_field_data["ipfabric_ingestion"] = ingestion.pk
                 device_object.save()
 
-            self.logger.increment_statistics(model="device")
-            logger.info(
-                f"Device {self.logger.log_data.get('statistics', {}).get('device', {}).get('current')} out of {devices_total}"
-            )
+                self.logger.increment_statistics(model="device")
+                logger.info(
+                    f"Device {self.logger.log_data.get('statistics', {}).get('device', {}).get('current')} out of {devices_total}"
+                )
 
-            # The Device exists now, so we can update master of the VC.
-            # The logic is handled in transform maps.
-            self.sync_model("dcim", "virtualchassis", virtual_chassis)
+                # The Device exists now, so we can update the master of the VC.
+                # The logic is handled in transform maps.
+                self.sync_model(
+                    "dcim",
+                    "virtualchassis",
+                    virtual_chassis,
+                    False,
+                    sync=self.settings.get("virtualchassis"),
+                )
 
             device_interfaces = interface_dict.get(device.get("sn"), [])
             for device_interface in device_interfaces:
-                interface_object = self.sync_interface(
+                self.sync_interface(
                     device_interface, managed_ips, device_object, device
                 )
-                if interface_object is None:
-                    continue
-                self.logger.increment_statistics(model="interface")
 
     @handle_errors
     def sync_ipaddress(
@@ -638,22 +719,20 @@ class IPFabricSyncRunner(object):
         primary_ip: str | None,
         login_ip: str | None,
     ):
-        if not self.settings.get("ipaddress") or not managed_ip:
-            return
-        ip_address_obj = self.get_model_or_update(
+        ip_address_obj: "IPAddress | None" = self.sync_model(
             "ipam",
             "ipaddress",
             managed_ip,
+            sync=self.settings.get("ipaddress"),
         )
         if ip_address_obj is None:
-            return
-        self.logger.increment_statistics(model="ipaddress")
+            return None
 
         connection_name = self.get_db_connection_name()
 
         try:
-            # Removing other IP is done in .signals.clear_other_primary_ip
-            # But do it here too so the change is shown in StagedChange diff
+            # Removing another IP is done in .signals.clear_other_primary_ip
+            # But do it here too, so the change is shown in StagedChange diff
             other_device = Device.objects.using(connection_name).get(
                 primary_ip4=ip_address_obj
             )
@@ -669,7 +748,7 @@ class IPFabricSyncRunner(object):
                 device_object.snapshot()
                 device_object.primary_ip4 = ip_address_obj
                 device_object.save(using=connection_name)
-            except ValueError as err:
+            except (ValueError, AttributeError) as err:
                 self.logger.log_failure(
                     f"Error assigning primary IP to device: {err}", obj=self.sync
                 )
@@ -680,17 +759,17 @@ class IPFabricSyncRunner(object):
     def sync_macaddress(
         self, data: dict | None, interface_object: Interface
     ) -> MACAddress | None:
-        if not self.settings.get("macaddress") or not data:
-            return None
         # Need to create MAC Address object before we can assign it to Interface
         # TODO: Figure out how to do this using transform maps
         macaddress_data = {
             "mac": data,
-            "id": interface_object.pk,
+            "id": getattr(interface_object, "pk", None),
         }
-        macaddress_object = self.get_model_or_update(
-            "dcim", "macaddress", macaddress_data
+        macaddress_object: MACAddress | None = self.sync_model(
+            "dcim", "macaddress", macaddress_data, sync=self.settings.get("macaddress")
         )
+        if macaddress_object is None:
+            return None
         try:
             interface_object.snapshot()
             interface_object.primary_mac_address = macaddress_object
@@ -711,15 +790,19 @@ class IPFabricSyncRunner(object):
         device: dict,
     ):
         device_interface["loginIp"] = device.get("loginIp")
-        interface_object = self.get_model_or_update(
-            "dcim", "interface", device_interface
+        # We need to get an Interface instance even when not syncing it but syncing IPs or MACs
+        interface_object: Interface | None = self.sync_model(
+            "dcim",
+            "interface",
+            device_interface,
+            sync=self.settings.get("interface")
+            or self.settings.get("ipaddress")
+            or self.settings.get("macaddress"),
         )
-        if interface_object is None:
-            return None
 
-        for ipaddress in managed_ips.get(device_object.serial, {}).get(
-            interface_object.name, []
-        ):
+        for ipaddress in managed_ips.get(
+            getattr(device_object, "serial", None), {}
+        ).get(getattr(interface_object, "name", None), []):
             self.sync_ipaddress(
                 ipaddress,
                 device_object,

ipfabric_netbox/views.py

@@ -34,6 +34,7 @@ from utilities.views import ViewTab
 from .filtersets import IPFabricDataFilterSet
 from .filtersets import IPFabricIngestionChangeFilterSet
 from .filtersets import IPFabricIngestionFilterSet
+from .filtersets import IPFabricIngestionIssueFilterSet
 from .filtersets import IPFabricSnapshotFilterSet
 from .filtersets import IPFabricSourceFilterSet
 from .filtersets import IPFabricTransformMapFilterSet
@@ -52,6 +53,7 @@ from .forms import IPFabricTransformMapForm
 from .forms import IPFabricTransformMapGroupForm
 from .models import IPFabricData
 from .models import IPFabricIngestion
+from .models import IPFabricIngestionIssue
 from .models import IPFabricRelationshipField
 from .models import IPFabricSnapshot
 from .models import IPFabricSource
@@ -62,6 +64,7 @@ from .models import IPFabricTransformMapGroup
 from .tables import DeviceIPFTable
 from .tables import IPFabricDataTable
 from .tables import IPFabricIngestionChangesTable
+from .tables import IPFabricIngestionIssuesTable
 from .tables import IPFabricIngestionTable
 from .tables import IPFabricRelationshipFieldTable
 from .tables import IPFabricSnapshotTable
@@ -657,36 +660,8 @@ class IPFabricIngestionListView(generic.ObjectListView):
     table = IPFabricIngestionTable
 
 
-@register_model_view(
-    IPFabricIngestion,
-    name="logs",
-    path="logs",
-)
-class IPFabricIngestionLogView(LoginRequiredMixin, View):
-    template_name = "ipfabric_netbox/partials/ingestion_all.html"
-
-    def get(self, request, **kwargs):
-        ingestion_id = kwargs.get("pk")
-        if request.htmx:
-            ingestion = IPFabricIngestion.objects.get(pk=ingestion_id)
-            data = ingestion.get_statistics()
-            data["object"] = ingestion
-            data["job"] = ingestion.jobs.first()
-            response = render(
-                request,
-                self.template_name,
-                data,
-            )
-            if ingestion.job.completed:
-                response["HX-Refresh"] = "true"
-                return response
-            else:
-                return response
-
-
-@register_model_view(IPFabricIngestion)
-class IPFabricIngestionView(generic.ObjectView):
-    queryset = IPFabricIngestion.objects.annotate(
+def annotate_statistics(queryset):
+    return queryset.annotate(
         num_created=models.Count(
             "branch__changediff",
             filter=models.Q(
@@ -713,6 +688,39 @@ class IPFabricIngestionView(generic.ObjectView):
         staged_changes=models.Count(models.F("branch__changediff")),
     )
 
+
+@register_model_view(
+    IPFabricIngestion,
+    name="logs",
+    path="logs",
+)
+class IPFabricIngestionLogView(LoginRequiredMixin, View):
+    template_name = "ipfabric_netbox/partials/ingestion_all.html"
+
+    def get(self, request, **kwargs):
+        ingestion_id = kwargs.get("pk")
+        if request.htmx:
+            ingestion = annotate_statistics(IPFabricIngestion.objects).get(
+                pk=ingestion_id
+            )
+            data = ingestion.get_statistics()
+            data["object"] = ingestion
+            data["job"] = ingestion.jobs.first()
+            response = render(
+                request,
+                self.template_name,
+                data,
+            )
+            if ingestion.job.completed:
+                response["HX-Refresh"] = "true"
+            return response
+        return render(request, self.template_name)
+
+
+@register_model_view(IPFabricIngestion)
+class IPFabricIngestionView(generic.ObjectView):
+    queryset = annotate_statistics(IPFabricIngestion.objects)
+
     def get_extra_context(self, request, instance):
         data = instance.get_statistics()
         return data
@@ -844,6 +852,23 @@ class IPFabricIngestionChangesView(generic.ObjectChildrenView):
         return self.child_model.objects.filter(branch=parent.branch)
 
 
+@register_model_view(IPFabricIngestion, "ingestion_issues")
+class IPFabricIngestionIssuesView(generic.ObjectChildrenView):
+    queryset = IPFabricIngestion.objects.all()
+    child_model = IPFabricIngestionIssue
+    table = IPFabricIngestionIssuesTable
+    template_name = "generic/object_children.html"
+    filterset = IPFabricIngestionIssueFilterSet
+    tab = ViewTab(
+        label="Ingestion Issues",
+        badge=lambda obj: IPFabricIngestionIssue.objects.filter(ingestion=obj).count(),
+        permission="ipfabric_netbox.view_ipfabricingestionissue",
+    )
+
+    def get_children(self, request, parent):
+        return IPFabricIngestionIssue.objects.filter(ingestion=parent)
+
+
 @register_model_view(IPFabricIngestion, "delete")
 class IPFabricIngestionDeleteView(generic.ObjectDeleteView):
     queryset = IPFabricIngestion.objects.all()

{ipfabric_netbox-4.1.0b3.dist-info → ipfabric_netbox-4.1.0b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ipfabric_netbox
-Version: 4.1.0b3
+Version: 4.1.0b5
 Summary: NetBox plugin to sync IP Fabric data into NetBox
 License: MIT
 Keywords: netbox,ipfabric,plugin,sync

{ipfabric_netbox-4.1.0b3.dist-info → ipfabric_netbox-4.1.0b5.dist-info}/RECORD

@@ -1,13 +1,13 @@
-ipfabric_netbox/__init__.py,sha256=dNmLAwHDbmPgnzHOHoqLDisMshHihZ0VvOzkvp41n-8,674
+ipfabric_netbox/__init__.py,sha256=GlnjXNerOuwwTdZ-lspaHy84E4hf8GkMQ9jafQrWn70,674
 ipfabric_netbox/api/__init__.py,sha256=DOkvDAI4BoNgdCiNxfseeExEHyOrK8weG-LvjPRyK8A,101
-ipfabric_netbox/api/nested_serializers.py,sha256=F-VpAL6xhNSUipuvR9_37sVw-3IPjr-XZB5CkouwelA,2174
-ipfabric_netbox/api/serializers.py,sha256=BOhibC7IZDhaPhTAdQmt_RJtVxmgqjt-MXIo7UcNGZc,4496
-ipfabric_netbox/api/urls.py,sha256=KRFE8CtqfeK7RF15KG4DDPUGIcjh_0DyT0D1HZmAAyM,1101
-ipfabric_netbox/api/views.py,sha256=UhFMh3ioYht8mbCCOcpwiyItsI_NZWRdzYS0Nno9XKg,4750
+ipfabric_netbox/api/nested_serializers.py,sha256=dG9YdK6wY6dDEvUWsjzsla-J_GnB5szzDjrcZhdWoEg,2124
+ipfabric_netbox/api/serializers.py,sha256=KihGDzoYTM9M9lrU0uUQPFl3ru7t59MuIebBdQe_DhY,5130
+ipfabric_netbox/api/urls.py,sha256=oZuDEJ6C7dpz8c9J3aJGi1CBSAij8Y4ClLa3Lu5AWk0,1236
+ipfabric_netbox/api/views.py,sha256=j-5-t22519p-4iJxx6PwUNaJumdweIHCdUkYKijiTyI,5041
 ipfabric_netbox/choices.py,sha256=tQ5RHwmuArQ7dCLcE3A_Bnw2ctGHgw67z--AawyyPPg,5261
 ipfabric_netbox/data/transform_map.json,sha256=4PsucgMHcLW3SPoKEptQCd0gA5tCF4hjrR4bGQFCWy8,21744
-ipfabric_netbox/exceptions.py,sha256=Za-RutEX9ZIi3r0Rpor1vDGwsC5foeyrfSjUKS3Cwdk,744
-ipfabric_netbox/filtersets.py,sha256=N7Zsy60ZgJA6vY2n1MHfzIP62aOt6jdIvHC7azeYka8,5263
+ipfabric_netbox/exceptions.py,sha256=DT4dpbakvqoROtBR_F0LzvQCMNWpGhufFcUbZTx0OLY,2655
+ipfabric_netbox/filtersets.py,sha256=unVb64gR_m5oMRo1nP4yWrcogMRvfnzVQRmna6-9fKw,6121
 ipfabric_netbox/forms.py,sha256=07p_vngzsnHG0aev83JqBhb8fSBts0w-MTKu4BuoNLw,44494
 ipfabric_netbox/jobs.py,sha256=KrTUeCuFUIU7vKCUS3RiBYCBG7g7GzhGagM_qFMGQJ4,3089
 ipfabric_netbox/migrations/0001_initial.py,sha256=VphxkWL6QzWq2tcrdXlog718xQtiEGizKwS830z_fOs,13824
@@ -25,11 +25,12 @@ ipfabric_netbox/migrations/0011_update_part_number_DCIM_inventory_item_template.
 ipfabric_netbox/migrations/0012_remove_status_field.py,sha256=UZTY2BOBuV4Y_7zuPRfsCFLo57HZ6DsNRIhFlF_VOTM,387
 ipfabric_netbox/migrations/0013_switch_to_branching_plugin.py,sha256=JfdTNerjuFyjW3pDm4vueOp2lrDh2xt6lL1Et5i4crg,10754
 ipfabric_netbox/migrations/0014_ipfabrictransformmapgroup_ipfabrictransformmap_group.py,sha256=RCfgKyqQhTkfSPhf0IukI3fjeAEBUs5pKWIpsLxgzp0,2272
+ipfabric_netbox/migrations/0015_ipfabricingestionissue.py,sha256=AjAkyboa4BSXsN53BqzO1k_U6QHu4rlA2IhzhubocJw,1732
 ipfabric_netbox/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ipfabric_netbox/models.py,sha256=vUqJBrSc5SyNR_Fm4jPBXkhUx-Vf0GI4L_TZdCurB5k,35116
+ipfabric_netbox/models.py,sha256=CXRMO1nKlcVz_R9WbTjQ0FWsXe1C6ZHIEoRhavI8Jyo,36067
 ipfabric_netbox/navigation.py,sha256=2dEJ_wKHb52Tl0FOV1TH3JbxRe8YZ56ewrTsBFGKpCg,2210
 ipfabric_netbox/signals.py,sha256=cGa5PVD2i24pGXiVNfbu6ruIDqPVdwKQHTSWe9Ura84,1838
-ipfabric_netbox/tables.py,sha256=cmRFCXXK5mBLE_e6B0fsRJ4wZhkQBF1t5uoMWuQ7Eag,7573
+ipfabric_netbox/tables.py,sha256=pHKv6Bosjnc-7aApak3nLhzxqBiA30olPdaMO8F1PQg,8262
 ipfabric_netbox/template_content.py,sha256=bP2nUf5MM-GUbtQxJ8QoYVNXhrDCrkb8wZnbeqa07EA,315
 ipfabric_netbox/templates/ipfabric_netbox/inc/clone_form.html,sha256=K-2TTDaS1F4wUIR8FFFPqex4KJbySXtHiz5V-OEwelY,967
 ipfabric_netbox/templates/ipfabric_netbox/inc/diff.html,sha256=xOiIrvRIBtqDD65u6xcLo2xdwDKNpAylDmzznaJRGCw,3281
@@ -42,7 +43,7 @@ ipfabric_netbox/templates/ipfabric_netbox/inc/snapshotdata.html,sha256=1ItOCPjjp
 ipfabric_netbox/templates/ipfabric_netbox/inc/transform_map_field_map.html,sha256=mRU-rBweVFvaPFHbVYPw7vcYyXiVaXCOkeHm7xWdKPA,500
 ipfabric_netbox/templates/ipfabric_netbox/inc/transform_map_relationship_map.html,sha256=qyuG_EXZMGUscA3sv_6WGSrf_bR7JTRlKyMYf6EYyo4,504
 ipfabric_netbox/templates/ipfabric_netbox/ipfabric_table.html,sha256=d5qcBeKDgh57eSZ6J1oYc--qfGmHRC6PLhrffFBQiM8,1631
-ipfabric_netbox/templates/ipfabric_netbox/ipfabricingestion.html,sha256=ctneF3bVY5ZMqry3SMWpX2UEsTmIM7k5sjEgT-s7LTk,5021
+ipfabric_netbox/templates/ipfabric_netbox/ipfabricingestion.html,sha256=fm_X2FLnoTS6s6AL3WmU6p3puDojROSkPG0jA4EBQeM,4435
 ipfabric_netbox/templates/ipfabric_netbox/ipfabricsnapshot.html,sha256=hj8ORs_4mM_xTjmw3McHN-da5seC8nbbkzobn0f1TSc,3482
 ipfabric_netbox/templates/ipfabric_netbox/ipfabricsource.html,sha256=koR_t6Mf2FhWlPZHchWsTOQDSLB7AWrqtY0TRnIzrrM,3864
 ipfabric_netbox/templates/ipfabric_netbox/ipfabricsync.html,sha256=BicVS7mCP85fFZJEt46GUm5xppi1Jw3byw1el9BB2WE,4448
@@ -51,10 +52,12 @@ ipfabric_netbox/templates/ipfabric_netbox/ipfabrictransformmap.html,sha256=qFo_K
 ipfabric_netbox/templates/ipfabric_netbox/ipfabrictransformmap_list.html,sha256=p8zqn0-B6mawSUM3zQrus6dsKUM5SRBTO0X94pLboX8,452
 ipfabric_netbox/templates/ipfabric_netbox/ipfabrictransformmap_restore.html,sha256=cuvOBKnlMudMI-CX77W3vTpwhtc4CBcc6j6Ye-IBBMQ,2562
 ipfabric_netbox/templates/ipfabric_netbox/ipfabrictransformmapgroup.html,sha256=H3uvjA4PdJq5uX2kizdHV1pAxwcPpyfc9IbJi1ZK5-k,975
-ipfabric_netbox/templates/ipfabric_netbox/partials/ingestion_all.html,sha256=FHMoHSnngsR_ZyypF6Ent8Tl-4kYDe1WTUIoehPYWEY,389
+ipfabric_netbox/templates/ipfabric_netbox/partials/ingestion_all.html,sha256=W9W31m8b7mGrsfu0f_hE1TcudDqSJ0G2Bp9JE4UTIIE,662
 ipfabric_netbox/templates/ipfabric_netbox/partials/ingestion_progress.html,sha256=NellDFy1qzgVbCtkOZbiSi3ufau6FOLIQPUoNiU6Bg4,595
-ipfabric_netbox/templates/ipfabric_netbox/partials/ingestion_status.html,sha256=mKXre8_-y6OYyoL_WFYyHuyxJrR4D40M2OT-r83zKEM,81
+ipfabric_netbox/templates/ipfabric_netbox/partials/ingestion_statistics.html,sha256=_KtbxZQlIa_141OQSIAvSsMMfZRkNj27kJqrYHuLt7Y,867
+ipfabric_netbox/templates/ipfabric_netbox/partials/ingestion_status.html,sha256=qYXe-V-kQn1INqCHLSSpdrzXJ_IIt84AgCgAGwqpNbs,178
 ipfabric_netbox/templates/ipfabric_netbox/partials/job_logs.html,sha256=PMZxxrRVzn_JI8k5XCNV5BQnoFj9zYePN6afP6C_J2E,1622
+ipfabric_netbox/templates/ipfabric_netbox/partials/object_tabs.html,sha256=3xbGy38Y1RH13bVPlcyj5L6J_FM-mOW1y0fx54hj1xE,364
 ipfabric_netbox/templates/ipfabric_netbox/partials/sync_last_ingestion.html,sha256=3v6tC88xE5cic9l9lQw7Msawoq-AW2oo2odd-osGv50,179
 ipfabric_netbox/templates/static/ipfabric_netbox/css/rack.css,sha256=z1H-RmmsqF2pGdhn5J64TMFiccy62xZUHHlCRd8fJrQ,118
 ipfabric_netbox/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -63,11 +66,11 @@ ipfabric_netbox/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 ipfabric_netbox/tests/test_models.py,sha256=4SGMX0LZ_fThkc-F1AMZIQbpmJvQNVFnS6QYZpIZkNA,14998
 ipfabric_netbox/urls.py,sha256=ok66LP09rYi01qJmwdGGlBzV9wrGWVwVAIngPcreJxg,5449
 ipfabric_netbox/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ipfabric_netbox/utilities/ipfutils.py,sha256=LNFNfwTAUkHb09PRExZHfRdiSubWvGHuZzvhBWHgA7Q,28675
+ipfabric_netbox/utilities/ipfutils.py,sha256=u7fn4HaBwhs8CXuoUsYv1CfFfSLN3JYc2ByeN0kjF8g,31370
 ipfabric_netbox/utilities/logging.py,sha256=GYknjocMN6LQ2873_az3y0RKm29TCXaWviUIIneH-x0,3445
 ipfabric_netbox/utilities/nbutils.py,sha256=kFBEiJOGvr_49hJWCS2duXojx2-A9kVk0Xp_vj0ohfs,2641
 ipfabric_netbox/utilities/transform_map.py,sha256=QotbGc2TksINJrb62STgAigpC5Nsgi5umYHu_0rZd8k,2204
-ipfabric_netbox/views.py,sha256=tPuceZgH2veu5ls4_avUiM9fuM5pYxr1KFWp5im5b0s,35898
-ipfabric_netbox-4.1.0b3.dist-info/METADATA,sha256=1RxqnpWrxYvqQai2wU5lbiUzIhhSFUwXmyS5dy8eVj8,4548
-ipfabric_netbox-4.1.0b3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-ipfabric_netbox-4.1.0b3.dist-info/RECORD,,
+ipfabric_netbox/views.py,sha256=nGWO-PlTyKviBzGEdmE3C_1I-xFjZMldqOWGx12wdbg,36855
+ipfabric_netbox-4.1.0b5.dist-info/METADATA,sha256=MeNMpz-OvdEyzOrg39PNkuGqbyXaKTVdHUR2Y8v4psg,4548
+ipfabric_netbox-4.1.0b5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+ipfabric_netbox-4.1.0b5.dist-info/RECORD,,