scrapli 2023.7.30__py3-none-any.whl → 2024.7.30__py3-none-any.whl

scrapli/__init__.py

@@ -1,8 +1,9 @@
 """scrapli"""
+
 from scrapli.driver.base import AsyncDriver, Driver
 from scrapli.factory import AsyncScrapli, Scrapli
 
-__version__ = "2023.07.30"
+__version__ = "2024.07.30"
 
 __all__ = (
     "AsyncDriver",

scrapli/channel/__init__.py

@@ -1,4 +1,5 @@
 """scrapli.channel"""
+
 from scrapli.channel.async_channel import AsyncChannel
 from scrapli.channel.sync_channel import Channel
 

scrapli/channel/async_channel.py

@@ -1,4 +1,5 @@
 """scrapli.channel.async_channel"""
+
 import asyncio
 import re
 import time
@@ -10,6 +11,7 @@ from typing import AsyncIterator, List, Optional, Tuple
 from scrapli.channel.base_channel import BaseChannel, BaseChannelArgs
 from scrapli.decorators import timeout_wrapper
 from scrapli.exceptions import ScrapliAuthenticationFailed, ScrapliTimeout
+from scrapli.helper import output_roughly_contains_input
 from scrapli.transport.base import AsyncTransport
 
 
@@ -69,7 +71,7 @@ class AsyncChannel(BaseChannel):
         buf = await self.transport.read()
         buf = buf.replace(b"\r", b"")
 
-        self.logger.debug(f"read: {buf!r}")
+        self.logger.debug("read: %r", buf)
 
         if self.channel_log:
             self.channel_log.write(buf)
@@ -104,9 +106,16 @@ class AsyncChannel(BaseChannel):
         while True:
             buf += await self.read()
 
-            # replace any backspace chars (particular problem w/ junos), and remove any added spaces
-            # this is just for comparison of the inputs to what was read from channel
-            if processed_channel_input in b"".join(buf.lower().replace(b"\x08", b"").split()):
+            if not self._base_channel_args.comms_roughly_match_inputs:
+                # replace any backspace chars (particular problem w/ junos), and remove any added
+                # spaces this is just for comparison of the inputs to what was read from channel
+                # note (2024) this would be worked around by using the roughly contains search,
+                # *but* that is slower (probably immaterially for most people but... ya know...)
+                processed_buf = b"".join(buf.lower().replace(b"\x08", b"").split())
+
+                if processed_channel_input in processed_buf:
+                    return buf
+            elif output_roughly_contains_input(input_=processed_channel_input, output=buf):
                 return buf
 
     async def _read_until_prompt(self, buf: bytes = b"") -> bytes:
@@ -241,7 +250,7 @@ class AsyncChannel(BaseChannel):
 
             if (time.time() - start) > read_duration:
                 break
-            if any((channel_output in search_buf for channel_output in channel_outputs)):
+            if any(channel_output in search_buf for channel_output in channel_outputs):
                 break
             if re.search(pattern=regex_channel_outputs_pattern, string=search_buf):
                 break
@@ -455,6 +464,7 @@ class AsyncChannel(BaseChannel):
         *,
         strip_prompt: bool = True,
         eager: bool = False,
+        eager_input: bool = False,
     ) -> Tuple[bytes, bytes]:
         """
         Primary entry point to send data to devices in shell mode; accept input and returns result
@@ -465,6 +475,8 @@ class AsyncChannel(BaseChannel):
             eager: eager mode reads and returns the `_read_until_input` value, but does not attempt
                 to read to the prompt pattern -- this should not be used manually! (only used by
                 `send_configs` with the eager flag set)
+            eager_input: when true does *not* try to read our input off the channel -- generally
+                this should be left alone unless you know what you are doing!
 
         Returns:
             Tuple[bytes, bytes]: tuple of "raw" output and "processed" (cleaned up/stripped) output
@@ -479,12 +491,18 @@ class AsyncChannel(BaseChannel):
         bytes_channel_input = channel_input.encode()
 
         self.logger.info(
-            f"sending channel input: {channel_input}; strip_prompt: {strip_prompt}; eager: {eager}"
+            "sending channel input: %s; strip_prompt: %s; eager: %s",
+            channel_input,
+            strip_prompt,
+            eager,
         )
 
         async with self._channel_lock():
             self.write(channel_input=channel_input)
-            _buf_until_input = await self._read_until_input(channel_input=bytes_channel_input)
+
+            if not eager_input:
+                _buf_until_input = await self._read_until_input(channel_input=bytes_channel_input)
+
             self.send_return()
 
             if not eager:
@@ -531,8 +549,12 @@ class AsyncChannel(BaseChannel):
         ]
 
         self.logger.info(
-            f"sending channel input and read: {channel_input}; strip_prompt: {strip_prompt}; "
-            f"expected_outputs: {expected_outputs}; read_duration: {read_duration}"
+            "sending channel input and read: %s; strip_prompt: %s; "
+            "expected_outputs: %s; read_duration: %s",
+            channel_input,
+            strip_prompt,
+            expected_outputs,
+            read_duration,
         )
 
         async with self._channel_lock():
@@ -642,9 +664,10 @@ class AsyncChannel(BaseChannel):
 
                 _channel_input = channel_input if not hidden_input else "REDACTED"
                 self.logger.info(
-                    f"sending interactive input: {_channel_input}; "
-                    f"expecting: {channel_response}; "
-                    f"hidden_input: {hidden_input}"
+                    "sending interactive input: %s; expecting: %s; hidden_input: %s",
+                    _channel_input,
+                    channel_response,
+                    hidden_input,
                 )
 
                 self.write(channel_input=channel_input, redacted=bool(hidden_input))

scrapli/channel/base_channel.py

@@ -1,4 +1,5 @@
 """scrapli.channel.base_channel"""
+
 import re
 from dataclasses import dataclass
 from datetime import datetime
@@ -10,7 +11,19 @@ from scrapli.exceptions import ScrapliAuthenticationFailed, ScrapliTypeError, Sc
 from scrapli.logging import get_instance_logger
 from scrapli.transport.base import AsyncTransport, Transport
 
-ANSI_ESCAPE_PATTERN = re.compile(rb"\x1b(\[.*?[@-~]|\].*?(\x07|\x1b\\)|E)")
+ANSI_ESCAPE_PATTERN = re.compile(
+    pattern=rb"[\x1B\x9B\x9D](\s)?"  # Prefix ESC (^) or CSI (^[) or OSC (^)
+    rb"("
+    rb"([78ME])"  # control cursor position
+    rb"|"
+    rb"((\]\d).*?[\x07])"  # BEL (Terminal bell)
+    rb"|"
+    rb"(\[.*?[@-~])"  # control codes starts with `[` e.x. ESC [2;37;41m
+    rb"|"
+    rb"(\[.*?[0-9;]m)"  # Select Graphic Rendition (SGR) control sequence
+    rb")",
+    flags=re.VERBOSE,
+)
 
 
 @dataclass()
@@ -31,6 +44,12 @@ class BaseChannelArgs:
         comms_prompt_search_depth: depth of the buffer to search in for searching for the prompt
             in "read_until_prompt"; smaller number here will generally be faster, though may be less
             reliable; default value is 1000
+        comms_roughly_match_inputs: indicates if the channel should "roughly" match inputs sent
+            to the device. If False (default) inputs are strictly checked, as in any input
+            *must* be read back exactly on the channel. When set to True all input chars *must*
+            be read back in order in the output and all chars must be present, but the *exact*
+            input string does not need to be seen. This can be useful if a device echoes back
+            extra characters or rewrites the terminal during command input.
         timeout_ops: timeout_ops to assign to the channel, see above
         channel_log: log "channel" output -- this would be the output you would normally see on a
             terminal. If `True` logs to `scrapli_channel.log`, if a string is provided, logs to
@@ -53,6 +72,7 @@ class BaseChannelArgs:
     comms_prompt_pattern: str = r"^[a-z0-9.\-@()/:]{1,32}[#>$]$"
     comms_return_char: str = "\n"
     comms_prompt_search_depth: int = 1000
+    comms_roughly_match_inputs: bool = False
     timeout_ops: float = 30.0
     channel_log: Union[str, bool, BytesIO] = False
     channel_log_mode: str = "write"
@@ -348,8 +368,10 @@ class BaseChannel:
             N/A
 
         """
-        log_output = "REDACTED" if redacted else repr(channel_input)
-        self.logger.debug(f"write: {log_output}")
+        if redacted:
+            self.logger.debug("write: REDACTED")
+        else:
+            self.logger.debug("write: %r", channel_input)
 
         self.transport.write(channel_input=channel_input.encode())
 

scrapli/channel/sync_channel.py

@@ -1,4 +1,5 @@
 """scrapli.channel.sync_channel"""
+
 import re
 import time
 from contextlib import contextmanager, suppress
@@ -10,6 +11,7 @@ from typing import Iterator, List, Optional, Tuple
 from scrapli.channel.base_channel import BaseChannel, BaseChannelArgs
 from scrapli.decorators import timeout_wrapper
 from scrapli.exceptions import ScrapliAuthenticationFailed, ScrapliConnectionError, ScrapliTimeout
+from scrapli.helper import output_roughly_contains_input
 from scrapli.transport.base import Transport
 
 
@@ -69,7 +71,7 @@ class Channel(BaseChannel):
         buf = self.transport.read()
         buf = buf.replace(b"\r", b"")
 
-        self.logger.debug(f"read: {buf!r}")
+        self.logger.debug("read: %r", buf)
 
         if self.channel_log:
             self.channel_log.write(buf)
@@ -104,9 +106,16 @@ class Channel(BaseChannel):
         while True:
             buf += self.read()
 
-            # replace any backspace chars (particular problem w/ junos), and remove any added spaces
-            # this is just for comparison of the inputs to what was read from channel
-            if processed_channel_input in b"".join(buf.lower().replace(b"\x08", b"").split()):
+            if not self._base_channel_args.comms_roughly_match_inputs:
+                # replace any backspace chars (particular problem w/ junos), and remove any added
+                # spaces this is just for comparison of the inputs to what was read from channel
+                # note (2024) this would be worked around by using the roughly contains search,
+                # *but* that is slower (probably immaterially for most people but... ya know...)
+                processed_buf = b"".join(buf.lower().replace(b"\x08", b"").split())
+
+                if processed_channel_input in processed_buf:
+                    return buf
+            elif output_roughly_contains_input(input_=processed_channel_input, output=buf):
                 return buf
 
     def _read_until_prompt(self, buf: bytes = b"") -> bytes:
@@ -238,7 +247,7 @@ class Channel(BaseChannel):
 
             if (time.time() - start) > read_duration:
                 break
-            if any((channel_output in search_buf for channel_output in channel_outputs)):
+            if any(channel_output in search_buf for channel_output in channel_outputs):
                 break
             if re.search(pattern=regex_channel_outputs_pattern, string=search_buf):
                 break
@@ -456,6 +465,7 @@ class Channel(BaseChannel):
         *,
         strip_prompt: bool = True,
         eager: bool = False,
+        eager_input: bool = False,
     ) -> Tuple[bytes, bytes]:
         """
         Primary entry point to send data to devices in shell mode; accept input and returns result
@@ -466,6 +476,8 @@ class Channel(BaseChannel):
             eager: eager mode reads and returns the `_read_until_input` value, but does not attempt
                 to read to the prompt pattern -- this should not be used manually! (only used by
                 `send_configs` with the eager flag set)
+            eager_input: when true does *not* try to read our input off the channel -- generally
+                this should be left alone unless you know what you are doing!
 
         Returns:
             Tuple[bytes, bytes]: tuple of "raw" output and "processed" (cleaned up/stripped) output
@@ -480,12 +492,18 @@ class Channel(BaseChannel):
         bytes_channel_input = channel_input.encode()
 
         self.logger.info(
-            f"sending channel input: {channel_input}; strip_prompt: {strip_prompt}; eager: {eager}"
+            "sending channel input: %s; strip_prompt: %s; eager: %s",
+            channel_input,
+            strip_prompt,
+            eager,
         )
 
         with self._channel_lock():
             self.write(channel_input=channel_input)
-            _buf_until_input = self._read_until_input(channel_input=bytes_channel_input)
+
+            if not eager_input:
+                _buf_until_input = self._read_until_input(channel_input=bytes_channel_input)
+
             self.send_return()
 
             if not eager:
@@ -532,8 +550,12 @@ class Channel(BaseChannel):
         ]
 
         self.logger.info(
-            f"sending channel input and read: {channel_input}; strip_prompt: {strip_prompt}; "
-            f"expected_outputs: {expected_outputs}; read_duration: {read_duration}"
+            "sending channel input and read: %s; strip_prompt: %s; "
+            "expected_outputs: %s; read_duration: %s",
+            channel_input,
+            strip_prompt,
+            expected_outputs,
+            read_duration,
         )
 
         with self._channel_lock():
@@ -643,9 +665,10 @@ class Channel(BaseChannel):
 
                 _channel_input = channel_input if not hidden_input else "REDACTED"
                 self.logger.info(
-                    f"sending interactive input: {_channel_input}; "
-                    f"expecting: {channel_response}; "
-                    f"hidden_input: {hidden_input}"
+                    "sending interactive input: %s; expecting: %s; hidden_input: %s",
+                    _channel_input,
+                    channel_response,
+                    hidden_input,
                 )
 
                 self.write(channel_input=channel_input, redacted=bool(hidden_input))

scrapli/decorators.py

@@ -1,4 +1,5 @@
 """scrapli.decorators"""
+
 import asyncio
 import signal
 import sys

scrapli/driver/__init__.py

@@ -1,4 +1,5 @@
 """scrapli.driver"""
+
 from scrapli.driver.base import AsyncDriver, Driver
 from scrapli.driver.generic import AsyncGenericDriver, GenericDriver
 from scrapli.driver.network import AsyncNetworkDriver, NetworkDriver

scrapli/driver/base/__init__.py

@@ -1,4 +1,5 @@
 """scrapli.driver.base"""
+
 from scrapli.driver.base.async_driver import AsyncDriver
 from scrapli.driver.base.sync_driver import Driver
 

scrapli/driver/base/async_driver.py

@@ -1,11 +1,12 @@
 """scrapli.driver.base.async_driver"""
+
 from types import TracebackType
 from typing import Any, Optional, Type, TypeVar
 
 from scrapli.channel import AsyncChannel
 from scrapli.driver.base.base_driver import BaseDriver
-from scrapli.exceptions import ScrapliValueError
-from scrapli.transport import ASYNCIO_TRANSPORTS
+from scrapli.exceptions import ScrapliConnectionError, ScrapliValueError
+from scrapli.transport import ASYNCIO_TRANSPORTS, CORE_TRANSPORTS
 
 _T = TypeVar("_T", bound="AsyncDriver")
 
@@ -14,7 +15,7 @@ class AsyncDriver(BaseDriver):
     def __init__(self, **kwargs: Any):
         super().__init__(**kwargs)
 
-        if self.transport_name not in ASYNCIO_TRANSPORTS:
+        if self.transport_name in CORE_TRANSPORTS and self.transport_name not in ASYNCIO_TRANSPORTS:
             raise ScrapliValueError(
                 "provided transport is *not* an asyncio transport, must use an async transport with"
                 " the AsyncDriver(s)"
@@ -39,10 +40,22 @@ class AsyncDriver(BaseDriver):
             _T: a concrete implementation of the opened AsyncDriver object
 
         Raises:
-            N/A
+            ScrapliConnectionError: if an exception occurs during opening
 
         """
-        await self.open()
+        try:
+            await self.open()
+        except Exception as exc:
+            self.logger.critical(
+                "encountered exception during open in context manager,"
+                " attempting to close transport and channel"
+            )
+
+            self.transport.close()
+            self.channel.close()
+
+            raise ScrapliConnectionError(exc) from exc
+
         return self
 
     async def __aexit__(
@@ -87,14 +100,7 @@ class AsyncDriver(BaseDriver):
         await self.transport.open()
         self.channel.open()
 
-        if (
-            self.transport_name
-            in (
-                "telnet",
-                "asynctelnet",
-            )
-            and not self.auth_bypass
-        ):
+        if "telnet" in self.transport_name and not self.auth_bypass:
             await self.channel.channel_authenticate_telnet(
                 auth_username=self.auth_username, auth_password=self.auth_password
             )

scrapli/driver/base/base_driver.py

@@ -1,4 +1,5 @@
-"""scrapli.driver.base.base_driver"""
+"""scrapli.driver.base.base_driver"""  # noqa: C0302
+
 import importlib
 from dataclasses import fields
 from io import BytesIO
@@ -13,6 +14,7 @@ from scrapli.logging import get_instance_logger
 from scrapli.ssh_config import ssh_config_factory
 from scrapli.transport import CORE_TRANSPORTS
 from scrapli.transport.base import BasePluginTransportArgs, BaseTransportArgs
+from scrapli.transport.plugins.system.transport import SystemTransport
 
 
 class BaseDriver:
@@ -34,6 +36,7 @@ class BaseDriver:
         timeout_ops: float = 30.0,
         comms_prompt_pattern: str = r"^[a-z0-9.\-@()/:]{1,48}[#>$]\s*$",
         comms_return_char: str = "\n",
+        comms_roughly_match_inputs: bool = False,
         ssh_config_file: Union[str, bool] = False,
         ssh_known_hosts_file: Union[str, bool] = False,
         on_init: Optional[Callable[..., Any]] = None,
@@ -83,6 +86,12 @@ class BaseDriver:
                 should be mostly sorted for you if using network drivers (i.e. `IOSXEDriver`).
                 Lastly, the case insensitive is just a convenience factor so i can be lazy.
             comms_return_char: character to use to send returns to host
+            comms_roughly_match_inputs: indicates if the channel should "roughly" match inputs sent
+                to the device. If False (default) inputs are strictly checked, as in any input
+                *must* be read back exactly on the channel. When set to True all input chars *must*
+                be read back in order in the output and all chars must be present, but the *exact*
+                input string does not need to be seen. This can be useful if a device echoes back
+                extra characters or rewrites the terminal during command input.
             ssh_config_file: string to path for ssh config file, True to use default ssh config file
                 or False to ignore default ssh config file
             ssh_known_hosts_file: string to path for ssh known hosts file, True to use default known
@@ -149,6 +158,7 @@ class BaseDriver:
             auth_passphrase_pattern=auth_passphrase_pattern,
             comms_prompt_pattern=comms_prompt_pattern,
             comms_return_char=comms_return_char,
+            comms_roughly_match_inputs=comms_roughly_match_inputs,
             timeout_ops=timeout_ops,
             channel_log=channel_log,
             channel_log_mode=channel_log_mode,
@@ -249,6 +259,7 @@ class BaseDriver:
             f"timeout_ops={self._base_channel_args.timeout_ops!r}, "
             f"comms_prompt_pattern={self._base_channel_args.comms_prompt_pattern!r}, "
             f"comms_return_char={self._base_channel_args.comms_return_char!r}, "
+            f"comms_roughly_match_inputs={self._base_channel_args.comms_roughly_match_inputs!r}, "
             f"ssh_config_file={self.ssh_config_file!r}, "
             f"ssh_known_hosts_file={self.ssh_known_hosts_file!r}, "
             f"on_init={self.on_init!r}, "
@@ -362,7 +373,7 @@ class BaseDriver:
                 cfg = ""
             else:
                 cfg = ssh_config_file
-            resolved_ssh_config_file = self._resolve_ssh_config(cfg)
+            resolved_ssh_config_file = self._resolve_ssh_config(cfg, transport=transport)
         else:
             resolved_ssh_config_file = ""
 
@@ -371,7 +382,9 @@ class BaseDriver:
                 known_hosts = ""
             else:
                 known_hosts = ssh_known_hosts_file
-            resolved_ssh_known_hosts_file = self._resolve_ssh_known_hosts(known_hosts)
+            resolved_ssh_known_hosts_file = self._resolve_ssh_known_hosts(
+                known_hosts, transport=transport
+            )
         else:
             resolved_ssh_known_hosts_file = ""
 
@@ -547,7 +560,9 @@ class BaseDriver:
 
         return transport_class, plugin_transport_args
 
-    def _load_non_core_transport_plugin(self) -> Tuple[Any, Type[BasePluginTransportArgs]]:
+    def _load_non_core_transport_plugin(
+        self,
+    ) -> Tuple[Any, Type[BasePluginTransportArgs]]:
         """
         Find non-core transport plugins and required plugin arguments
 
@@ -586,7 +601,7 @@ class BaseDriver:
 
         return transport_class, plugin_transport_args
 
-    def _resolve_ssh_config(self, ssh_config_file: str) -> str:
+    def _resolve_ssh_config(self, ssh_config_file: str, transport: str) -> str:
         """
         Resolve ssh configuration file from provided string
 
@@ -595,6 +610,8 @@ class BaseDriver:
 
         Args:
             ssh_config_file: string representation of ssh config file to try to use
+            transport: string name of selected transport (so we can apply a bit of special handling
+                if system transport in use)
 
         Returns:
             str: string path to ssh config file or an empty string
@@ -603,27 +620,20 @@ class BaseDriver:
             N/A
 
         """
-        self.logger.debug("attempting to resolve 'ssh_config_file' file")
+        self.logger.debug(f"attempting to resolve 'ssh_config_file' file {ssh_config_file}")
 
-        resolved_ssh_config_file = ""
+        if ssh_config_file == "" and transport == "system":
+            return SystemTransport.SSH_SYSTEM_CONFIG_MAGIC_STRING
 
-        if Path(ssh_config_file).is_file():
-            resolved_ssh_config_file = str(Path(ssh_config_file))
-        elif Path("~/.ssh/config").expanduser().is_file():
-            resolved_ssh_config_file = str(Path("~/.ssh/config").expanduser())
-        elif Path("/etc/ssh/ssh_config").is_file():
-            resolved_ssh_config_file = str(Path("/etc/ssh/ssh_config"))
+        for path in (ssh_config_file, "~/.ssh/config", "/etc/ssh/ssh_config"):
+            full_path = Path(path).expanduser()
+            if full_path.is_file():
+                return str(full_path)
 
-        if resolved_ssh_config_file:
-            self.logger.debug(
-                f"using '{resolved_ssh_config_file}' as resolved 'ssh_config_file' file'"
-            )
-        else:
-            self.logger.debug("unable to resolve 'ssh_config_file' file")
+        self.logger.debug(f"unable to resolve 'ssh_config_file' file {ssh_config_file}")
+        return ""
 
-        return resolved_ssh_config_file
-
-    def _resolve_ssh_known_hosts(self, ssh_known_hosts: str) -> str:
+    def _resolve_ssh_known_hosts(self, ssh_known_hosts: str, transport: str) -> str:
         """
         Resolve ssh known hosts file from provided string
 
@@ -632,6 +642,8 @@ class BaseDriver:
 
         Args:
             ssh_known_hosts: string representation of ssh config file to try to use
+            transport: string name of selected transport (so we can apply a bit of special handling
+                if system transport in use)
 
         Returns:
             str: string path to ssh known hosts file or an empty string
@@ -642,23 +654,17 @@ class BaseDriver:
         """
         self.logger.debug("attempting to resolve 'ssh_known_hosts file'")
 
-        resolved_ssh_known_hosts = ""
-
-        if Path(ssh_known_hosts).is_file():
-            resolved_ssh_known_hosts = str(Path(ssh_known_hosts))
-        elif Path("~/.ssh/known_hosts").expanduser().is_file():
-            resolved_ssh_known_hosts = str(Path("~/.ssh/known_hosts").expanduser())
-        elif Path("/etc/ssh/ssh_known_hosts").is_file():
-            resolved_ssh_known_hosts = str(Path("/etc/ssh/ssh_known_hosts"))
+        if ssh_known_hosts == "" and transport == "system":
+            self.logger.debug("Using system known hosts file as 'ssh_known_hosts' file")
+            return SystemTransport.SSH_SYSTEM_KNOWN_HOSTS_FILE_MAGIC_STRING
 
-        if resolved_ssh_known_hosts:
-            self.logger.debug(
-                f"using '{resolved_ssh_known_hosts}' as resolved 'ssh_known_hosts' file'"
-            )
-        else:
-            self.logger.debug("unable to resolve 'ssh_known_hosts' file")
+        for path in (ssh_known_hosts, "~/.ssh/known_hosts", "/etc/ssh/ssh_known_hosts"):
+            full_path = Path(path).expanduser()
+            if full_path.is_file():
+                return str(full_path)
 
-        return resolved_ssh_known_hosts
+        self.logger.info(f"unable to resolve 'ssh_known_hosts' file {ssh_known_hosts}")
+        return ""
 
     @property
     def comms_prompt_pattern(self) -> str:
@@ -738,6 +744,84 @@ class BaseDriver:
 
         self._base_channel_args.comms_return_char = value
 
+    @property
+    def comms_prompt_search_depth(self) -> int:
+        """
+        Getter for `comms_prompt_search_depth` attribute
+
+        Args:
+            N/A
+
+        Returns:
+            int: comms_prompt_search_depth int
+
+        Raises:
+            N/A
+
+        """
+        return self._base_channel_args.comms_prompt_search_depth
+
+    @comms_prompt_search_depth.setter
+    def comms_prompt_search_depth(self, value: int) -> None:
+        """
+        Setter for `comms_prompt_search_depth` attribute
+
+        Args:
+            value: int value for comms_prompt_search_depth
+
+        Returns:
+            None
+
+        Raises:
+            ScrapliTypeError: if value is not of type int
+
+        """
+        self.logger.debug(f"setting 'comms_prompt_search_depth' value to {value!r}")
+
+        if not isinstance(value, int):
+            raise ScrapliTypeError
+
+        self._base_channel_args.comms_prompt_search_depth = value
+
+    @property
+    def comms_roughly_match_inputs(self) -> bool:
+        """
+        Getter for `comms_roughly_match_inputs` attribute
+
+        Args:
+            N/A
+
+        Returns:
+            bool: comms_roughly_match_inputs bool
+
+        Raises:
+            N/A
+
+        """
+        return self._base_channel_args.comms_roughly_match_inputs
+
+    @comms_roughly_match_inputs.setter
+    def comms_roughly_match_inputs(self, value: bool) -> None:
+        """
+        Setter for `comms_roughly_match_inputs` attribute
+
+        Args:
+            value: int value for comms_roughly_match_inputs
+
+        Returns:
+            None
+
+        Raises:
+            ScrapliTypeError: if value is not of type bool
+
+        """
+        self.logger.debug(f"setting 'comms_roughly_match_inputs' value to {value!r}")
+
+        if not isinstance(value, bool):
+            raise ScrapliTypeError
+
+        self._base_channel_args.comms_roughly_match_inputs = value
+
     @property
     def timeout_socket(self) -> float:
         """