Ultimate 2025 Guide: Unify SSHLibrary & Paramiko Outputs

If you work in Python automation, you've likely found yourself in this exact spot. For your structured tests, you reach for Robot Framework's SSHLibrary because its keyword-driven approach is clean and readable. But for a complex pre-test setup or a standalone utility script, you need the granular control of Paramiko, the powerful library that SSHLibrary itself is built on.

Using both is smart, but it introduces a subtle, persistent friction: their outputs are completely different. One returns clean strings, the other returns stream objects. Juggling these inconsistencies clutters your code, complicates error handling, and forces you to write similar logic in two different ways.

What if you could make them speak the same language? In this guide, we'll build a simple, elegant solution to unify the outputs from SSHLibrary and Paramiko, making your automation code cleaner, more reusable, and easier to maintain in 2025 and beyond.

Why We Juggle SSHLibrary and Paramiko

To understand the solution, we first need to appreciate the problem. Let's look at how each library executes a simple ls -l command and what it gives back.

SSHLibrary: The High-Level Champion

SSHLibrary is designed for ease of use within test suites. Its Execute Command keyword handles the connection, execution, and result retrieval in one shot, returning a simple tuple of strings and an integer.

# Assuming 'ssh' is an initialized SSHLibrary instance

stdout, stderr, rc = ssh.execute_command('ls -l /tmp', return_stderr=True, return_rc=True)

print(f"STDOUT: {stdout}")
print(f"RC: {rc}")
# STDOUT: total 0
# -rw-r--r--. 1 user group 0 Jan 15 10:00 somefile.txt
# RC: 0

This is great! It's straightforward and gives you exactly what you need: the standard output, standard error, and the return code. Simple and effective.

Paramiko: The Low-Level Powerhouse

Paramiko gives you direct, programmatic access to the SSH protocol. When you execute a command, it doesn't wait for it to finish. Instead, it gives you file-like stream objects for stdin, stdout, and `stderr`.

# Assuming 'client' is an initialized Paramiko SSHClient
import paramiko

stdin, stdout, stderr = client.exec_command('ls -l /tmp')

# You have to read the data from the stream objects
output = stdout.read().decode('utf-8')
errors = stderr.read().decode('utf-8')

# And you need to get the return code separately
rc = stdout.channel.recv_exit_status()

print(f"OUTPUT: {output}")
print(f"RC: {rc}")
# OUTPUT: total 0
# -rw-r--r--. 1 user group 0 Jan 15 10:00 somefile.txt
# RC: 0

This is more powerful—you could process the output as it streams in, for example—but it requires more boilerplate code. The core problem is clear: the shape of the result from ssh.execute_command is fundamentally different from client.exec_command.

Defining Our Unified Command Result

The key to bridging this gap is to define a single, consistent data structure that can represent the result of a command, regardless of which library executed it. Python's dataclasses are perfect for this job. They are lightweight and provide a clean way to bundle related data.

Let's create a CommandResult class.

from dataclasses import dataclass

@dataclass
class CommandResult:
    """A unified structure for holding SSH command results."""
    command: str
    stdout: str
    stderr: str
    rc: int

    def __bool__(self) -> bool:
        """Allows for easy success checking, e.g., `if result:`."""
        return self.rc == 0

    @property
    def succeeded(self) -> bool:
        """An explicit property for checking success."""
        return self.rc == 0

    @property
    def failed(self) -> bool:
        """An explicit property for checking failure."""
        return self.rc != 0

This simple class is our universal translator. It holds the four key pieces of information we always care about: the command that was run, its standard output, its standard error, and its return code. We've also added a handy __bool__ method, which lets us check for success simply by writing if result:. The explicit succeeded and failed properties are also great for readability.

Building the Bridge: Wrapper Functions

Now that we have our target data structure, we can write two small wrapper functions. Each function will take its respective library's client/instance, execute a command, and package the output into our shiny new CommandResult object.

Wrapping Paramiko

The Paramiko wrapper will handle the stream reading, decoding, and exit code retrieval, hiding that complexity from the rest of our code.

import paramiko

def execute_with_paramiko(client: paramiko.SSHClient, command: str) -> CommandResult:
    """Executes a command using Paramiko and returns a unified CommandResult."""
    stdin, stdout, stderr = client.exec_command(command)

    # It's important to get the exit status *after* reading from stdout/stderr
    stdout_str = stdout.read().decode('utf-8').strip()
    stderr_str = stderr.read().decode('utf-8').strip()
    rc = stdout.channel.recv_exit_status()

    return CommandResult(
        command=command,
        stdout=stdout_str,
        stderr=stderr_str,
        rc=rc
    )

Wrapping SSHLibrary

The SSHLibrary wrapper is even simpler, as the library has already done most of the work for us. This is more of a translation layer than a complex wrapper.

from robot.libraries.SSHLibrary import SSHLibrary

def execute_with_sshlibrary(ssh_lib: SSHLibrary, command: str) -> CommandResult:
    """Executes a command using SSHLibrary and returns a unified CommandResult."""
    # SSHLibrary returns results in the order: stdout, stderr, rc
    stdout, stderr, rc = ssh_lib.execute_command(
        command,
        return_stderr=True,
        return_rc=True
    )

    return CommandResult(
        command=command,
        stdout=str(stdout), # Ensure it's a string
        stderr=str(stderr),
        rc=int(rc)
    )

Putting It All Together: A Practical Example

With our wrappers in place, we can now write generic functions that process command results without ever needing to know where they came from. Let's create a simple handler that logs the outcome of a command.

def log_command_outcome(result: CommandResult):
    """A generic function to process any CommandResult object."""
    print(f"--- Executed Command: `{result.command}` ---")
    if result.succeeded:
        print(f"✅ SUCCESS (RC={result.rc})")
        print("Output:")
        print(result.stdout or "[No Stderr]")
    else:
        print(f"❌ FAILED (RC={result.rc})")
        print("Error Output:")
        print(result.stderr or "[No Stderr]")
    print("-------------------------------------------------")

Now, let's see it in action. Imagine a script where we first use Paramiko for some initial setup, and then later, we might use SSHLibrary within a larger test context.

# --- Scenario 1: Using the Paramiko Wrapper ---
# (Assume 'paramiko_client' is connected)
print("Running setup with Paramiko...")
result1 = execute_with_paramiko(paramiko_client, "touch /tmp/paramiko_was_here.txt")
log_command_outcome(result1)

result2 = execute_with_paramiko(paramiko_client, "ls /nonexistent_directory")
log_command_outcome(result2)

# --- Scenario 2: Using the SSHLibrary Wrapper ---
# (Assume 'ssh_library_instance' is connected)
print("\nRunning tests with SSHLibrary...")
result3 = execute_with_sshlibrary(ssh_library_instance, "ls -l /tmp/paramiko_was_here.txt")
log_command_outcome(result3)

result4 = execute_with_sshlibrary(ssh_library_instance, "rm /nonexistent_file")
log_command_outcome(result4)

The beauty here is that log_command_outcome works identically for both. We've successfully abstracted away the implementation detail of how the SSH command was executed. Our high-level logic is now clean, consistent, and reusable.

Conclusion: Streamlined SSH for 2025

By investing a few minutes to create a unified CommandResult dataclass and a couple of simple wrapper functions, you eliminate a persistent source of friction in your Python automation projects. This small pattern pays huge dividends:

• Code Reusability: Write common error handlers, loggers, and result processors once and use them everywhere.
• Improved Readability: Your high-level logic is no longer cluttered with `if/else` blocks to handle different result types.
• Reduced Cognitive Load: You and your team only need to think about one type of result object: CommandResult.
• Enhanced Maintainability: Refactoring or debugging becomes much simpler when your data contracts are consistent.

Stop juggling different outputs. Adopt this unified approach and make your SSH-based automation cleaner, more robust, and ready for the challenges of 2025.