ntermqt 0.1.8__tar.gz → 0.1.9__tar.gz

{ntermqt-0.1.8/ntermqt.egg-info → ntermqt-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ntermqt
-Version: 0.1.8
+Version: 0.1.9
 Summary: Modern SSH terminal widget for PyQt6 with credential vault and jump host support
 Author: Scott Peterman
 License: GPL-3.0
@@ -112,7 +112,7 @@ nterm includes a built-in development console accessible via **Dev → IPython**
 
 ![IPython Console](https://raw.githubusercontent.com/scottpeterman/nterm/main/screenshots/ipython.png)
 
-![IPython Console](https://raw.githubusercontent.com/scottpeterman/nterm/main/screenshots/repl.png)
+![IPython Console](https://raw.githubusercontent.com/scottpeterman/nterm/main/screenshots/repl_dark3.png)
 
 The IPython console runs in the same Python environment as nterm, with the scripting API pre-loaded. Query your device inventory, inspect credentials, and prototype automation workflows without leaving the app.
 

{ntermqt-0.1.8 → ntermqt-0.1.9}/README.md

@@ -67,7 +67,7 @@ nterm includes a built-in development console accessible via **Dev → IPython**
 
 ![IPython Console](https://raw.githubusercontent.com/scottpeterman/nterm/main/screenshots/ipython.png)
 
-![IPython Console](https://raw.githubusercontent.com/scottpeterman/nterm/main/screenshots/repl.png)
+![IPython Console](https://raw.githubusercontent.com/scottpeterman/nterm/main/screenshots/repl_dark3.png)
 
 The IPython console runs in the same Python environment as nterm, with the scripting API pre-loaded. Query your device inventory, inspect credentials, and prototype automation workflows without leaving the app.
 

{ntermqt-0.1.8 → ntermqt-0.1.9}/nterm/scripting/api.py

@@ -19,13 +19,16 @@ from .models import ActiveSession, CommandResult, DeviceInfo, CredentialInfo
 from .platform_data import INTERFACE_DETAIL_FIELD_MAP
 from .platform_utils import (
     detect_platform,
+    detect_platform_from_template,
+    extract_platform_from_template_name,
     normalize_fields,
     get_paging_disable_command,
     get_platform_command,
     extract_version_info,
     extract_neighbor_info,
+    try_disable_paging,
 )
-from .ssh_connection import connect_ssh, send_command
+from .ssh_connection import connect_ssh, send_command, PagingNotDisabledError
 
 # TextFSM parsing - REQUIRED
 try:
@@ -397,10 +400,21 @@ class NTermAPI:
             prompt=prompt,
         )
 
-        # Detect platform
+        # Pre-emptively try to disable paging BEFORE platform detection
+        # This prevents 'show version' from being truncated by --More--
+        # Use the most common command - harmless if it fails on non-Cisco platforms
+        try:
+            send_command(shell, "terminal length 0", prompt, timeout=5)
+            if debug:
+                print(f"[DEBUG] Pre-emptive paging disable: terminal length 0")
+        except Exception as e:
+            if debug:
+                print(f"[DEBUG] Pre-emptive paging disable failed (normal on some platforms): {e}")
+
+        # Detect platform using TextFSM template matching (primary) or regex (fallback)
         try:
             version_output = send_command(shell, "show version", prompt)
-            platform = detect_platform(version_output)
+            platform = detect_platform(version_output, tfsm_engine=self._tfsm_engine)
             session.platform = platform
             if debug:
                 print(f"[DEBUG] Platform detected: {platform}")
@@ -413,9 +427,13 @@ class NTermAPI:
         if paging_cmd:
             try:
                 send_command(shell, paging_cmd, prompt, timeout=5)
+                session._paging_disabled = True
             except Exception as e:
                 if debug:
                     print(f"[DEBUG] Failed to disable paging: {e}")
+        else:
+            # Platform unknown - will try to auto-fix if paging error occurs
+            session._paging_disabled = False
 
         self._active_sessions[device_name] = session
         return session
@@ -472,6 +490,7 @@ class NTermAPI:
         timeout: int = 60,
         parse: bool = True,
         normalize: bool = True,
+        _retry_after_paging_fix: bool = False,
     ) -> CommandResult:
         """
         Send command to a connected session.
@@ -482,6 +501,7 @@ class NTermAPI:
             timeout: Command timeout in seconds
             parse: Whether to attempt TextFSM parsing
             normalize: Whether to normalize field names (requires parse=True)
+            _retry_after_paging_fix: Internal flag to prevent infinite retry loops
 
         Returns:
             CommandResult with raw and parsed output
@@ -495,12 +515,62 @@ class NTermAPI:
             if result.parsed_data:
                 for row in result.parsed_data:
                     print(row)
+
+        Note:
+            If paging is detected (--More-- prompt), the API will automatically
+            try to disable paging and retry the command once.
         """
         if not session.is_connected():
             raise RuntimeError(f"Session {session.device_name} is not connected")
 
         # Execute command using our refactored module
-        raw_output = send_command(session.shell, command, session.prompt, timeout)
+        try:
+            raw_output = send_command(session.shell, command, session.prompt, timeout)
+        except PagingNotDisabledError as e:
+            # Auto-recovery: try to disable paging and retry
+            if _retry_after_paging_fix:
+                # Already tried once, don't loop forever
+                raise RuntimeError(
+                    f"Paging still not disabled after auto-fix attempt. "
+                    f"Original error: {e}"
+                )
+
+            # Try to disable paging with multiple commands
+            print(f"[AUTO-FIX] Paging detected, attempting to disable...")
+
+            # Send Ctrl+C to break out of --More-- prompt
+            try:
+                session.shell.send('\x03')  # Ctrl+C
+                import time
+                time.sleep(0.5)
+                # Clear any pending output
+                while session.shell.recv_ready():
+                    session.shell.recv(65536)
+            except Exception:
+                pass
+
+            # Try multiple paging disable commands
+            success = try_disable_paging(
+                session.shell,
+                session.prompt,
+                send_command,
+                debug=True,
+            )
+
+            if success:
+                session._paging_disabled = True
+                print(f"[AUTO-FIX] Paging disabled, retrying command...")
+                # Retry the original command
+                return self.send(
+                    session, command, timeout, parse, normalize,
+                    _retry_after_paging_fix=True
+                )
+            else:
+                raise RuntimeError(
+                    f"Failed to auto-disable paging. "
+                    f"Tried multiple commands but none succeeded. "
+                    f"Original error: {e}"
+                )
 
         # Create result object
         result = CommandResult(
@@ -655,16 +725,22 @@ class NTermAPI:
         Disconnect a session.
 
         Args:
-            session: ActiveSession to close
+            session: ActiveSession to disconnect
         """
         if session.device_name in self._active_sessions:
             del self._active_sessions[session.device_name]
 
-        if session.shell:
-            session.shell.close()
+        try:
+            if session.shell:
+                session.shell.close()
+        except Exception:
+            pass
 
-        if session.client:
-            session.client.close()
+        try:
+            if session.client:
+                session.client.close()
+        except Exception:
+            pass
 
     def disconnect_all(self) -> int:
         """
@@ -674,60 +750,48 @@ class NTermAPI:
             Number of sessions disconnected
 
         Example:
-            # Cleanup at end of script
+            # At end of script or in finally block
             count = api.disconnect_all()
             print(f"Disconnected {count} session(s)")
         """
-        count = 0
-        for session_id in list(self._active_sessions.keys()):
+        count = len(self._active_sessions)
+
+        for session in list(self._active_sessions.values()):
             try:
-                session = self._active_sessions[session_id]
                 self.disconnect(session)
-                count += 1
             except Exception:
                 pass
+
+        self._active_sessions.clear()
         return count
 
     def active_sessions(self) -> List[ActiveSession]:
         """
-        Get list of currently active sessions.
+        List all active sessions.
 
         Returns:
             List of ActiveSession objects
         """
-        # Clean up stale sessions
-        active = []
-        stale = []
-
-        for session_id, session in self._active_sessions.items():
-            if session.is_connected():
-                active.append(session)
-            else:
-                stale.append(session_id)
-
-        # Remove stale entries
-        for session_id in stale:
-            del self._active_sessions[session_id]
-
-        return active
+        return list(self._active_sessions.values())
 
     # -------------------------------------------------------------------------
-    # Debug / diagnostic methods
+    # Diagnostics
     # -------------------------------------------------------------------------
 
     def db_info(self) -> Dict[str, Any]:
         """
-        Get detailed information about TextFSM database.
+        Get information about the TextFSM database.
 
         Returns:
-            Dict with database path, existence, and diagnostic info
+            Dict with db_path, db_exists, db_size, db_size_mb, etc.
         """
         info = {
-            "engine_available": self._tfsm_engine is not None,
+            "engine_initialized": self._tfsm_engine is not None,
             "db_path": None,
             "db_exists": False,
+            "db_size": None,
+            "db_size_mb": None,
             "db_absolute_path": None,
-            "current_working_directory": os.getcwd(),
         }
 
         if self._tfsm_engine and hasattr(self._tfsm_engine, 'db_path'):
@@ -816,6 +880,90 @@ class NTermAPI:
 
         return debug_info
 
+    def detect_platform_from_output(
+        self,
+        output: str,
+        min_score: float = 50.0,
+    ) -> Dict[str, Any]:
+        """
+        Detect platform from command output using TextFSM template matching.
+
+        This is the same method used internally during connect() for platform
+        detection. Useful for testing and debugging.
+
+        Args:
+            output: Raw command output (typically from 'show version')
+            min_score: Minimum match score to accept (default 50.0)
+
+        Returns:
+            Dict with:
+            - platform: Detected platform string or None
+            - template: Best matching template name
+            - score: Match confidence score
+            - method: 'textfsm' or 'regex' or 'none'
+            - parsed_data: Parsed data from template if available
+
+        Example:
+            >>> result = api.send(session, "show version", parse=False)
+            >>> api.detect_platform_from_output(result.raw_output)
+            {
+                'platform': 'cisco_ios',
+                'template': 'cisco_ios_show_version',
+                'score': 95.83,
+                'method': 'textfsm',
+                'parsed_data': [{'VERSION': '15.2(4)M11', ...}]
+            }
+        """
+        result = {
+            "platform": None,
+            "template": None,
+            "score": 0.0,
+            "method": "none",
+            "parsed_data": None,
+            "all_scores": None,
+        }
+
+        if not output:
+            result["error"] = "No output provided"
+            return result
+
+        # Try TextFSM template matching first
+        if self._tfsm_engine:
+            try:
+                best_template, parsed_data, best_score, all_scores = self._tfsm_engine.find_best_template(
+                    device_output=output,
+                    filter_string="show_version",
+                )
+
+                result["template"] = best_template
+                result["score"] = best_score
+                result["all_scores"] = all_scores
+                result["parsed_data"] = parsed_data
+
+                if best_template and best_score >= min_score:
+                    platform = extract_platform_from_template_name(best_template)
+                    if platform:
+                        result["platform"] = platform
+                        result["method"] = "textfsm"
+                        return result
+
+            except Exception as e:
+                result["textfsm_error"] = str(e)
+
+        # Fallback to regex
+        from .platform_data import PLATFORM_PATTERNS
+        import re
+
+        for platform, patterns in PLATFORM_PATTERNS.items():
+            for pattern in patterns:
+                if re.search(pattern, output, re.IGNORECASE):
+                    result["platform"] = platform
+                    result["method"] = "regex"
+                    result["regex_pattern"] = pattern
+                    return result
+
+        return result
+
     # -------------------------------------------------------------------------
     # Convenience / REPL helpers
     # -------------------------------------------------------------------------
@@ -912,6 +1060,7 @@ Command Results:
 
 Debugging:
   api.debug_parse(cmd, output, platform)  Debug why parsing failed
+  api.detect_platform_from_output(output) Detect platform from command output
   api.db_info()                    Show TextFSM database path and status
   
 Status:
@@ -919,6 +1068,21 @@ Status:
   api.vault_unlocked               Check vault status
   api._tfsm_engine                 TextFSM parser (required)
 
+Platform Detection:
+  Platform is detected automatically during connect() using:
+  1. TextFSM template matching (primary - more accurate)
+  2. Regex patterns (fallback)
+  
+  The API sends 'terminal length 0' before detection to prevent
+  paging issues. Template names like 'cisco_ios_show_version' 
+  tell us the platform directly.
+
+Auto-Recovery:
+  If paging (--More--) is detected, the API will automatically:
+  1. Send Ctrl+C to break out of the pager
+  2. Try multiple paging disable commands
+  3. Retry the original command
+
 Examples:
   # Connect and execute (manual)
   api.unlock("vault-password")

{ntermqt-0.1.8 → ntermqt-0.1.9}/nterm/scripting/platform_utils.py

@@ -19,16 +19,27 @@ from .platform_data import (
 )
 
 
-def detect_platform(version_output: str) -> Optional[str]:
+def detect_platform(version_output: str, tfsm_engine=None) -> Optional[str]:
     """
     Detect device platform from 'show version' output.
 
+    Uses TextFSM template matching as primary method (more accurate),
+    falls back to regex patterns if no template matches.
+
     Args:
         version_output: Raw output from 'show version' command
+        tfsm_engine: Optional TextFSMAutoEngine instance for template-based detection
 
     Returns:
         Platform string (e.g., 'cisco_ios', 'arista_eos') or None if not detected
     """
+    # Primary method: Use TextFSM template matching
+    if tfsm_engine is not None:
+        platform = detect_platform_from_template(version_output, tfsm_engine)
+        if platform:
+            return platform
+
+    # Fallback: Regex pattern matching
     for platform, patterns in PLATFORM_PATTERNS.items():
         for pattern in patterns:
             if re.search(pattern, version_output, re.IGNORECASE):
@@ -36,6 +47,140 @@ def detect_platform(version_output: str) -> Optional[str]:
     return None
 
 
+def detect_platform_from_template(
+    version_output: str,
+    tfsm_engine,
+    min_score: float = 50.0,
+) -> Optional[str]:
+    """
+    Detect platform by finding the best matching TextFSM template.
+
+    This is more accurate than regex because TextFSM templates are designed
+    to parse specific platform outputs structurally.
+
+    Args:
+        version_output: Raw output from 'show version' or similar command
+        tfsm_engine: TextFSMAutoEngine instance
+        min_score: Minimum match score to accept (default 50.0)
+
+    Returns:
+        Platform string extracted from template name, or None
+
+    Example:
+        Template 'cisco_ios_show_version' → returns 'cisco_ios'
+        Template 'arista_eos_show_version' → returns 'arista_eos'
+    """
+    if not tfsm_engine or not version_output:
+        return None
+
+    try:
+        # Try with show_version filter first
+        best_template, parsed_data, best_score, all_scores = tfsm_engine.find_best_template(
+            device_output=version_output,
+            filter_string="show_version",
+        )
+
+        if best_template and best_score >= min_score:
+            platform = extract_platform_from_template_name(best_template)
+            if platform:
+                return platform
+
+        # If show_version didn't match well, try without filter
+        # This catches show system info, show version detail, etc.
+        if not best_template or best_score < min_score:
+            best_template, parsed_data, best_score, all_scores = tfsm_engine.find_best_template(
+                device_output=version_output,
+                filter_string="",  # No filter - let it find best match
+            )
+
+            if best_template and best_score >= min_score:
+                platform = extract_platform_from_template_name(best_template)
+                if platform:
+                    return platform
+
+    except Exception:
+        pass  # Fall through to return None
+
+    return None
+
+
+def extract_platform_from_template_name(template_name: str) -> Optional[str]:
+    """
+    Extract platform identifier from a TextFSM template name.
+
+    Template names follow the pattern: {platform}_{command}
+    Examples:
+        'cisco_ios_show_version' → 'cisco_ios'
+        'arista_eos_show_interfaces' → 'arista_eos'
+        'juniper_junos_show_version' → 'juniper_junos'
+        'cisco_nxos_show_version' → 'cisco_nxos'
+
+    Args:
+        template_name: Full template name from TextFSM database
+
+    Returns:
+        Platform string or None if pattern not recognized
+    """
+    if not template_name:
+        return None
+
+    # Known platform prefixes (ordered by specificity - longer matches first)
+    known_platforms = [
+        'cisco_iosxr',
+        'cisco_iosxe',
+        'cisco_nxos',
+        'cisco_ios',
+        'cisco_asa',
+        'cisco_wlc',
+        'arista_eos',
+        'juniper_junos',
+        'juniper_screenos',
+        'hp_procurve',
+        'hp_comware',
+        'huawei_vrp',
+        'linux',
+        'paloalto_panos',
+        'fortinet_fortios',
+        'dell_force10',
+        'dell_os10',
+        'extreme_exos',
+        'extreme_nos',
+        'brocade_fastiron',
+        'brocade_netiron',
+        'ubiquiti_edgeswitch',
+        'mikrotik_routeros',
+        'vyos',
+        'alcatel_aos',
+        'alcatel_sros',
+        'checkpoint_gaia',
+        'enterasys',
+        'ruckus_fastiron',
+        'yamaha',
+        'zyxel_os',
+    ]
+
+    template_lower = template_name.lower()
+
+    for platform in known_platforms:
+        if template_lower.startswith(platform + '_'):
+            return platform
+
+    # Fallback: try to extract platform from template name pattern
+    # Assumes format: platform_command or platform_subplatform_command
+    parts = template_name.split('_')
+    if len(parts) >= 2:
+        # Try first two parts (handles cisco_ios, arista_eos, etc.)
+        potential_platform = f"{parts[0]}_{parts[1]}"
+        if potential_platform.lower() in [p.lower() for p in known_platforms]:
+            return potential_platform.lower()
+
+        # Try just first part for single-word platforms (linux, vyos)
+        if parts[0].lower() in [p.lower() for p in known_platforms]:
+            return parts[0].lower()
+
+    return None
+
+
 def get_platform_command(
     platform: Optional[str],
     command_type: str,
@@ -208,8 +353,65 @@ def extract_version_info(
 
     data = parsed_data[0]  # show version typically returns single row
 
-    # Get platform-specific or default field map
-    field_map = VERSION_FIELD_MAP.get(platform, DEFAULT_VERSION_FIELD_MAP) if platform else DEFAULT_VERSION_FIELD_MAP
+    # Platform-specific field mappings
+    # These override the generic mappings in platform_data.py when needed
+    PLATFORM_VERSION_FIELDS = {
+        'arista_eos': {
+            'version': ['IMAGE', 'VERSION', 'SOFTWARE_IMAGE', 'EOS_VERSION'],
+            'hardware': ['MODEL', 'HARDWARE', 'PLATFORM'],
+            'serial': ['SERIAL_NUMBER', 'SERIAL', 'SN'],
+            'uptime': ['UPTIME'],
+            'hostname': ['HOSTNAME'],
+        },
+        'cisco_ios': {
+            'version': ['VERSION', 'SOFTWARE_VERSION', 'ROMMON'],
+            'hardware': ['HARDWARE', 'MODEL', 'PLATFORM'],
+            'serial': ['SERIAL', 'SERIAL_NUMBER'],
+            'uptime': ['UPTIME'],
+            'hostname': ['HOSTNAME'],
+        },
+        'cisco_nxos': {
+            'version': ['OS', 'VERSION', 'NXOS_VERSION', 'KICKSTART_VERSION'],
+            'hardware': ['PLATFORM', 'HARDWARE', 'CHASSIS'],
+            'serial': ['SERIAL', 'SERIAL_NUMBER'],
+            'uptime': ['UPTIME'],
+            'hostname': ['HOSTNAME', 'DEVICE_NAME'],
+        },
+        'cisco_iosxe': {
+            'version': ['VERSION', 'ROMMON'],
+            'hardware': ['HARDWARE', 'MODEL', 'PLATFORM'],
+            'serial': ['SERIAL', 'SERIAL_NUMBER'],
+            'uptime': ['UPTIME'],
+            'hostname': ['HOSTNAME'],
+        },
+        'juniper_junos': {
+            'version': ['JUNOS_VERSION', 'VERSION'],
+            'hardware': ['MODEL', 'HARDWARE'],
+            'serial': ['SERIAL_NUMBER', 'SERIAL'],
+            'uptime': ['UPTIME', 'RE_UPTIME'],
+            'hostname': ['HOSTNAME'],
+        },
+    }
+
+    # Default field mapping (tries common field names)
+    DEFAULT_FIELDS = {
+        'version': ['VERSION', 'IMAGE', 'SOFTWARE_VERSION', 'SOFTWARE_IMAGE', 'OS', 'ROMMON'],
+        'hardware': ['HARDWARE', 'MODEL', 'PLATFORM', 'CHASSIS'],
+        'serial': ['SERIAL', 'SERIAL_NUMBER', 'SN'],
+        'uptime': ['UPTIME'],
+        'hostname': ['HOSTNAME', 'DEVICE_NAME'],
+    }
+
+    # Get platform-specific mapping or fall back to defaults
+    if platform and platform in PLATFORM_VERSION_FIELDS:
+        field_map = PLATFORM_VERSION_FIELDS[platform]
+    else:
+        # Try to load from platform_data if available
+        try:
+            loaded_map = VERSION_FIELD_MAP.get(platform, DEFAULT_VERSION_FIELD_MAP) if platform else DEFAULT_VERSION_FIELD_MAP
+            field_map = loaded_map if loaded_map else DEFAULT_FIELDS
+        except (NameError, TypeError):
+            field_map = DEFAULT_FIELDS
 
     return extract_fields(data, field_map, defaults={
         'version': 'unknown',
@@ -317,6 +519,70 @@ def get_paging_disable_command(platform: Optional[str]) -> Optional[str]:
     return None
 
 
+def get_paging_disable_commands_to_try() -> List[str]:
+    """
+    Get list of paging disable commands to try when platform is unknown.
+
+    Returns a prioritized list of commands that cover most network platforms.
+    Commands are ordered by likelihood of success across vendors.
+
+    Returns:
+        List of paging disable commands to try in order
+    """
+    return [
+        # Cisco IOS/IOS-XE/NX-OS, Arista EOS (most common)
+        "terminal length 0",
+        # Cisco alternative
+        "terminal pager 0",
+        # Juniper JUNOS
+        "set cli screen-length 0",
+        # Some Cisco platforms
+        "screen-length 0",
+        # HP/Aruba
+        "no page",
+        # Huawei
+        "screen-length 0 temporary",
+        # Extreme
+        "disable clipaging",
+        # Dell/Force10
+        "terminal length 0",
+    ]
+
+
+def try_disable_paging(shell, prompt, send_command_func, debug: bool = False) -> bool:
+    """
+    Try multiple commands to disable terminal paging.
+
+    Used for auto-recovery when PagingNotDisabledError is raised.
+
+    Args:
+        shell: Active SSH channel
+        prompt: Device prompt
+        send_command_func: Function to send commands (ssh_connection.send_command)
+        debug: Print debug info
+
+    Returns:
+        True if any command succeeded (didn't raise exception), False if all failed
+    """
+    commands = get_paging_disable_commands_to_try()
+
+    for cmd in commands:
+        try:
+            if debug:
+                print(f"[PAGING] Trying: {cmd}")
+            # Short timeout - these commands should return quickly
+            send_command_func(shell, cmd, prompt, timeout=5)
+            if debug:
+                print(f"[PAGING] Success: {cmd}")
+            return True
+        except Exception as e:
+            if debug:
+                print(f"[PAGING] Failed: {cmd} - {e}")
+            continue
+
+    return False
+
+
 def sanitize_filename(name: str) -> str:
     """
     Make a device name safe for use in filenames.