Pexpect might be useful for you: http://sourceforge.net/projects/pexpect/

Description from the webpage: "Pexpect is a Python module for spawning child applications; controlling them; and responding to expected patterns in their output. Pexpect can be used for automating interactive applications such as ssh, ftp, passwd, telnet, etc. Pexpect is pure Python."

You need to drop the stdout=subprocess.PIPE. Doing that disconnects the stdout of your process from Python's stdout and makes it retrievable using the Popen.communicate() function, like so:

import subprocess

spooky_path = 'ls'
cmd = [spooky_path, '-l']
process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
output = process.communicate()[0]
print "Output:", output
process.wait()
print('Done')

To make it print directly you can use it without the stdout argument:

process = subprocess.Popen(cmd)

Or you can use the call function:

process = subprocess.call(cmd)

Maybe you want something from Subprocess (MOTW).

I use code like this to make calls out to the shell:

from subprocess import Popen, PIPE

## shell out, prompt
def shell(args, input_=''):
    ''' uses subprocess pipes to call out to the shell.
    
    args:  args to the command
    input:  stdin
    
    returns stdout, stderr
    '''
    p = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE)
    stdout, stderr = p.communicate(input=input_)
    return stdout, stderr

Read the parameters from sys.argv, and pass them to subprocess.call() (or perhaps one of the other functions in subprocess). subprocess.call() takes a list to specify the command to run and it's parameters, which is a good fit for sys.argv.

Could be as simple as this, in case there's no need to check, process or filter the parameters:

#!/usr/bin/env python3
import subprocess
import sys
subprocess.call(sys.argv[1:])

Called as e.g. wrap.py ls -l, it will execute ls -l.

I've achieved this by defining a group/command like this:

import subprocess

import click


@click.group()
def cli():
    pass


@cli.command(context_settings=dict(
    ignore_unknown_options=True,
    allow_extra_args=True,
))
@click.argument('command')
@click.pass_context
def run(ctx, command):
    subprocess.run([command, *ctx.args])


if __name__ == '__main__':
    cli()

and invoking it from my shell like:

python main.py run git -- --help
python main.py run git -- add --help
python main.py run git -- branch --help

python main.py run ls -- -al

Essentially, I told my click command to passthrough all arguments it receives to the command I have specified.

Hope this answers your question.