netbox-cisco-sync 1.0.1__py3-none-any.whl

netbox_cisco_sync/__init__.py

@@ -0,0 +1,86 @@
+"""Plugin NetBox synchronizujący inventory z obsługiwanych platform Cisco."""
+
+from netbox.plugins import PluginConfig
+
+__version__ = "1.0.1"
+
+DEFAULT_PLUGIN_SETTINGS = {
+    # Czas jednej zbiorczej sesji Refresh lub Apply, w sekundach.
+    "sync_session_timeout_seconds": 300,
+    # Pusty slug oznacza wybór pierwszego VLAN-u o szukanym VID, niezależnie od grupy.
+    "preferred_vlan_group_slug": "",
+    # Ustawienia vManage są oddzielone od innych źródeł, aby dodanie kolejnej
+    # platformy nie zmieniało niejawnie jej filtrów ani nazw obiektów NetBox.
+    "vmanage_ignored_interface_names": [
+        "nvi0",
+        "vmanage_system",
+        "null0",
+        "appnav-compress",
+    ],
+    "vmanage_ignored_interface_patterns": [
+        r"virtualportgroup\d+",
+        r"loopback655\d{2}",
+        r"service-engine.*",
+    ],
+    "vmanage_default_platform_name": "Cisco SD-WAN",
+    "vmanage_default_platform_slug": "sd-wan-cisco",
+    "vmanage_site_id_field": "SdwanSiteId",
+    "vmanage_controller_types": ["vmanage", "vsmart", "vbond", "vedge-vbond"],
+    "vmanage_edge_types": ["vedge", "cedge"],
+    # Catalyst Center korzysta z osobnych filtrów. Puste listy oznaczają, że
+    # domyślnie nie odrzucamy interfejsów na podstawie nazw właściwych SD-WAN.
+    "ccc_ignored_interface_names": [],
+    "ccc_ignored_interface_patterns": [],
+    "ccc_default_platform_name": "Cisco Catalyst Center",
+    "ccc_default_platform_slug": "cisco-catalyst-center",
+    "meraki_ignored_interface_names": [],
+    "meraki_ignored_interface_patterns": [],
+    "meraki_default_platform_name": "Cisco Meraki",
+    "meraki_default_platform_slug": "cisco-meraki",
+    "meraki_site_id_field": "MerakiSiteId",
+    # Dokładne mapowanie prędkości portu MS na wartości choices NetBox.
+    "meraki_speed_to_interface_type": {
+        100: "100base-tx",
+        1000: "1000base-t",
+        2500: "2.5gbase-t",
+        5000: "5gbase-t",
+        10000: "10gbase-t",
+        25000: "25gbase-x-sfp28",
+        40000: "40gbase-x-qsfpp",
+        100000: "100gbase-x-qsfp28",
+    },
+    "meraki_family_interface_types": {
+        "MS": "1000base-t",
+        "MX": "1000base-t",
+        "MR": "ieee802.11ax",
+        "MG": "lte",
+        "MV": "other",
+        "MT": "other",
+    },
+}
+
+
+class NetBoxCiscoSyncConfig(PluginConfig):
+    name = "netbox_cisco_sync"
+    label = "netbox_cisco_sync"
+    verbose_name = "NetBox Cisco Sync"
+    description = "Synchronize Cisco platform inventory into NetBox."
+    version = __version__
+    author = "Lukasz Luczak"
+    author_email = "bleblas@gmail.com"
+    base_url = "cisco-sync"
+    min_version = "4.6.0"
+    max_version = "4.6.99"
+    required_settings = []
+    default_settings = DEFAULT_PLUGIN_SETTINGS
+
+    def ready(self):
+        super().ready()
+        # Sam import rejestruje dekorowane zadania cykliczne w workerze NetBox.
+        from . import jobs  # noqa: F401
+
+
+# Tymczasowy alias zachowuje zgodność integracji importujących starą nazwę klasy.
+NetBoxVmanageSyncConfig = NetBoxCiscoSyncConfig
+
+config = NetBoxCiscoSyncConfig

netbox_cisco_sync/api/__init__.py

@@ -0,0 +1,3 @@
+from ..connectors.vmanage import VmanageClient, VmanageError
+
+__all__ = ("VmanageClient", "VmanageError")

netbox_cisco_sync/api/client.py

@@ -0,0 +1,5 @@
+"""Compatibility exports for the former vManage API client location."""
+
+from ..connectors.vmanage.client import VmanageClient, VmanageError
+
+__all__ = ("VmanageClient", "VmanageError")

netbox_cisco_sync/api/serializers.py

@@ -0,0 +1,164 @@
+"""Serializery REST API wymagane również przez change log NetBoxa."""
+
+from dcim.api.serializers import DeviceSerializer, SiteSerializer
+from netbox.api.serializers import NetBoxModelSerializer
+
+from ..models import (
+    CatalystCenterConfig,
+    DeviceCatalystCenterConfig,
+    DeviceMerakiConfig,
+    DeviceVmanageConfig,
+    DiscoveredInterface,
+    SyncRun,
+    VmanageSyncConfig,
+    MerakiConfig,
+)
+
+
+class DeviceVmanageConfigSerializer(NetBoxModelSerializer):
+    """Reprezentacja wykrytego urządzenia i jego mapowania do NetBoxa."""
+
+    netbox_site = SiteSerializer(nested=True, allow_null=True)
+    device = DeviceSerializer(nested=True, allow_null=True)
+
+    class Meta:
+        model = DeviceVmanageConfig
+        fields = (
+            "id", "url", "display", "system_ip", "vmanage_uuid", "hostname",
+            "serial_number", "device_model", "vmanage_site_id", "vmanage_site_name",
+            "latitude", "longitude", "device_groups", "reachability", "netbox_site",
+            "device", "match_method", "manual_site_override", "enabled",
+            "interface_selection", "interfaces_last_refreshed", "last_discovered",
+            "last_sync_at", "last_sync_status", "last_sync_message", "tags", "custom_fields",
+            "created", "last_updated",
+        )
+        brief_fields = ("id", "url", "display", "system_ip", "hostname", "device")
+
+
+class DeviceCatalystCenterConfigSerializer(NetBoxModelSerializer):
+    """Reprezentacja urządzenia wykrytego przez Catalyst Center."""
+
+    netbox_site = SiteSerializer(nested=True, allow_null=True)
+    device = DeviceSerializer(nested=True, allow_null=True)
+
+    class Meta:
+        model = DeviceCatalystCenterConfig
+        fields = (
+            "id", "url", "display", "catalyst_id", "management_ip", "hostname",
+            "serial_number", "switch_stack_serials", "switch_stack_info", "device_model",
+            "catalyst_site_id", "catalyst_site_name",
+            "latitude", "longitude", "reachability", "catalyst_role", "catalyst_family", "netbox_site", "device",
+            "match_method", "manual_site_override", "enabled",
+            "interface_selection", "interfaces_last_refreshed", "last_discovered",
+            "last_sync_at", "last_sync_status", "last_sync_message", "tags", "custom_fields",
+            "created", "last_updated",
+        )
+        brief_fields = ("id", "url", "display", "management_ip", "hostname", "device")
+
+
+class DeviceMerakiConfigSerializer(NetBoxModelSerializer):
+    """Reprezentacja urządzenia wykrytego przez Meraki Dashboard."""
+    netbox_site = SiteSerializer(nested=True, allow_null=True)
+    device = DeviceSerializer(nested=True, allow_null=True)
+
+    class Meta:
+        model = DeviceMerakiConfig
+        fields = (
+            "id", "url", "display", "serial_number", "hostname", "device_model",
+            "product_family", "firmware", "network_id", "network_name", "management_ip",
+            "latitude", "longitude", "netbox_site", "device", "match_method",
+            "manual_site_override", "enabled", "interface_selection", "interfaces_last_refreshed",
+            "last_discovered", "last_sync_at",
+            "last_sync_status", "last_sync_message", "tags", "custom_fields", "created", "last_updated",
+        )
+        brief_fields = ("id", "url", "display", "serial_number", "hostname", "device")
+
+
+class DiscoveredInterfaceSerializer(NetBoxModelSerializer):
+    """Reprezentacja relacyjnego cache interfejsów platform źródłowych."""
+
+    class Meta:
+        model = DiscoveredInterface
+        fields = (
+            "id", "url", "display", "vmanage_config", "catalyst_config",
+            "meraki_config", "name", "normalized_name", "description", "label",
+            "interface_type", "admin_up", "oper_up", "mac_address",
+            "ipv4_address", "ipv4_mask", "ipv6_addresses", "mtu",
+            "speed_mbps", "vpn_id", "selected", "present", "last_seen",
+            "mode", "untagged_vlan", "tagged_vlans",
+            "bridge_name",
+            "tags", "custom_fields", "created", "last_updated",
+        )
+        brief_fields = ("id", "url", "display", "name", "selected", "present")
+
+
+class SyncRunSerializer(NetBoxModelSerializer):
+    """Historia Compare/Apply serializowana m.in. przed usunięciem rekordu."""
+
+    config = DeviceVmanageConfigSerializer(nested=True, allow_null=True)
+    catalyst_config = DeviceCatalystCenterConfigSerializer(nested=True, allow_null=True)
+    meraki_config = DeviceMerakiConfigSerializer(nested=True, allow_null=True)
+    device = DeviceSerializer(nested=True, allow_null=True)
+
+    class Meta:
+        model = SyncRun
+        fields = (
+            "id", "url", "display", "config", "catalyst_config", "meraki_config", "device", "trigger", "mode", "status",
+            "devices_created", "devices_updated", "interfaces_created", "interfaces_updated",
+            "ips_created", "macs_created", "fhrp_groups_created", "message",
+            "source_data",
+            "reverted", "tags", "custom_fields", "created", "last_updated",
+        )
+        brief_fields = ("id", "url", "display", "config", "catalyst_config", "meraki_config", "device", "mode", "status")
+
+
+class VmanageSyncConfigSerializer(NetBoxModelSerializer):
+    """Globalne ustawienia; hasło może być zapisane, ale nigdy zwrócone przez API."""
+
+    class Meta:
+        model = VmanageSyncConfig
+        fields = (
+            "id", "url", "display", "base_url", "username", "password", "verify_ssl",
+            "ca_bundle", "request_timeout", "request_retries", "update_existing",
+            "sync_interfaces", "ignore_disabled_interfaces", "sync_ipv4", "sync_ipv6",
+            "sync_mac_addresses", "set_primary_ips", "preferred_primary_ipv4_interface",
+            "sync_fhrp", "gps_max_distance_km", "default_device_role", "sync_interval_hours",
+            "history_keep_days", "tags", "custom_fields", "created", "last_updated",
+        )
+        brief_fields = ("id", "url", "display", "base_url", "username")
+        # Sekret jest akceptowany przy zapisie, ale nie może pojawić się w odpowiedzi
+        # API ani w serializowanym change logu NetBoxa.
+        extra_kwargs = {"password": {"write_only": True}}
+
+
+class CatalystCenterConfigSerializer(NetBoxModelSerializer):
+    """Ustawienia Catalyst Center z sekretem wyłącznie do zapisu."""
+
+    class Meta:
+        model = CatalystCenterConfig
+        fields = (
+            "id", "url", "display", "base_url", "username", "password", "verify_ssl",
+            "ca_bundle", "request_timeout", "request_retries", "enabled", "update_existing",
+            "sync_interfaces", "ignore_disabled_interfaces", "sync_ipv4", "sync_ipv6",
+            "sync_mac_addresses", "set_primary_ips", "preferred_primary_ipv4_interface",
+            "import_device_roles", "sync_fhrp", "default_device_role", "sync_interval_hours",
+            "gps_max_distance_km", "history_keep_days", "tags", "custom_fields", "created", "last_updated",
+        )
+        brief_fields = ("id", "url", "display", "base_url", "username", "enabled")
+        extra_kwargs = {"password": {"write_only": True}}
+
+
+class MerakiConfigSerializer(NetBoxModelSerializer):
+    """Ustawienia Meraki z kluczem API dostępnym wyłącznie przy zapisie."""
+    class Meta:
+        model = MerakiConfig
+        fields = (
+            "id", "url", "display", "enabled", "base_url", "api_key", "organization_ids",
+            "request_timeout", "request_retries", "update_existing", "sync_interfaces",
+            "ignore_disabled_interfaces", "sync_ipv4", "sync_ipv6", "sync_mac_addresses",
+            "set_primary_ips", "preferred_primary_ipv4_interface", "import_device_families",
+            "gps_max_distance_km", "default_device_role", "sync_interval_hours",
+            "history_keep_days", "tags", "custom_fields", "created", "last_updated",
+        )
+        brief_fields = ("id", "url", "display", "enabled", "base_url")
+        extra_kwargs = {"api_key": {"write_only": True}}

netbox_cisco_sync/api/urls.py

@@ -0,0 +1,26 @@
+"""Router REST API pluginu zgodny z automatycznym ładowaniem przez NetBox."""
+
+from netbox.api.routers import NetBoxRouter
+
+from .views import (
+    CatalystCenterConfigViewSet,
+    DeviceCatalystCenterConfigViewSet,
+    DeviceMerakiConfigViewSet,
+    DeviceVmanageConfigViewSet,
+    DiscoveredInterfaceViewSet,
+    SyncRunViewSet,
+    VmanageSyncConfigViewSet,
+    MerakiConfigViewSet,
+)
+
+router = NetBoxRouter()
+router.register("device-vmanage-configs", DeviceVmanageConfigViewSet)
+router.register("device-catalyst-center-configs", DeviceCatalystCenterConfigViewSet)
+router.register("device-meraki-configs", DeviceMerakiConfigViewSet)
+router.register("discovered-interfaces", DiscoveredInterfaceViewSet)
+router.register("sync-runs", SyncRunViewSet)
+router.register("settings", VmanageSyncConfigViewSet)
+router.register("catalyst-center-settings", CatalystCenterConfigViewSet)
+router.register("meraki-settings", MerakiConfigViewSet)
+
+urlpatterns = router.urls

netbox_cisco_sync/api/views.py

@@ -0,0 +1,71 @@
+"""ViewSety modeli pluginu dla REST API NetBoxa."""
+
+from netbox.api.viewsets import NetBoxModelViewSet
+
+from .. import filtersets
+from ..models import (
+    CatalystCenterConfig,
+    DeviceCatalystCenterConfig,
+    DeviceMerakiConfig,
+    DeviceVmanageConfig,
+    DiscoveredInterface,
+    SyncRun,
+    VmanageSyncConfig,
+    MerakiConfig,
+)
+from .serializers import (
+    CatalystCenterConfigSerializer,
+    DeviceCatalystCenterConfigSerializer,
+    DeviceMerakiConfigSerializer,
+    DeviceVmanageConfigSerializer,
+    DiscoveredInterfaceSerializer,
+    SyncRunSerializer,
+    VmanageSyncConfigSerializer,
+    MerakiConfigSerializer,
+)
+
+
+class DeviceVmanageConfigViewSet(NetBoxModelViewSet):
+    queryset = DeviceVmanageConfig.objects.select_related("netbox_site", "device")
+    serializer_class = DeviceVmanageConfigSerializer
+    filterset_class = filtersets.DeviceVmanageConfigFilterSet
+
+
+class DeviceCatalystCenterConfigViewSet(NetBoxModelViewSet):
+    queryset = DeviceCatalystCenterConfig.objects.select_related("netbox_site", "device")
+    serializer_class = DeviceCatalystCenterConfigSerializer
+    filterset_class = filtersets.DeviceCatalystCenterConfigFilterSet
+
+
+class DeviceMerakiConfigViewSet(NetBoxModelViewSet):
+    queryset = DeviceMerakiConfig.objects.select_related("netbox_site", "device")
+    serializer_class = DeviceMerakiConfigSerializer
+    filterset_class = filtersets.DeviceMerakiConfigFilterSet
+
+
+class DiscoveredInterfaceViewSet(NetBoxModelViewSet):
+    queryset = DiscoveredInterface.objects.all()
+    serializer_class = DiscoveredInterfaceSerializer
+
+
+class SyncRunViewSet(NetBoxModelViewSet):
+    queryset = SyncRun.objects.select_related("config", "device")
+    serializer_class = SyncRunSerializer
+    filterset_class = filtersets.SyncRunFilterSet
+
+
+class VmanageSyncConfigViewSet(NetBoxModelViewSet):
+    # Model jest singletonem, ale rejestracja ViewSetu jest potrzebna, aby NetBox
+    # potrafił znaleźć jego serializer podczas tworzenia change logu.
+    queryset = VmanageSyncConfig.objects.all()
+    serializer_class = VmanageSyncConfigSerializer
+
+
+class CatalystCenterConfigViewSet(NetBoxModelViewSet):
+    queryset = CatalystCenterConfig.objects.all()
+    serializer_class = CatalystCenterConfigSerializer
+
+
+class MerakiConfigViewSet(NetBoxModelViewSet):
+    queryset = MerakiConfig.objects.all()
+    serializer_class = MerakiConfigSerializer

netbox_cisco_sync/catalyst_services.py

@@ -0,0 +1,107 @@
+"""Application services for Catalyst Center discovery and collection."""
+
+from django.utils import timezone
+
+from dcim.models import Site
+
+from .choices import MatchMethodChoices
+from .connectors.catalyst_center import CatalystCenterConnector
+from .connectors.catalyst_center.collector import parse_device
+from .matcher import match_site, site_prefix_bindings
+from .models import CatalystCenterConfig, DeviceCatalystCenterConfig
+from .interface_cache import collect_cached_config
+
+
+def discover_catalyst_devices():
+    settings = CatalystCenterConfig.get()
+    if not settings.enabled:
+        raise RuntimeError("Catalyst Center integration is disabled in Settings.")
+    devices = CatalystCenterConnector(settings).connect().collect_inventory()
+    sites = list(Site.objects.all())
+    prefix_bindings = site_prefix_bindings(sites)
+    created = updated = 0
+    for row in devices:
+        config = DeviceCatalystCenterConfig.objects.filter(catalyst_id=row.uuid).first()
+        is_new = config is None
+        if is_new:
+            config = DeviceCatalystCenterConfig(catalyst_id=row.uuid, hostname=row.hostname)
+        config.management_ip = row.system_ip or None
+        config.hostname = row.hostname
+        config.serial_number = row.serial_number
+        config.switch_stack_serials = list(row.switch_stack_serials)
+        config.switch_stack_info = list(row.switch_stack_info)
+        config.device_model = row.model
+        config.catalyst_site_id = row.site_id
+        config.catalyst_site_name = row.site_name
+        config.latitude = row.latitude
+        config.longitude = row.longitude
+        config.reachability = row.reachability
+        config.catalyst_role = row.source_role
+        config.catalyst_family = row.source_family
+        config.last_discovered = timezone.now()
+        if not config.manual_site_override:
+            # ID Building z CCC nie jest identyfikatorem SdwanSiteId używanym przez
+            # vManage, dlatego dla CCC stosujemy nazwę, a następnie odległość GPS.
+            site, method = match_site(
+                row,
+                sites,
+                settings.gps_max_distance_km,
+                use_custom_field=False,
+                prefix_bindings=prefix_bindings,
+            )
+            config.netbox_site = site
+            config.match_method = method
+        elif config.netbox_site_id:
+            config.match_method = MatchMethodChoices.MANUAL
+        config.save()
+        created += int(is_new)
+        updated += int(not is_new)
+    return {"seen": len(devices), "created": created, "updated": updated}
+
+
+def catalyst_inventory_dto(config):
+    """Odtwórz podstawowe DTO Catalyst Center zapisane podczas Discovery."""
+    data = parse_device(
+        {
+            "id": config.catalyst_id,
+            "hostname": config.hostname,
+            "managementIpAddress": str(config.management_ip or ""),
+            "serialNumber": config.serial_number,
+            "serialNumbers": [config.serial_number, *config.switch_stack_serials],
+            "stackSwitchInfo": config.switch_stack_info,
+            "platformId": config.device_model,
+            "reachabilityStatus": config.reachability,
+            "role": config.catalyst_role,
+            "family": config.catalyst_family,
+        },
+        {
+            "id": config.catalyst_site_id,
+            "name": config.catalyst_site_name,
+            "latitude": float(config.latitude) if config.latitude is not None else None,
+            "longitude": float(config.longitude) if config.longitude is not None else None,
+        },
+    )
+    return data
+
+
+def collect_catalyst_config(
+    config,
+    *,
+    settings=None,
+    include_unselected=False,
+    force_refresh=False,
+    refresh_missing=True,
+):
+    """Zwróć Catalyst Center DTO przez wspólny przepływ cache."""
+    settings = settings or CatalystCenterConfig.get()
+    data = catalyst_inventory_dto(config)
+
+    def collect():
+        """Odpytaj connector wyłącznie przy jawnym odświeżeniu lub pustym cache."""
+        connector = CatalystCenterConnector(settings).connect()
+        return connector.collect_device(data)
+
+    return collect_cached_config(
+        config, data, settings, collect, include_unselected=include_unselected,
+        force_refresh=force_refresh, refresh_missing=refresh_missing,
+    )

netbox_cisco_sync/choices.py

@@ -0,0 +1,40 @@
+"""Wspólne zestawy wyborów dla modeli, formularzy, tabel i silnika synchronizacji."""
+
+from utilities.choices import ChoiceSet
+
+
+class MatchMethodChoices(ChoiceSet):
+    MANUAL = "manual"
+    CUSTOM_FIELD = "custom_field"
+    NAME = "name"
+    GPS = "gps"
+    PRIMARY_IP = "primary_ip"
+    UNMATCHED = "unmatched"
+
+    CHOICES = (
+        (MANUAL, "Manual", "blue"),
+        (CUSTOM_FIELD, "SdwanSiteId", "green"),
+        (NAME, "Site name", "cyan"),
+        (GPS, "GPS", "purple"),
+        (PRIMARY_IP, "Primary IP prefix", "indigo"),
+        (UNMATCHED, "Unmatched", "orange"),
+    )
+
+
+class SyncModeChoices(ChoiceSet):
+    COMPARE = "compare"
+    APPLY = "apply"
+    CHOICES = ((COMPARE, "Compare", "cyan"), (APPLY, "Apply", "green"))
+
+
+class SyncStatusChoices(ChoiceSet):
+    OK = "ok"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+    CHOICES = ((OK, "OK", "green"), (FAILED, "Failed", "red"), (SKIPPED, "Skipped", "gray"))
+
+
+class SyncTriggerChoices(ChoiceSet):
+    MANUAL = "manual"
+    SCHEDULED = "scheduled"
+    CHOICES = ((MANUAL, "Manual", "blue"), (SCHEDULED, "Scheduled", "purple"))

netbox_cisco_sync/collector.py

@@ -0,0 +1,21 @@
+"""Compatibility facade for the former vManage collector location."""
+
+from .connectors.vmanage.collector import (
+    collect_details,
+    collect_inventory,
+    configured_device_types,
+    is_edge,
+    parse_device,
+    parse_interface,
+    parse_vrrp,
+)
+
+__all__ = (
+    "collect_details",
+    "collect_inventory",
+    "configured_device_types",
+    "is_edge",
+    "parse_device",
+    "parse_interface",
+    "parse_vrrp",
+)

netbox_cisco_sync/connectors/__init__.py

@@ -0,0 +1,5 @@
+"""Platform-specific data sources exposed through a common connector contract."""
+
+from .base import BaseConnector, ConnectorError
+
+__all__ = ("BaseConnector", "ConnectorError")

netbox_cisco_sync/connectors/base.py

@@ -0,0 +1,39 @@
+"""Wspólny kontrakt implementowany przez wszystkie źródła danych Cisco."""
+
+from abc import ABC, abstractmethod
+
+import requests
+
+
+class ConnectorError(RuntimeError):
+    """Kontrolowany błąd źródła, który można bezpiecznie pokazać w NetBox."""
+
+
+class BaseConnector(ABC):
+    """Minimalny kontrakt używany przez Discovery i usługi synchronizacji."""
+
+    source_type = ""
+
+    @abstractmethod
+    def connect(self):
+        """Uwierzytelnij połączenie i zwróć gotowy connector."""
+
+    @abstractmethod
+    def collect_inventory(self):
+        """Zwróć lekkie, znormalizowane rekordy urządzeń do Discovery."""
+
+    @abstractmethod
+    def collect_device(self, inventory_device):
+        """Uzupełnij jeden rekord inventory o szczegółowe dane źródłowe."""
+
+
+def init_controller_client(client, settings):
+    """Przygotuj sesję kontrolera bez ujawniania danych dostępowych w logach."""
+    client.base_url = settings.base_url.rstrip("/")
+    client.username = settings.username
+    client.password = settings.password
+    client.timeout = settings.request_timeout
+    client.retries = settings.request_retries
+    client.session = requests.Session()
+    client.session.verify = settings.ca_bundle or settings.verify_ssl
+    client.session.headers.update({"Accept": "application/json"})

netbox_cisco_sync/connectors/catalyst_center/__init__.py

@@ -0,0 +1,6 @@
+"""Cisco Catalyst Center connector."""
+
+from .client import CatalystCenterClient, CatalystCenterError
+from .connector import CatalystCenterConnector
+
+__all__ = ("CatalystCenterClient", "CatalystCenterConnector", "CatalystCenterError")