isptools-pro 3.0.0__py3-none-any.whl

autofix/__init__.py

@@ -0,0 +1,5 @@
+from .engine import AutoFixEngine
+from .permissions import PermissionManager, PermissionLevel
+from .rules import AUTOFIX_RULES
+
+__all__ = ["AutoFixEngine", "PermissionManager", "PermissionLevel", "AUTOFIX_RULES"]

autofix/engine.py

@@ -0,0 +1,91 @@
+import logging
+from .permissions import PermissionManager, PermissionLevel
+from .rules import AUTOFIX_RULES
+
+logger = logging.getLogger(__name__)
+
+class AutoFixEngine:
+    """Engine for automatically detecting and fixing network issues."""
+
+    def __init__(self, permission_manager: PermissionManager):
+        self.permission_manager = permission_manager
+        self.history = []
+
+    def analyze(self, device_host: str, stats: dict) -> list[dict]:
+        """Analyze stats against rules and return potential fixes."""
+        detected_problems = []
+        for rule in AUTOFIX_RULES:
+            if rule["trigger"](stats):
+                detected_problems.append({
+                    "name": rule["name"],
+                    "description": rule["description"],
+                    "fixes": rule["fixes"]
+                })
+        return detected_problems
+
+    def apply_fixes(self, driver, stats: dict) -> list[dict]:
+        """Analyze and apply allowed fixes."""
+        device_host = driver.device.host
+        device_type = driver.device.device_type
+        problems = self.analyze(device_host, stats)
+        results = []
+
+        for problem in problems:
+            for fix in problem["fixes"]:
+                # Check if fix applies to this device type
+                if fix["devices"] != ["all"] and device_type not in fix["devices"]:
+                    continue
+
+                action = fix["action"]
+                required_level = fix["permission"]
+                
+                # Request permission
+                if self.permission_manager.request_permission(action, device_host, required_level, problem["description"]):
+                    status = self._execute_fix(driver, action)
+                else:
+                    status = 'denied' if self.permission_manager.level < required_level else 'skipped'
+                
+                result = {
+                    "problem": problem["name"],
+                    "action": action,
+                    "status": status
+                }
+                self.history.append(result)
+                results.append(result)
+                
+                if status == 'applied':
+                    logger.info(f"AutoFix: Applied {action} to {device_host} for {problem['name']}")
+                else:
+                    logger.debug(f"AutoFix: {action} on {device_host} status: {status}")
+
+        return results
+
+    def _execute_fix(self, driver, action: str) -> str:
+        """Execute the actual fix on the driver."""
+        try:
+            if action == "reboot_device":
+                driver.reboot()
+                return 'applied'
+            elif action == "send_alert":
+                # Alerting is handled externally usually, but we mark as applied
+                return 'applied'
+            
+            # Call driver-specific methods
+            method = getattr(driver, action, None)
+            if method:
+                if method():
+                    return 'applied'
+                else:
+                    return 'failed'
+            else:
+                logger.warning(f"Driver {driver.__class__.__name__} does not implement {action}")
+                return 'failed'
+        except Exception as e:
+            logger.error(f"Error executing fix {action} on {driver.device.host}: {e}")
+            return 'failed'
+
+    def get_fix_log(self, device_host: str = None) -> list[dict]:
+        """Return history of all applied fixes."""
+        if device_host:
+            return [h for h in self.history if h.get('host') == device_host]
+        return self.history

autofix/permissions.py

@@ -0,0 +1,31 @@
+from enum import IntEnum
+
+class PermissionLevel(IntEnum):
+    READ_ONLY = 0       # فقط قراءة، بدون أي تعديل
+    SAFE_FIX = 1        # إصلاح آمن (restart interface, clear arp)
+    MODERATE_FIX = 2    # إصلاح متوسط (change tx power, channel)
+    FULL_AUTO = 3       # صلاحية كاملة (reboot, change config)
+
+class PermissionManager:
+    def __init__(self, level: PermissionLevel = PermissionLevel.READ_ONLY, require_confirm: bool = True):
+        self.level = level
+        self.require_confirm = require_confirm
+        self.confirm_callback = None
+
+    def set_confirm_callback(self, callback: callable):
+        """Set a callback function for confirmation. 
+        Callback receives: (action, device_host, details) -> returns bool
+        """
+        self.confirm_callback = callback
+
+    def request_permission(self, action: str, device_host: str, required_level: PermissionLevel, details: str = "") -> bool:
+        """Check if action is allowed based on current permission level and confirmation."""
+        if self.level < required_level:
+            return False
+        
+        if self.require_confirm:
+            if self.confirm_callback:
+                return self.confirm_callback(action, device_host, details)
+            return False # No callback set but confirmation required
+            
+        return True

autofix/rules.py

@@ -0,0 +1,64 @@
+from .permissions import PermissionLevel
+
+AUTOFIX_RULES = [
+    {
+        "name": "low_signal",
+        "trigger": lambda stats: stats.get("signal", 0) < -80,
+        "description": "Signal dropped below -80 dBm",
+        "fixes": [
+            {"action": "increase_tx_power", "permission": PermissionLevel.MODERATE_FIX, "devices": ["ubiquiti"]},
+            {"action": "send_alert", "permission": PermissionLevel.READ_ONLY, "devices": ["all"]},
+        ]
+    },
+    {
+        "name": "high_cpu",
+        "trigger": lambda stats: stats.get("cpu_load", 0) > 90,
+        "description": "CPU load exceeded 90%",
+        "fixes": [
+            {"action": "clear_connections", "permission": PermissionLevel.SAFE_FIX, "devices": ["mikrotik", "cisco"]},
+            {"action": "reboot_device", "permission": PermissionLevel.FULL_AUTO, "devices": ["all"]},
+        ]
+    },
+    {
+        "name": "interface_down",
+        "trigger": lambda stats: stats.get("interface_status") == "down",
+        "description": "Interface went down",
+        "fixes": [
+            {"action": "restart_interface", "permission": PermissionLevel.SAFE_FIX, "devices": ["all"]},
+        ]
+    },
+    {
+        "name": "high_noise",
+        "trigger": lambda stats: stats.get("noise", -95) > -85,
+        "description": "Noise floor too high",
+        "fixes": [
+            {"action": "change_channel", "permission": PermissionLevel.MODERATE_FIX, "devices": ["ubiquiti", "mikrotik"]},
+            {"action": "scan_best_channel", "permission": PermissionLevel.MODERATE_FIX, "devices": ["ubiquiti"]},
+        ]
+    },
+    {
+        "name": "low_ccq",
+        "trigger": lambda stats: stats.get("ccq", 100) < 60,
+        "description": "CCQ dropped below 60%",
+        "fixes": [
+            {"action": "reset_link", "permission": PermissionLevel.SAFE_FIX, "devices": ["ubiquiti"]},
+            {"action": "change_channel_width", "permission": PermissionLevel.MODERATE_FIX, "devices": ["ubiquiti"]},
+        ]
+    },
+    {
+        "name": "bandwidth_overload",
+        "trigger": lambda stats: stats.get("tx_bytes", 0) > 900_000_000,  # ~900 Mbps
+        "description": "Bandwidth near capacity",
+        "fixes": [
+            {"action": "enable_queue", "permission": PermissionLevel.MODERATE_FIX, "devices": ["mikrotik"]},
+        ]
+    },
+    {
+        "name": "arp_flood",
+        "trigger": lambda stats: stats.get("arp_entries", 0) > 500,
+        "description": "ARP table flooding",
+        "fixes": [
+            {"action": "clear_arp", "permission": PermissionLevel.SAFE_FIX, "devices": ["mikrotik"]},
+        ]
+    },
+]

core/__init__.py

@@ -0,0 +1,4 @@
+from .base import BaseDevice
+from .exceptions import ISPToolsError, ConnectionError, AuthenticationError, CommandError
+
+__all__ = ["BaseDevice", "ISPToolsError", "ConnectionError", "AuthenticationError", "CommandError"]

core/base.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+from ..models.device import Device
+from ..models.stats import DeviceStats
+from ..models.station import Station
+
+class BaseDevice(ABC):
+    """Abstract base class for all ISP device drivers."""
+
+    def __init__(self, device: Device):
+        self.device = device
+        self.is_connected = False
+
+    @abstractmethod
+    def connect(self) -> bool:
+        """Establish a connection to the device."""
+        pass
+
+    @abstractmethod
+    def disconnect(self):
+        """Close the connection to the device."""
+        pass
+
+    @abstractmethod
+    def get_stats(self) -> DeviceStats:
+        """Fetch device performance statistics."""
+        pass
+
+    @abstractmethod
+    def get_clients(self) -> List[Station]:
+        """Fetch connected stations/clients."""
+        pass
+
+    @abstractmethod
+    def get_signal(self) -> Dict[str, Any]:
+        """Fetch signal strength, noise, and CCQ for wireless devices."""
+        pass
+
+    @abstractmethod
+    def apply_config(self, config: Dict[str, Any]) -> bool:
+        """Apply a configuration to the device."""
+        pass
+
+    @abstractmethod
+    def reboot(self) -> bool:
+        """Reboot the device."""
+        pass

core/exceptions.py

@@ -0,0 +1,15 @@
+class ISPToolsError(Exception):
+    """Base exception for all isptools errors."""
+    pass
+
+class ConnectionError(ISPToolsError):
+    """Raised when connection to a device fails."""
+    pass
+
+class AuthenticationError(ISPToolsError):
+    """Raised when authentication fails."""
+    pass
+
+class CommandError(ISPToolsError):
+    """Raised when a command fails to execute on the device."""
+    pass

drivers/__init__.py

@@ -0,0 +1,6 @@
+from .mikrotik import MikroTikDriver
+from .ubiquiti import UbiquitiDriver
+from .cisco import CiscoDriver
+from .snmp import SNMPDriver
+
+__all__ = ["MikroTikDriver", "UbiquitiDriver", "CiscoDriver", "SNMPDriver"]

drivers/cisco.py

@@ -0,0 +1,165 @@
+import logging
+import re
+from typing import List, Dict, Any
+from datetime import datetime
+from netmiko import ConnectHandler
+from ..core.base import BaseDevice
+from ..core.exceptions import ConnectionError, AuthenticationError, CommandError
+from ..models.stats import DeviceStats
+from ..models.station import Station
+
+logger = logging.getLogger(__name__)
+
+class CiscoDriver(BaseDevice):
+    """Driver for Cisco devices using Netmiko (SSH)."""
+
+    def __init__(self, device):
+        super().__init__(device)
+        self.port = device.port or 22
+        self.connection = None
+
+    def connect(self) -> bool:
+        try:
+            device_params = {
+                'device_type': 'cisco_ios',
+                'host': self.device.host,
+                'username': self.device.username,
+                'password': self.device.password,
+                'port': self.port,
+            }
+            self.connection = ConnectHandler(**device_params)
+            self.is_connected = True
+            logger.info(f"Connected to Cisco device at {self.device.host}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect to Cisco at {self.device.host}: {e}")
+            raise ConnectionError(f"Cisco connection failed: {e}")
+
+    def disconnect(self):
+        if self.connection:
+            self.connection.disconnect()
+            self.is_connected = False
+            logger.info(f"Disconnected from Cisco device at {self.device.host}")
+
+    def get_stats(self) -> DeviceStats:
+        try:
+            # Get CPU load
+            cpu_output = self.connection.send_command("show processes cpu sorted | exclude 0.00%")
+            cpu_match = re.search(r"five seconds: (\d+)%", cpu_output)
+            cpu_load = float(cpu_match.group(1)) if cpu_match else 0.0
+
+            # Get Memory
+            mem_output = self.connection.send_command("show memory statistics")
+            mem_match = re.search(r"Processor.* (\d+) total,.* (\d+) used", mem_output)
+            if mem_match:
+                total_mem = int(mem_match.group(1))
+                used_mem = int(mem_match.group(2))
+                mem_used_pct = (used_mem / total_mem) * 100
+            else:
+                mem_used_pct = 0.0
+
+            # Get Interfaces/Bytes
+            int_output = self.connection.send_command("show interfaces")
+            tx_bytes = sum(int(b) for b in re.findall(r"(\d+) bytes output", int_output))
+            rx_bytes = sum(int(b) for b in re.findall(r"(\d+) bytes input", int_output))
+
+            # Get Uptime
+            ver_output = self.connection.send_command("show version")
+            uptime_match = re.search(r"uptime is (.*)", ver_output)
+            uptime = uptime_match.group(1) if uptime_match else ""
+
+            return DeviceStats(
+                timestamp=datetime.now(),
+                cpu_load=cpu_load,
+                memory_used=mem_used_pct,
+                tx_bytes=tx_bytes,
+                rx_bytes=rx_bytes,
+                uptime=uptime
+            )
+        except Exception as e:
+            raise CommandError(f"Failed to get stats from Cisco: {e}")
+
+    def get_clients(self) -> List[Station]:
+        try:
+            stations = []
+            # Try DHCP bindings first
+            dhcp_output = self.connection.send_command("show ip dhcp binding")
+            # Format: 192.168.1.10         0100.50b6.075c.e1       Feb 16 2026 12:00 PM    Automatic
+            dhcp_matches = re.findall(r"(\d+\.\d+\.\d+\.\d+)\s+([0-9a-f\.]+)", dhcp_output)
+            
+            for ip, mac in dhcp_matches:
+                stations.append(Station(mac=mac, ip=ip))
+            
+            # If no DHCP, try ARP
+            if not stations:
+                arp_output = self.connection.send_command("show arp")
+                # Format: Internet  192.168.1.1             -   0000.0c07.ac01  ARPA   FastEthernet0/0
+                arp_matches = re.findall(r"Internet\s+(\d+\.\d+\.\d+\.\d+)\s+.*?\s+([0-9a-f\.]+)", arp_output)
+                for ip, mac in arp_matches:
+                    stations.append(Station(mac=mac, ip=ip))
+
+            return stations
+        except Exception as e:
+            raise CommandError(f"Failed to get clients from Cisco: {e}")
+
+    def get_signal(self) -> Dict[str, Any]:
+        # Cisco is not wireless by default
+        return {}
+
+    def apply_config(self, config: Dict[str, Any]) -> bool:
+        try:
+            # Expecting config as a list of commands under 'commands' key
+            commands = config.get('commands', [])
+            if commands:
+                self.connection.send_config_set(commands)
+                return True
+            return False
+        except Exception as e:
+            raise CommandError(f"Failed to apply config to Cisco: {e}")
+
+    def reboot(self) -> bool:
+        try:
+            # reload command usually requires confirmation
+            self.connection.send_command("reload", expect_string=r"confirm")
+            self.connection.send_command("\n")
+            return True
+        except Exception as e:
+            logger.warning(f"Reboot command sent to Cisco, connection may drop: {e}")
+            return True
+
+    # --- AutoFix Actions ---
+
+    def restart_interface(self, name: str) -> bool:
+        """Shutdown and no shutdown an interface."""
+        try:
+            commands = [
+                f"interface {name}",
+                "shutdown",
+                "no shutdown"
+            ]
+            self.connection.send_config_set(commands)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to restart interface {name} on Cisco: {e}")
+            return False
+
+    def get_neighbors(self) -> List[Dict[str, Any]]:
+        """Get neighbors via LLDP."""
+        try:
+            output = self.connection.send_command("show lldp neighbors", use_textfsm=True)
+            # If textfsm is not available or fails, output is just a string
+            if isinstance(output, str):
+                # Simple regex parsing if textfsm fails
+                neighbors = []
+                matches = re.findall(r"(\S+)\s+(\S+)\s+\d+\s+.*?\s+(\S+)", output)
+                for neighbor_id, local_int, remote_int in matches:
+                    neighbors.append({
+                        "neighbor_id": neighbor_id,
+                        "local_interface": local_int,
+                        "neighbor_interface": remote_int
+                    })
+                return neighbors
+            return output
+        except Exception as e:
+            logger.error(f"Failed to get neighbors from Cisco: {e}")
+            return []

drivers/mikrotik.py

@@ -0,0 +1,179 @@
+import logging
+import time
+import routeros_api
+from typing import List, Dict, Any
+from datetime import datetime
+from ..core.base import BaseDevice
+from ..core.exceptions import ConnectionError, AuthenticationError, CommandError
+from ..models.stats import DeviceStats
+from ..models.station import Station
+
+logger = logging.getLogger(__name__)
+
+class MikroTikDriver(BaseDevice):
+    """Driver for MikroTik devices using RouterOS API."""
+
+    def __init__(self, device):
+        super().__init__(device)
+        self.port = device.port or 8728
+        self.connection = None
+        self.api = None
+
+    def connect(self) -> bool:
+        try:
+            self.connection = routeros_api.RouterOsApiConnection(
+                self.device.host,
+                username=self.device.username,
+                password=self.device.password,
+                port=self.port
+            )
+            self.api = self.connection.get_api()
+            self.is_connected = True
+            logger.info(f"Connected to MikroTik device at {self.device.host}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect to MikroTik at {self.device.host}: {e}")
+            raise ConnectionError(f"MikroTik connection failed: {e}")
+
+    def disconnect(self):
+        if self.connection:
+            self.connection.disconnect()
+            self.is_connected = False
+            logger.info(f"Disconnected from MikroTik device at {self.device.host}")
+
+    def get_stats(self) -> DeviceStats:
+        try:
+            resource = self.api.get_resource('/system/resource').get()[0]
+            interfaces = self.api.get_resource('/interface').get()
+            
+            tx_bytes = sum(int(i.get('tx-byte', 0)) for i in interfaces)
+            rx_bytes = sum(int(i.get('rx-byte', 0)) for i in interfaces)
+
+            return DeviceStats(
+                timestamp=datetime.now(),
+                cpu_load=float(resource.get('cpu-load', 0)),
+                memory_used=100 - (float(resource.get('free-memory', 0)) / float(resource.get('total-memory', 1)) * 100),
+                tx_bytes=tx_bytes,
+                rx_bytes=rx_bytes,
+                uptime=resource.get('uptime', ''),
+                temperature=float(resource.get('board-temperature1', 0)) or float(resource.get('cpu-temperature', 0))
+            )
+        except Exception as e:
+            raise CommandError(f"Failed to get stats from MikroTik: {e}")
+
+    def get_clients(self) -> List[Station]:
+        try:
+            stations = []
+            reg_table = self.api.get_resource('/interface/wireless/registration-table').get()
+            leases = self.api.get_resource('/ip/dhcp-server/lease').get()
+            
+            lease_map = {l.get('mac-address'): l.get('address', '') for l in leases}
+
+            for s in reg_table:
+                mac = s.get('mac-address')
+                stations.append(Station(
+                    mac=mac,
+                    ip=lease_map.get(mac, ''),
+                    signal=int(s.get('signal-strength', '0').split('dBm')[0]),
+                    noise=int(s.get('signal-to-noise', '0')), # Note: ROS might not provide direct noise in some versions
+                    ccq=int(s.get('tx-ccq', '0')),
+                    tx_rate=float(s.get('tx-rate', '0').split('Mbps')[0] or 0),
+                    rx_rate=float(s.get('rx-rate', '0').split('Mbps')[0] or 0),
+                    uptime=s.get('uptime', '')
+                ))
+            return stations
+        except Exception as e:
+            raise CommandError(f"Failed to get clients from MikroTik: {e}")
+
+    def get_signal(self) -> Dict[str, Any]:
+        try:
+            reg_table = self.api.get_resource('/interface/wireless/registration-table').get()
+            if not reg_table:
+                return {}
+            
+            # Returning stats for the first client as a summary, or could be averaged
+            s = reg_table[0]
+            return {
+                'signal': s.get('signal-strength'),
+                'noise': s.get('signal-to-noise'),
+                'ccq': s.get('tx-ccq')
+            }
+        except Exception as e:
+            raise CommandError(f"Failed to get signal from MikroTik: {e}")
+
+    def apply_config(self, config: Dict[str, Any]) -> bool:
+        try:
+            # Example: config = {'/ip/address': {'address': '1.1.1.1/24', 'interface': 'ether1'}}
+            for path, params in config.items():
+                resource = self.api.get_resource(path)
+                resource.set(**params)
+            return True
+        except Exception as e:
+            raise CommandError(f"Failed to apply config to MikroTik: {e}")
+
+    def reboot(self) -> bool:
+        try:
+            self.api.get_resource('/system/reboot').call('reboot')
+            return True
+        except Exception as e:
+            # Rebooting might break the connection and throw an error, which is expected
+            logger.warning(f"Reboot command sent to MikroTik, connection may drop: {e}")
+            return True
+
+    # --- AutoFix Actions ---
+
+    def clear_connections(self) -> bool:
+        """Remove all firewall connections."""
+        try:
+            resource = self.api.get_resource('/ip/firewall/connection')
+            conns = resource.get()
+            for conn in conns:
+                resource.remove(id=conn['.id'])
+            return True
+        except Exception as e:
+            logger.error(f"Failed to clear connections on MikroTik: {e}")
+            return False
+
+    def clear_arp(self) -> bool:
+        """Flush ARP table."""
+        try:
+            # ROS API doesn't have a direct 'flush' command exposed easily, we remove all dynamic entries
+            resource = self.api.get_resource('/ip/arp')
+            arps = resource.get()
+            for arp in arps:
+                if arp.get('dynamic') == 'true':
+                    resource.remove(id=arp['.id'])
+            return True
+        except Exception as e:
+            logger.error(f"Failed to clear ARP on MikroTik: {e}")
+            return False
+
+    def restart_interface(self, name: str = 'ether1') -> bool:
+        """Disable then enable an interface."""
+        try:
+            resource = self.api.get_resource('/interface')
+            resource.set(id=name, disabled='yes')
+            time.sleep(1)
+            resource.set(id=name, disabled='no')
+            return True
+        except Exception as e:
+            logger.error(f"Failed to restart interface {name} on MikroTik: {e}")
+            return False
+
+    def enable_queue(self, limit: str = '10M/10M') -> bool:
+        """Add a simple queue for bandwidth control."""
+        try:
+            resource = self.api.get_resource('/queue/simple')
+            resource.add(name='autofix-limit', target='0.0.0.0/0', max_limit=limit)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to enable queue on MikroTik: {e}")
+            return False
+
+    def get_neighbors(self) -> List[Dict[str, Any]]:
+        """Get neighbors via /ip/neighbor."""
+        try:
+            return self.api.get_resource('/ip/neighbor').get()
+        except Exception as e:
+            logger.error(f"Failed to get neighbors from MikroTik: {e}")
+            return []