netbox-toolkit-plugin 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

netbox_toolkit_plugin/connectors/__init__.py

@@ -1,15 +1,15 @@
 """Connectors package for device connection logic."""
 
-from .base import BaseDeviceConnector, ConnectionConfig, CommandResult
-from .scrapli_connector import ScrapliConnector
-from .netmiko_connector import NetmikoConnector
+from .base import BaseDeviceConnector, CommandResult, ConnectionConfig
 from .factory import ConnectorFactory
+from .netmiko_connector import NetmikoConnector
+from .scrapli_connector import ScrapliConnector
 
 __all__ = [
-    'BaseDeviceConnector',
-    'ConnectionConfig',
-    'CommandResult',
-    'ScrapliConnector',
-    'NetmikoConnector',
-    'ConnectorFactory',
+    "BaseDeviceConnector",
+    "ConnectionConfig",
+    "CommandResult",
+    "ScrapliConnector",
+    "NetmikoConnector",
+    "ConnectorFactory",
 ]

netbox_toolkit_plugin/connectors/base.py

@@ -1,14 +1,14 @@
 """Base connector interface for device connections."""
+
 from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional
 from dataclasses import dataclass
-
-from ..exceptions import DeviceConnectionError, CommandExecutionError
+from typing import Any
 
 
 @dataclass
 class ConnectionConfig:
     """Configuration for device connections."""
+
     hostname: str
     username: str
     password: str
@@ -17,81 +17,80 @@ class ConnectionConfig:
     timeout_transport: int = 15
     timeout_ops: int = 30
     auth_strict_key: bool = False
-    transport: str = 'system'  # Default to system transport for Scrapli
-    platform: Optional[str] = None
-    extra_options: Optional[Dict[str, Any]] = None
+    transport: str = "system"  # Default to system transport for Scrapli
+    platform: str | None = None
+    extra_options: dict[str, Any] | None = None
 
 
 @dataclass
 class CommandResult:
     """Result of command execution."""
+
     command: str
     output: str
     success: bool
-    error_message: Optional[str] = None
-    execution_time: Optional[float] = None
+    error_message: str | None = None
+    execution_time: float | None = None
     # New fields for syntax error detection
     has_syntax_error: bool = False
-    syntax_error_type: Optional[str] = None
-    syntax_error_vendor: Optional[str] = None
-    syntax_error_guidance: Optional[str] = None
+    syntax_error_type: str | None = None
+    syntax_error_vendor: str | None = None
+    syntax_error_guidance: str | None = None
     # New fields for command output parsing
-    parsed_output: Optional[Dict[str, Any]] = None
+    parsed_output: dict[str, Any] | None = None
     parsing_success: bool = False
-    parsing_method: Optional[str] = None  # 'textfsm', 'genie', 'ttp'
-    parsing_error: Optional[str] = None
+    parsing_method: str | None = None  # 'textfsm', 'genie', 'ttp'
+    parsing_error: str | None = None
 
 
 class BaseDeviceConnector(ABC):
     """Abstract base class for device connectors."""
-    
+
     def __init__(self, config: ConnectionConfig):
         self.config = config
         self._connection = None
-    
+
     @abstractmethod
     def connect(self) -> None:
         """Establish connection to the device."""
-        pass
-    
+
     @abstractmethod
     def disconnect(self) -> None:
         """Close connection to the device."""
-        pass
-    
+
     @abstractmethod
-    def execute_command(self, command: str, command_type: str = 'show') -> CommandResult:
+    def execute_command(
+        self, command: str, command_type: str = "show"
+    ) -> CommandResult:
         """Execute a command on the device.
-        
+
         Args:
             command: The command string to execute
             command_type: Type of command ('show' or 'config') for proper handling
-            
+
         Returns:
             CommandResult with execution details
         """
-        pass
-    
+
     @abstractmethod
     def is_connected(self) -> bool:
         """Check if connection is active."""
-        pass
-    
+
     def __enter__(self):
         """Context manager entry."""
         self.connect()
         return self
-    
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Context manager exit."""
         self.disconnect()
-    
+
     @property
     def hostname(self) -> str:
         """Get the hostname for this connection."""
         return self.config.hostname
-    
+
     @property
-    def platform(self) -> Optional[str]:
+    def platform(self) -> str | None:
         """Get the platform for this connection."""
         return self.config.platform

netbox_toolkit_plugin/connectors/factory.py

@@ -1,17 +1,13 @@
 """Factory for creating device connectors."""
 
-import logging
-from typing import Type, Optional
-
-from django.db.models import Model
 from dcim.models import Device
 
-from ..exceptions import UnsupportedPlatformError, DeviceConnectionError
+from ..exceptions import DeviceConnectionError, UnsupportedPlatformError
 from ..settings import ToolkitSettings
 from ..utils.logging import get_toolkit_logger
 from .base import BaseDeviceConnector, ConnectionConfig
-from .scrapli_connector import ScrapliConnector
 from .netmiko_connector import NetmikoConnector
+from .scrapli_connector import ScrapliConnector
 
 logger = get_toolkit_logger(__name__)
 
@@ -59,7 +55,7 @@ class ConnectorFactory:
         device: Device,
         username: str,
         password: str,
-        connector_type: Optional[str] = None,
+        connector_type: str | None = None,
         use_fallback: bool = True,
     ) -> BaseDeviceConnector:
         """
@@ -145,7 +141,9 @@ class ConnectorFactory:
                 )
                 return cls._create_fallback_connector(config, device.name, error_msg)
             else:
-                raise DeviceConnectionError(f"Connector creation failed: {error_msg}")
+                raise DeviceConnectionError(
+                    f"Connector creation failed: {error_msg}"
+                ) from e
 
     @classmethod
     def _create_fallback_connector(
@@ -169,11 +167,11 @@ class ConnectorFactory:
             raise DeviceConnectionError(
                 f"Both connectors failed. Primary error: {primary_error}. "
                 f"Fallback error: {str(fallback_error)}"
-            )
+            ) from fallback_error
 
     @classmethod
     def _prepare_connector_config(
-        cls, base_config: ConnectionConfig, connector_class: Type[BaseDeviceConnector]
+        cls, base_config: ConnectionConfig, connector_class: type[BaseDeviceConnector]
     ) -> ConnectionConfig:
         """Prepare a clean configuration for a specific connector type."""
         # Create a copy of the base config
@@ -262,7 +260,7 @@ class ConnectorFactory:
         return config
 
     @classmethod
-    def _get_connector_by_type(cls, connector_type: str) -> Type[BaseDeviceConnector]:
+    def _get_connector_by_type(cls, connector_type: str) -> type[BaseDeviceConnector]:
         """Get connector class by explicit type."""
         connector_type_lower = connector_type.lower()
         if connector_type_lower == "scrapli":
@@ -276,8 +274,8 @@ class ConnectorFactory:
 
     @classmethod
     def _get_primary_connector_by_platform(
-        cls, platform: Optional[str]
-    ) -> Type[BaseDeviceConnector]:
+        cls, platform: str | None
+    ) -> type[BaseDeviceConnector]:
         """Get primary connector class by device platform."""
         if not platform:
             return cls.PRIMARY_CONNECTOR
@@ -301,8 +299,8 @@ class ConnectorFactory:
 
     @classmethod
     def _get_connector_by_platform(
-        cls, platform: Optional[str]
-    ) -> Type[BaseDeviceConnector]:
+        cls, platform: str | None
+    ) -> type[BaseDeviceConnector]:
         """Legacy method for backward compatibility."""
         return cls._get_primary_connector_by_platform(platform)
 
@@ -331,7 +329,7 @@ class ConnectorFactory:
             return True
 
         # Check partial matches
-        for supported_platform in cls.CONNECTOR_MAP.keys():
+        for supported_platform in cls.CONNECTOR_MAP:
             if (
                 platform_lower in supported_platform
                 or supported_platform in platform_lower
@@ -339,17 +337,15 @@ class ConnectorFactory:
                 return True
 
         # Check if either connector supports it
-        if platform_lower in [
-            p.lower() for p in ScrapliConnector.get_supported_platforms()
-        ] or platform_lower in [
-            p.lower() for p in NetmikoConnector.get_supported_platforms()
-        ]:
-            return True
-
-        return False
+        return bool(
+            platform_lower
+            in [p.lower() for p in ScrapliConnector.get_supported_platforms()]
+            or platform_lower
+            in [p.lower() for p in NetmikoConnector.get_supported_platforms()]
+        )
 
     @classmethod
-    def get_recommended_connector(cls, platform: Optional[str]) -> str:
+    def get_recommended_connector(cls, platform: str | None) -> str:
         """Get recommended connector type for a platform."""
         connector_class = cls._get_primary_connector_by_platform(platform)
         if connector_class == ScrapliConnector:

netbox_toolkit_plugin/connectors/netmiko_connector.py

@@ -1,27 +1,24 @@
 """Netmiko-based device connector implementation."""
 
 import time
-from typing import Dict, Any, Optional, Tuple
+from typing import Any
 
 from netmiko import ConnectHandler, SSHDetect
 from netmiko.exceptions import (
-    NetmikoTimeoutException,
     NetmikoAuthenticationException,
     NetmikoBaseException,
-    ConnectionException,
-    ConfigInvalidException,
+    NetmikoTimeoutException,
 )
 
-from .base import BaseDeviceConnector, ConnectionConfig, CommandResult
-from ..settings import ToolkitSettings
 from ..exceptions import (
-    DeviceConnectionError,
     CommandExecutionError,
-    UnsupportedPlatformError,
+    DeviceConnectionError,
 )
-from ..utils.network import validate_device_connectivity
+from ..settings import ToolkitSettings
 from ..utils.error_parser import VendorErrorParser
 from ..utils.logging import get_toolkit_logger
+from ..utils.network import validate_device_connectivity
+from .base import BaseDeviceConnector, CommandResult, ConnectionConfig
 
 logger = get_toolkit_logger(__name__)
 
@@ -71,7 +68,7 @@ class NetmikoConnector(BaseDeviceConnector):
             f"Initialized NetmikoConnector for {config.hostname} with platform '{config.platform}'"
         )
 
-    def _filter_valid_netmiko_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
+    def _filter_valid_netmiko_params(self, params: dict[str, Any]) -> dict[str, Any]:
         """Filter parameters to only include those supported by Netmiko."""
         # Define valid Netmiko connection parameters
         valid_netmiko_params = {
@@ -182,7 +179,7 @@ class NetmikoConnector(BaseDeviceConnector):
             logger.warning(f"Auto-detection error for {self.config.hostname}: {str(e)}")
             return "generic_termserver"
 
-    def _build_connection_params(self) -> Dict[str, Any]:
+    def _build_connection_params(self) -> dict[str, Any]:
         """Build connection parameters for Netmiko."""
         device_type = self._get_device_type()
 
@@ -247,7 +244,6 @@ class NetmikoConnector(BaseDeviceConnector):
 
         max_retries = self._retry_config["max_retries"]
         retry_delay = self._retry_config["retry_delay"]
-        last_error = None
 
         for attempt in range(max_retries + 1):
             try:
@@ -280,10 +276,9 @@ class NetmikoConnector(BaseDeviceConnector):
                 logger.error(
                     f"Authentication failed for {self.config.hostname}: {str(e)}"
                 )
-                raise DeviceConnectionError(f"Authentication failed: {str(e)}")
+                raise DeviceConnectionError(f"Authentication failed: {str(e)}") from e
 
             except NetmikoTimeoutException as e:
-                last_error = e
                 logger.warning(
                     f"Connection timeout for {self.config.hostname}: {str(e)}"
                 )
@@ -291,21 +286,21 @@ class NetmikoConnector(BaseDeviceConnector):
                 if attempt >= max_retries:
                     raise DeviceConnectionError(
                         f"Connection timeout after {max_retries + 1} attempts: {str(e)}"
-                    )
+                    ) from e
 
             except NetmikoBaseException as e:
-                last_error = e
                 logger.warning(f"Netmiko error for {self.config.hostname}: {str(e)}")
 
                 if attempt >= max_retries:
-                    raise DeviceConnectionError(f"Netmiko connection failed: {str(e)}")
+                    raise DeviceConnectionError(
+                        f"Netmiko connection failed: {str(e)}"
+                    ) from e
 
             except Exception as e:
-                last_error = e
                 logger.warning(f"Unexpected error for {self.config.hostname}: {str(e)}")
 
                 if attempt >= max_retries:
-                    raise DeviceConnectionError(f"Connection failed: {str(e)}")
+                    raise DeviceConnectionError(f"Connection failed: {str(e)}") from e
 
     def disconnect(self) -> None:
         """Close connection to the device."""
@@ -423,7 +418,7 @@ class NetmikoConnector(BaseDeviceConnector):
                 execution_time=execution_time,
             )
 
-    def _execute_show_command(self, command: str) -> Tuple[str, Optional[list]]:
+    def _execute_show_command(self, command: str) -> tuple[str, list | None]:
         """Execute a show/display command and return both raw output and parsed data.
 
         Args:
@@ -441,8 +436,6 @@ class NetmikoConnector(BaseDeviceConnector):
             parsed_data = None
             try:
                 # Import textfsm here to avoid dependency issues if not installed
-                import textfsm
-                import os
                 from ntc_templates.parse import parse_output
 
                 # Try to parse using ntc-templates (which is what Netmiko uses)
@@ -475,20 +468,17 @@ class NetmikoConnector(BaseDeviceConnector):
 
         except Exception as e:
             logger.error(f"Show command failed: {str(e)}")
-            raise CommandExecutionError(f"Show command failed: {str(e)}")
+            raise CommandExecutionError(f"Show command failed: {str(e)}") from e
 
     def _execute_config_command(self, command: str) -> str:
         """Execute a configuration command."""
         try:
-            if isinstance(command, str):
-                commands = [command]
-            else:
-                commands = command
+            commands = [command] if isinstance(command, str) else command
 
             return self._connection.send_config_set(commands)
         except Exception as e:
             logger.error(f"Config command failed: {str(e)}")
-            raise CommandExecutionError(f"Config command failed: {str(e)}")
+            raise CommandExecutionError(f"Config command failed: {str(e)}") from e
 
     # Note: The _attempt_parsing method has been removed as parsing is now handled
     # directly in _execute_show_command to avoid re-executing commands on the device

netbox_toolkit_plugin/connectors/scrapli_connector.py

@@ -1,20 +1,15 @@
 """Scrapli-based device connector implementation."""
 
 import time
-from typing import Dict, Any, Type, Optional
+from typing import Any
 
-from scrapli.driver.core import IOSXEDriver, NXOSDriver, IOSXRDriver
+from scrapli.driver.core import IOSXEDriver, IOSXRDriver, NXOSDriver
 from scrapli.driver.generic import GenericDriver
-from scrapli.exceptions import ScrapliException
 
-from .base import BaseDeviceConnector, ConnectionConfig, CommandResult
-from ..settings import ToolkitSettings
 from ..exceptions import (
     DeviceConnectionError,
-    CommandExecutionError,
-    UnsupportedPlatformError,
 )
-from ..utils.network import validate_device_connectivity
+from ..settings import ToolkitSettings
 from ..utils.connection import (
     cleanup_connection_resources,
     validate_connection_health,
@@ -22,6 +17,8 @@ from ..utils.connection import (
 )
 from ..utils.error_parser import VendorErrorParser
 from ..utils.logging import get_toolkit_logger
+from ..utils.network import validate_device_connectivity
+from .base import BaseDeviceConnector, CommandResult, ConnectionConfig
 
 logger = get_toolkit_logger(__name__)
 
@@ -80,7 +77,7 @@ class ScrapliConnector(BaseDeviceConnector):
 
         return normalized
 
-    def _get_driver_class(self) -> Type:
+    def _get_driver_class(self) -> type:
         """Get the appropriate Scrapli driver class for the platform."""
         if not self.config.platform:
             logger.debug("No platform specified, using GenericDriver")
@@ -100,7 +97,7 @@ class ScrapliConnector(BaseDeviceConnector):
 
         return driver_class
 
-    def _build_connection_params(self) -> Dict[str, Any]:
+    def _build_connection_params(self) -> dict[str, Any]:
         """Build connection parameters for Scrapli."""
         # Use fast test timeouts for initial attempts if in fast fail mode
         if self._fast_fail_mode:
@@ -171,7 +168,7 @@ class ScrapliConnector(BaseDeviceConnector):
 
         return params
 
-    def _get_transport_options(self) -> Dict[str, Any]:
+    def _get_transport_options(self) -> dict[str, Any]:
         """Get transport-specific options for Scrapli."""
         ssh_options = ToolkitSettings.get_ssh_transport_options()
 
@@ -219,7 +216,9 @@ class ScrapliConnector(BaseDeviceConnector):
             logger.error(
                 f"Pre-connection validation failed for {self.config.hostname}: {str(e)}"
             )
-            raise DeviceConnectionError(f"Pre-connection validation failed: {str(e)}")
+            raise DeviceConnectionError(
+                f"Pre-connection validation failed: {str(e)}"
+            ) from e
 
         # Use fast-fail mode for first attempt to quickly detect incompatible scenarios
         self._fast_fail_mode = True
@@ -292,7 +291,9 @@ class ScrapliConnector(BaseDeviceConnector):
                 ):
                     logger.info(f"Fast-fail pattern detected: {error_msg}")
                     logger.info("Triggering immediate fallback to Netmiko")
-                    raise DeviceConnectionError(f"Fast-fail to Netmiko: {error_msg}")
+                    raise DeviceConnectionError(
+                        f"Fast-fail to Netmiko: {error_msg}"
+                    ) from None
 
                 # Clean up failed connection attempt
                 if self._connection:
@@ -308,7 +309,7 @@ class ScrapliConnector(BaseDeviceConnector):
                     logger.error(
                         f"All connection attempts failed for {self.config.hostname}: {error_msg}"
                     )
-                    raise DeviceConnectionError(error_msg)
+                    raise DeviceConnectionError(error_msg) from e
 
     def disconnect(self) -> None:
         """Close connection to the device with proper socket cleanup."""
@@ -320,7 +321,7 @@ class ScrapliConnector(BaseDeviceConnector):
                 logger.debug("Connection cleanup completed successfully")
             except Exception as e:
                 logger.warning(f"Error during connection cleanup: {str(e)}")
-                pass  # Cleanup error ignored
+                # Cleanup error ignored
             finally:
                 self._connection = None
                 # Give time for socket cleanup to complete
@@ -515,7 +516,7 @@ class ScrapliConnector(BaseDeviceConnector):
                 logger.debug(
                     "TextFSM parsing returned empty result (no matching template)"
                 )
-                pass  # TextFSM parsing returned empty result
+                # TextFSM parsing returned empty result
 
         except Exception as e:
             # TextFSM parsing failed - this is common for commands without templates

netbox_toolkit_plugin/exceptions.py

@@ -3,34 +3,27 @@
 
 class ToolkitError(Exception):
     """Base exception for toolkit-related errors."""
-    pass
 
 
 class DeviceConnectionError(ToolkitError):
     """Raised when device connection fails."""
-    pass
 
 
 class DeviceReachabilityError(DeviceConnectionError):
     """Raised when device is not reachable."""
-    pass
 
 
 class SSHBannerError(DeviceConnectionError):
     """Raised when SSH banner issues occur."""
-    pass
 
 
 class AuthenticationError(DeviceConnectionError):
     """Raised when authentication fails."""
-    pass
 
 
 class CommandExecutionError(ToolkitError):
     """Raised when command execution fails."""
-    pass
 
 
 class UnsupportedPlatformError(ToolkitError):
     """Raised when device platform is not supported."""
-    pass

netbox_toolkit_plugin/filtersets.py

@@ -1,85 +1,69 @@
-import django_filters
+from dcim.models import Device, Platform
 from netbox.filtersets import NetBoxModelFilterSet
-from dcim.models import Platform, Device
+
+import django_filters
+
 from .models import Command, CommandLog
 
+
 class CommandFilterSet(NetBoxModelFilterSet):
     """Enhanced filtering for commands"""
+
     platform_id = django_filters.ModelMultipleChoiceFilter(
         queryset=Platform.objects.all(),
-        label='Platform (ID)',
+        label="Platform (ID)",
     )
     platform_slug = django_filters.CharFilter(
-        field_name='platform__slug',
-        lookup_expr='icontains',
-        label='Platform slug'
+        field_name="platform__slug", lookup_expr="icontains", label="Platform slug"
     )
     command_type = django_filters.ChoiceFilter(
-        choices=[('show', 'Show Command'), ('config', 'Configuration Command')]
+        choices=[("show", "Show Command"), ("config", "Configuration Command")]
     )
     created_after = django_filters.DateTimeFilter(
-        field_name='created',
-        lookup_expr='gte'
+        field_name="created", lookup_expr="gte"
     )
     created_before = django_filters.DateTimeFilter(
-        field_name='created',
-        lookup_expr='lte'
+        field_name="created", lookup_expr="lte"
     )
     name_icontains = django_filters.CharFilter(
-        field_name='name',
-        lookup_expr='icontains',
-        label='Name contains'
+        field_name="name", lookup_expr="icontains", label="Name contains"
     )
     description_icontains = django_filters.CharFilter(
-        field_name='description',
-        lookup_expr='icontains',
-        label='Description contains'
+        field_name="description", lookup_expr="icontains", label="Description contains"
     )
 
     class Meta:
         model = Command
-        fields = ('name', 'platform', 'command_type', 'description')
+        fields = ("name", "platform", "command_type", "description")
+
 
 class CommandLogFilterSet(NetBoxModelFilterSet):
     """Enhanced filtering for command logs"""
+
     device_id = django_filters.ModelMultipleChoiceFilter(
-        queryset=Device.objects.all(),
-        label='Device (ID)'
+        queryset=Device.objects.all(), label="Device (ID)"
     )
     command_id = django_filters.ModelMultipleChoiceFilter(
-        queryset=Command.objects.all(),
-        label='Command (ID)'
+        queryset=Command.objects.all(), label="Command (ID)"
     )
     execution_time_after = django_filters.DateTimeFilter(
-        field_name='execution_time',
-        lookup_expr='gte'
+        field_name="execution_time", lookup_expr="gte"
     )
     execution_time_before = django_filters.DateTimeFilter(
-        field_name='execution_time',
-        lookup_expr='lte'
-    )
-    has_parsed_data = django_filters.BooleanFilter(
-        field_name='parsed_data',
-        lookup_expr='isnull',
-        exclude=True,
-        label='Has parsed data'
+        field_name="execution_time", lookup_expr="lte"
     )
     username_icontains = django_filters.CharFilter(
-        field_name='username',
-        lookup_expr='icontains',
-        label='Username contains'
+        field_name="username", lookup_expr="icontains", label="Username contains"
     )
     device_name_icontains = django_filters.CharFilter(
-        field_name='device__name',
-        lookup_expr='icontains',
-        label='Device name contains'
+        field_name="device__name", lookup_expr="icontains", label="Device name contains"
     )
     command_name_icontains = django_filters.CharFilter(
-        field_name='command__name',
-        lookup_expr='icontains',
-        label='Command name contains'
+        field_name="command__name",
+        lookup_expr="icontains",
+        label="Command name contains",
     )
 
     class Meta:
         model = CommandLog
-        fields = ('command', 'device', 'username', 'success', 'parsing_success')
+        fields = ("command", "device", "username", "success")