marsh-lib 0.2.0__py3-none-any.whl

marsh/__init__.py

@@ -0,0 +1,2 @@
+from marsh.core import *
+from marsh import ssh

marsh/bash/__init__.py

@@ -0,0 +1,3 @@
+from marsh.bash.bash_grammar import BashGrammar
+from marsh.bash.bash_script import BashScript
+from marsh.bash.bash_factory import BashFactory

marsh/bash/bash_factory.py

@@ -0,0 +1,74 @@
+import functools
+from typing import Callable
+
+from marsh.core import LocalCommandExecutor
+from marsh.bash import BashGrammar
+from marsh.bash import BashScript
+
+
+class BashFactory:
+    """
+    A factory class that simplifies the creation of various Bash-related objects, such as command grammars and executors.
+    """
+    def create_one_command_grammar(self, command: str, bash_path: str="bash", bash_options: list[str] | None = None) -> BashGrammar:
+        """Creates a BashGrammar from one-line bash command.
+
+        Args:
+            command (str): Bash one-line command.
+            bash_path (str, optional): Path to bash program.  Defaults to "bash".
+            bash_options (list[str] | None, optional): Options or Flags to be passed to the bash. Defaults to None.
+
+        Returns:
+            BashGrammar: Customized BashGrammar instance for one-line bash command.
+        """
+        bash_options = bash_options or ["-c"]
+        return BashGrammar(bash_path=bash_path, bash_options=bash_options, bash_args=[command])
+
+    def create_multi_line_command_grammar(self, commands: list[str], bash_path="bash", bash_options=None, *bash_script_args, **bash_script_kwargs) -> BashGrammar:
+        """Creates a BashGrammar from multi-line bash commands.
+
+        Args:
+            commands (list[str]): List of bash command to be run sequentially.
+            bash_path (str, optional): Path to bash program. Defaults to "bash".
+            bash_options (list[str] | None, optional): Options or Flags to be passed to the bash. Defaults to None.
+
+        Returns:
+            BashGrammar: Customized BashGrammar instance for multi-line bash commands.
+        """
+        bash_script = BashScript(*bash_script_args, **bash_script_kwargs)
+        bash_options = bash_options or ["-c"]
+        script_str: str = bash_script.generate(*commands)
+        return BashGrammar(bash_path=bash_path, bash_options=bash_options, bash_args=[script_str])
+
+    def create_local_command_executor(self, command: str | list[str], *executor_args, grammar_args=(), grammar_kwargs=None, **executor_kwargs) -> LocalCommandExecutor:
+        """Creates a LocalCommandExecutor from one-line or multi-line command.
+
+        Args:
+            command (str | list[str]): One-line bash command as string or multi-line commands as a list of strings.
+            grammar_args (tuple, optional): Positional arguments for be passed on to the bash grammar factory method. Defaults to ().
+            grammar_kwargs (dict, optional): Keyword arguments for be passed on to the bash grammar factory method. Defaults to None.
+
+        Returns:
+            LocalCommandExecutor: Customized LocalCommandExecutor.
+        """
+        grammar_kwargs = grammar_kwargs or dict()
+        if isinstance(command, str):
+            cmd_grammar = self.create_one_command_grammar(command, *grammar_args, **grammar_kwargs)
+        if isinstance(command, list):
+            cmd_grammar = self.create_multi_line_command_grammar(command, *grammar_args, **grammar_kwargs)
+        return LocalCommandExecutor(cmd_grammar, *executor_args, **executor_kwargs)
+
+    def create_cmd_runner(self, command: str | list[str], *runner_args, executor_args=(), executor_kwargs=None, **runner_kwargs) -> Callable[[bytes, bytes], tuple[bytes, bytes]]:
+        """Creates a command runner function from a given command(s) and other factory method parameters.
+
+        Args:
+            command (str | list[str]): One-line bash command as string or multi-line commands as a list of strings.
+            executor_args (tuple, optional): Positional arguments for be passed on to `create_local_command_executor()`. Defaults to ().
+            executor_kwargs (dict, optional): Keyword arguments for be passed on to `create_local_command_executor()`. Defaults to None.
+
+        Returns:
+            Callable[[bytes, bytes], tuple[bytes, bytes]]: Customized bash command runner ready to be called, this function can be further enhanced with command runner decorators.
+        """
+        executor_kwargs = executor_kwargs or dict()
+        local_cmd = self.create_local_command_executor(command, *executor_args, **executor_kwargs)
+        return functools.partial(local_cmd.run, *runner_args, **runner_kwargs)

marsh/bash/bash_grammar.py

@@ -0,0 +1,44 @@
+from marsh.core import CommandGrammar
+from marsh.constants import BASH_PATH
+
+
+class BashGrammar(CommandGrammar):
+    """
+    A concrete implementation of the `CommandGrammar` class for constructing and managing Bash commands.
+
+    The `BashGrammar` class simplifies building Bash command-line invocations by providing methods to 
+    add options, arguments, inline commands, or scripts. It allows users to create flexible, reusable 
+    Bash commands programmatically and can be integrated with other tools that execute shell commands.
+    """
+    # /path/to/bash [options] [args]
+    # /bin/bash -c command
+    # /bin/bash /path/to/file
+    def __init__(self,
+                 bash_path: str | None = BASH_PATH,
+                 bash_options: list[str] | None = None,
+                 bash_args: list[str] | None =None,
+                 ):
+        self._bash_path = bash_path or "bash"
+        self._options = bash_options or []
+        self._args = bash_args or []
+
+    @property
+    def program_path(self) -> str:
+        return self._bash_path
+
+    @property
+    def options(self) -> list[str]:
+        return self._options
+
+    @property
+    def program_args(self) -> list[str]:
+        return self._args
+
+    def add_option(self, option: str) -> "BashGrammar":
+        return BashGrammar(bash_options=self._options+[option], bash_args=self._args)
+
+    def add_arg(self, arg: str) -> "BashGrammar":
+        return BashGrammar(bash_options=self._options, bash_args=self._args+[arg])
+
+    def build_cmd(self) -> list[str]:
+        return [self._bash_path, *self._options, " ".join(self._args)]

marsh/bash/bash_script.py

@@ -0,0 +1,71 @@
+import string
+
+from marsh.exceptions import ScriptError
+from marsh import Script
+
+
+_BASH_SCRIPT_TEMPLATE = r"""$shebang_
+
+$debugging_
+
+$statements_
+
+"""
+
+
+class BashScript(Script):
+    """
+    An implementation of the `Script` ABC for generating Bash scripts from templates.
+
+    This class provides a way to construct Bash scripts by specifying a shebang, 
+    debugging settings, and script statements. The resulting script can be rendered 
+    as a string using the `generate` method.
+    """
+    def __init__(self,
+                 shebang: str = "#!/usr/bin/env bash",
+                 debugging: str = "set -eu -o pipefail"
+                 ):
+        """
+        Initializes a `BashScript` instance with a default shebang and debugging options.
+
+        Args:
+            `shebang` (str): The shebang line to specify the shell for the script. 
+                           Defaults to `#!/usr/bin/env bash`.
+            `debugging` (str): Debugging options to set shell behavior. Defaults to 
+                             `set -eu -o pipefail`.
+
+        Raises:
+            ScriptError: If the provided `shebang` does not start with `#!`.
+        """
+
+        # Make sure that shebang starts with `#!`.
+        if not shebang.startswith("#!"):
+            raise ScriptError("Shebang must start with '#!'.")
+
+        template = string.Template(_BASH_SCRIPT_TEMPLATE)
+        template_str = template.safe_substitute(
+            shebang_=shebang,
+            debugging_=debugging
+        )
+        super().__init__(template_str)
+
+    def generate(self,
+                 *statements: list[str],
+                 sep: str = "\n"
+                 ) -> str:
+        """
+        Renders the Bash script by substituting the provided script statements 
+        into the template.
+
+        Args:
+            `*statements` (list[str]): A list of Bash statements to include in the script.
+            `sep` (str): Separator for joining multiple statements. Defaults to `\\n`.
+
+        Returns:
+            str: A string containing the rendered Bash script.
+        """
+
+        statements_ = f"{sep}".join(statements)
+        return string.Template(self.script_template).safe_substitute(
+            statements_=statements_
+        ).rstrip()

marsh/constants.py

@@ -0,0 +1,5 @@
+import shutil
+
+BASH_PATH: str | None = shutil.which("bash")
+SH_PATH: str | None = shutil.which("sh")
+PY_PATH: str | None = shutil.which("python")

marsh/core/__init__.py

@@ -0,0 +1,8 @@
+from marsh.core.conveyor import Conveyor
+from marsh.core.command_grammar import CommandGrammar
+from marsh.core.authenticator import Authenticator
+from marsh.core.connector import Connector
+from marsh.core.script import Script
+from marsh.core.expression import *
+from marsh.core.cmd_run_decorator import *
+from marsh.core.executor import *

marsh/core/authenticator.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class Authenticator(ABC):
+    @abstractmethod
+    def authenticate(self, *args, **kwargs):
+        pass

marsh/core/cmd_run_decorator.py

@@ -0,0 +1,289 @@
+import functools
+import inspect
+from typing import Callable
+
+
+def _is_proc_or_mod_func_args_valid(func: Callable) -> bool:
+    # Validate the signature of func
+    sig = inspect.signature(func)
+    params = list(sig.parameters.values())
+    if len(params) < 2:  # Check if there are at least two parameters
+        return False
+    match params[0], params[1]:  # Match first two parameters to check if they are positional and of type bytes
+        case (inspect.Parameter(kind=inspect.Parameter.POSITIONAL_OR_KEYWORD), inspect.Parameter(kind=inspect.Parameter.POSITIONAL_OR_KEYWORD)):
+            # Validate that they are of type 'bytes'
+            if not all(isinstance(param.annotation, type(bytes)) or param.annotation == inspect.Parameter.empty for param in params[:2]):
+                return False
+        case _:
+            return False
+    return True
+
+
+def processor_decorator(before: bool,
+                        proc_func: Callable[[bytes, bytes], None],
+                        *proc_args,
+                        **proc_kwargs
+                        ) -> Callable[[bytes, bytes], tuple[bytes, bytes]]:
+    """
+    A decorator to add pre-processing or post-processing behavior to a command runner function.
+
+    This decorator wraps a command runner function with pre- or post-processing logic. The `before` argument
+    specifies whether the processor function (`proc_func`) should run before or after the command runner.
+
+    Args:
+        before (bool): If True, the processor runs before the command runner (pre-processing).
+                      If False, it runs after the command runner (post-processing).
+        proc_func (Callable[[bytes, bytes], None]): The processor function that extends or modifies
+                      the behavior of the command runner.
+        *proc_args: Additional positional arguments to pass to `proc_func`.
+        **proc_kwargs: Additional keyword arguments to pass to `proc_func`.
+
+    Returns:
+        Callable[[bytes, bytes], tuple[bytes, bytes]]: A decorated command runner function that includes 
+        pre- or post-processing logic.
+    """
+    if not _is_proc_or_mod_func_args_valid(proc_func):
+        raise ValueError("The processor function has invalid signature.")
+
+    def outer(cmd_runner):
+        @functools.wraps(cmd_runner)
+        def wrapper(x_stdout, x_stderr, *args, **kwargs):
+            # Execute processor before or after
+            if before:
+                proc_func(x_stdout, x_stderr, *proc_args, **proc_kwargs)
+                stdout, stderr = cmd_runner(x_stdout, x_stderr, *args, **kwargs)
+            else:
+                stdout, stderr = cmd_runner(x_stdout, x_stderr, *args, **kwargs)
+                proc_func(stdout, stderr, *proc_args, **proc_kwargs)
+            return stdout, stderr
+        return wrapper
+    return outer
+
+
+def stdout_stderr_modifier(before: bool,
+                           mod_func: Callable[[bytes, bytes], tuple[bytes, bytes]],
+                           *mod_args,
+                           **mod_kwargs
+                           ) -> Callable[[bytes, bytes], tuple[bytes, bytes]]:
+    """
+    A decorator that modifies the standard output and error of a command runner function.
+
+    This decorator allows you to modify the stdout and stderr either before or after the command runner function
+    executes. The `mod_func` should return the modified stdout and stderr as a tuple.
+
+    In `processor_decorator()`, the `proc_func` does not return any result, which limits its ability to perform modifications.
+    This decorator is primarily suited for use cases such as validation, error handling, printing, logging, notifications, etc.
+    In contrast, the `mod_func` allows users to manipulate the `(x_stdout, x_stderr)` or `(stdout, stderr)` values and return the
+    modified results. However, it does not modify the arguments in place, as the bytes objects are immutable. Use cases for this
+    include data cleaning, ETL (Extract, Transform, Load) processes, and similar tasks.
+
+    Args:
+        before (bool): If True, the modifier function is applied to the command's stdout and stderr before
+                       the command runner is executed. If False, it is applied after.
+        mod_func (Callable[[bytes, bytes], tuple[bytes, bytes]]): A function that modifies the command's stdout and stderr.
+        *mod_args: Additional positional arguments passed to `mod_func`.
+        **mod_kwargs: Additional keyword arguments passed to `mod_func`.
+
+    Returns:
+        Callable[[bytes, bytes], tuple[bytes, bytes]]: A new command runner function that includes the modifications.
+    """
+    # Validate the Signature of Modifier Function
+    if not _is_proc_or_mod_func_args_valid(mod_func):
+        raise ValueError("The processor function has invalid signature.")
+
+    def outer(cmd_runner):
+        @functools.wraps(cmd_runner)
+        def wrapper(x_stdout: bytes, x_stderr: bytes, *args, **kwargs) -> tuple[bytes, bytes]:
+            if before:
+                # mod_func() will be used to transform the previous command runner's results (bytes, bytes), and use this "modified"
+                # results for the current command runner as arguments.
+                mod_x_stdout, mod_x_stderr = mod_func(x_stdout, x_stderr, *mod_args, **mod_kwargs)
+                mod_stdout, mod_stderr = cmd_runner(mod_x_stdout, mod_x_stderr, *args, **kwargs)
+                return mod_stdout, mod_stderr
+            else:
+                # mod_func() will be used to "modify" the current command runner's result and finally returns the modified results.
+                stdout, stderr = cmd_runner(x_stdout, x_stderr, *args, **kwargs)
+                mod_stdout, mod_stderr = mod_func(stdout, stderr, *mod_args, **mod_kwargs)
+                return mod_stdout, mod_stderr
+        return wrapper
+    return outer
+
+
+class CmdRunDecorator:
+    """
+    A class for managing and applying chains of pre- and post-processors and modifiers to a command runner.
+
+    This class allows you to add processor and modifier functions to a command runner. Processors can be applied
+    before or after the command runner, and modifiers modify the stdout and stderr either before or after the runner.
+    
+    Methods:
+        add_processor: Adds a processor function to the pre- or post-processor chain.
+        add_mod_processor: Adds a modifier function to the pre- or post-modifier chain.
+        decorate: Applies the added processors and modifiers to a command runner function.
+    """
+    def __init__(self, decorated_runners: list[Callable]=None):
+        # Separate chains for processors and modifiers
+        self._pre_processors = []
+        self._post_processors = []
+        self._pre_modifiers = []  # To store mod_func processors to be applied before
+        self._post_modifiers = []  # To store mod_func processors to be applied after
+
+        if decorated_runners:
+            for runner in decorated_runners:
+                if runner["before"]:
+                    self._pre_processors.append(runner["decorator"])
+                else:
+                    self._post_processors.append(runner["decorator"])
+
+    def add_processor(self,
+                      processor: Callable[[bytes, bytes], None],
+                      before: bool = True,
+                      proc_args: tuple = (),
+                      proc_kwargs: dict | None = None) -> "CmdRunDecorator":
+        """
+        Adds a processor function to the pre- or post-processor chain.
+
+        Args:
+            processor (Callable[[bytes, bytes], None]): A function to process the command's stdout and stderr.
+            before (bool, optional): If True, the processor is added to the pre-processor chain. Defaults to True.
+            proc_args (tuple, optional): Positional arguments for the processor. Defaults to ().
+            proc_kwargs (dict, optional): Keyword arguments for the processor. Defaults to None.
+
+        Returns:
+            CmdRunDecorator: The current CmdRunDecorator instance to allow method chaining.
+        """
+        proc_kwags_ = proc_kwargs or {}
+        cmd_runner_decorator = processor_decorator(before, processor, *proc_args, **proc_kwags_)
+
+        if before:
+            self._pre_processors.append(cmd_runner_decorator)
+        else:
+            self._post_processors.append(cmd_runner_decorator)
+
+        return self
+
+    def add_mod_processor(self,
+                          mod_func: Callable[[bytes, bytes], tuple[bytes, bytes]],
+                          before: bool = True,
+                          mod_args: tuple = (),
+                          mod_kwargs: dict | None = None) -> "CmdRunDecorator":
+        """
+        Adds a modifier function to the pre- or post-modifier chain.
+
+        Args:
+            mod_func (Callable[[bytes, bytes], tuple[bytes, bytes]]): A function that modifies the command's stdout and stderr.
+            before (bool, optional): If True, the modifier is added to the pre-modifier chain. Defaults to True.
+            mod_args (tuple, optional): Positional arguments for the modifier. Defaults to ().
+            mod_kwargs (dict, optional): Keyword arguments for the modifier. Defaults to None.
+
+        Returns:
+            CmdRunDecorator: The current CmdRunDecorator instance to allow method chaining.
+        """
+        mod_kwags_ = mod_kwargs or {}
+        cmd_runner_decorator = stdout_stderr_modifier(before, mod_func, *mod_args, **mod_kwags_)
+
+        if before:
+            self._pre_modifiers.append(cmd_runner_decorator)  # Store pre-modifiers
+        else:
+            self._post_modifiers.append(cmd_runner_decorator)  # Store post-modifiers
+
+        return self
+
+    def decorate(self, cmd_runner: Callable[[bytes, bytes], tuple[bytes, bytes]]) -> Callable[[bytes, bytes], tuple[bytes, bytes]]:
+        """
+        Decorates a command runner function with the pre- and post-processors and modifiers.
+
+        The order of evaluation:
+            1) Pre-Modifiers
+            2) Pre-Processors
+            3) Command Runner
+            4) Post-Modifiers
+            5) Post-Processors
+
+        Args:
+            cmd_runner (Callable[[bytes, bytes], tuple[bytes, bytes]]): The command runner function to decorate.
+
+        Returns:
+            Callable[[bytes, bytes], tuple[bytes, bytes]]: The decorated command runner function.
+        """
+        # 2nd
+        # Apply pre-processors (before the command runner)
+        for pre_processor in reversed(self._pre_processors):  # Reverse order for before-processors
+            cmd_runner = pre_processor(cmd_runner)
+
+        # 1st
+        # Apply pre-modifiers (before the command runner)
+        for pre_modifier in reversed(self._pre_modifiers):  # Reverse order for before-modifiers
+            cmd_runner = pre_modifier(cmd_runner)
+
+        # 3rd
+        # Apply post-modifiers (after the command runner)
+        for post_modifier in self._post_modifiers:
+            cmd_runner = post_modifier(cmd_runner)
+
+        # 4th
+        # Apply post-processors (after the command runner)
+        for post_processor in self._post_processors:
+            cmd_runner = post_processor(cmd_runner)
+
+        return cmd_runner
+
+
+def add_processors_and_modifiers(*tup_list: list[tuple]) -> Callable[[bytes, bytes], tuple[bytes, bytes]]:
+    """
+    A decorator that allows adding multiple processors and modifiers to a command runner.
+
+    This decorator allows adding both processors and modifiers in one call, either to modify the output
+    or to perform additional processing before or after the command execution.
+
+    Args:
+        *tup_list (list[tuple]): A list of tuples specifying processors and modifiers. Each tuple must contain
+                                  the classification ("proc" or "mod") followed by the appropriate function and arguments.
+
+    Returns:
+        Callable[[bytes, bytes], tuple[bytes, bytes]]: A decorated command runner function.
+    """
+    def outer(cmd_runner):
+        @functools.wraps(cmd_runner)
+        def wrapper(x_stdout, x_stderr, *args, **kwargs):
+            # Initialize the Command Run Decorator
+            cmd_runner_decorator = CmdRunDecorator()
+
+            for tup in tup_list:
+                assert isinstance(tup, (tuple, list))
+                assert isinstance(tup[0], str) and tup[0] in ["proc", "mod"], 'The classifier must be "proc" or "mod".'
+
+                # Classifier ("proc" or "mod")
+                proc_or_mod = tup[0]
+
+                # Set the Method for adding either a "processor" or "modifier"
+                adder_method = cmd_runner_decorator.add_processor if proc_or_mod == "proc" else cmd_runner_decorator.add_mod_processor
+
+                # Pattern Match on the given tuples
+                # Only match the required information and not the classification of "proc" or "mod"
+                match tup[1:]:
+                    case (before, callback):
+                        adder_method(callback, before=before)
+                    case (before, callback, args_) if isinstance(args_, (tuple, list)):
+                        adder_method(callback, before=before, mod_args=args_) if proc_or_mod == "mod" else adder_method(callback, before=before, proc_args=args_)
+                    case (before, callback, kwargs_) if isinstance(kwargs_, dict):
+                        adder_method(callback, before=before, mod_kwargs=kwargs_) if proc_or_mod == "mod" else adder_method(callback, before=before, proc_kwargs=kwargs_)
+                    case (before, callback, args_, kwargs_) if isinstance(args_, (tuple, list)) and isinstance(kwargs_, dict):
+                        adder_method(callback, before=before, mod_args=args_, mod_kwargs=kwargs_) if proc_or_mod == "mod" else adder_method(callback, before=before, proc_args=args_, proc_kwargs=kwargs_)
+                    case _:
+                        error_message = f"{tup} is invalid."
+                        ValueError(error_message)
+
+            # Decorate the command runner
+            decorated_cmd_runner = cmd_runner_decorator.decorate(cmd_runner)
+            return decorated_cmd_runner(x_stdout, x_stderr, *args, **kwargs)
+        return wrapper
+    return outer
+
+
+__all__ = (
+    "processor_decorator",
+    "stdout_stderr_modifier",
+    "CmdRunDecorator",
+    "add_processors_and_modifiers"
+)

marsh/core/command_grammar.py

@@ -0,0 +1,45 @@
+from abc import abstractmethod, ABC
+
+
+# TODO: Utilize shlex.split() for parsing the full command.
+# Reference: https://docs.python.org/3.11/library/shlex.html#shlex.split
+class CommandGrammar(ABC):
+    """
+    Abstract base class for defining the structure and behavior of program command grammars.
+
+    This class enforces a consistent interface for defining a program's executable path, 
+    its options (e.g., flags or configuration switches), and its arguments. It also provides 
+    a mechanism to build the final command to be executed (for subprocess.Popen).
+
+    Properties:
+        - program_path (str): The path to the executable program.
+        - options (list[str]): A list of options or flags to be passed to the program.
+        - program_args (list[str]): A list of arguments for the program.
+
+    Methods:
+        - build_cmd: Constructs the full command as a list of strings that can be passed to 
+                     `subprocess.Popen` or similar command-executing libraries.
+    """
+
+    @abstractmethod
+    def build_cmd(self, *args, **kwargs) -> list[str]:
+        """
+        Constructs the full command as a list of strings.
+
+        This method combines the program path, options, and arguments into a single list
+        that can be passed to a command-execution library such as `subprocess.Popen`.
+
+        Args:
+            *args: Additional arguments to include in the command.
+            **kwargs: Additional keyword arguments to customize the command-building process.
+
+        Returns:
+            list[str]: The full command to be passed to subprocess.Popen.
+
+        Example:
+            ```python
+            def build_cmd(self, *args, **kwargs):
+                return [self.program_path] + self.options + self.program_args
+            ```
+        """
+        pass

marsh/core/connector.py

@@ -0,0 +1,77 @@
+from typing import Optional, Tuple, Any
+from abc import ABC, abstractmethod
+
+
+class Connector(ABC):
+    """
+    Abstract base class for managing connections and executing commands on remote systems.
+
+    The `Connector` class defines an interface for establishing, managing, and closing
+    connections to remote systems, as well as executing commands on those systems.
+    Subclasses must provide concrete implementations for connecting to a remote host,
+    executing a command, and disconnecting from the host.
+
+    Note:
+        Subclasses of `Connector` are responsible for handling specific connection
+        protocols, such as SSH, HTTP, or other custom communication mechanisms.
+    """
+    @abstractmethod
+    def connect(self, *args, **kwargs) -> Optional[Any]:
+        """
+        Establishes a connection to a remote system.
+
+        Args:
+            *args: Positional arguments specific to the connection implementation.
+            **kwargs: Keyword arguments for configuring the connection.
+
+        Returns:
+            Optional[Any]: A connection object or `None` if the connection fails.
+
+        Raises:
+            NotImplementedError: If not implemented in a subclass.
+        """
+        pass
+
+    @abstractmethod
+    def disconnect(self, connection: Any, *args, **kwargs)  -> Optional[Any]:
+        """
+        Closes an active connection to a remote system.
+
+        Args:
+            connection (Any): The connection object to be closed.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            Optional[Any]: Implementation-specific result or `None`.
+
+        Raises:
+            NotImplementedError: If not implemented in a subclass.
+        """
+        pass
+
+    @abstractmethod
+    def exec_cmd(self, command: list[str], connection: Any, *args, **kwargs) -> Tuple[bytes, bytes]:
+        """
+        Executes a command on a remote system and retrieves its output.
+
+        Args:
+            command (list[str]): The command to execute as a list of strings.
+            connection (Any): An active connection object to the remote system.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments (e.g., timeout).
+
+        Returns:
+            Tuple[bytes, bytes]: A tuple containing:
+                - stdout (bytes): The standard output from the command execution.
+                - stderr (bytes): The standard error from the command execution.
+
+        Raises:
+            NotImplementedError: If not implemented in a subclass.
+
+        Note:
+            A `timeout` parameter may be included in `kwargs` to specify the
+            maximum duration for command execution.
+        """
+        # TODO: Add timeout for running a remote command.
+        pass