Como escapar de chamadas de os.system ()?

Ao usar os.system (), muitas vezes é necessário escapar nomes de arquivos e outros argumentos passados ​​como parâmetros para comandos. Como posso fazer isso? De preferência algo que funcionaria em vários sistemas operacionais / shells, mas em particular no bash.

Atualmente, estou fazendo o seguinte, mas tenho certeza de que deve haver uma função de biblioteca para isso, ou pelo menos uma opção mais elegante / robusta / eficiente:

def sh_escape(s):
   return s.replace("(","\\(").replace(")","\\)").replace(" ","\\ ")

os.system("cat %s | grep something | sort > %s" 
          % (sh_escape(in_filename), 
             sh_escape(out_filename)))

Edit: Aceitei a resposta simples de usar aspas, não sei por que não pensei nisso; Eu acho que porque eu vim do Windows, onde 'e "se comportam de maneira um pouco diferente.

Em relação à segurança, entendo a preocupação, mas, neste caso, estou interessado em uma solução rápida e fácil fornecida pelo os.system (), e a origem das strings não é gerada pelo usuário ou, pelo menos, inserida por um usuário confiável (eu).

Isto é o que eu uso:

def shellquote(s):
    return "'" + s.replace("'", "'\\''") + "'"

O shell sempre aceita um nome de arquivo citado e remove as aspas circundantes antes de passá-lo para o programa em questão. Notavelmente, isso evita problemas com nomes de arquivos que contêm espaços ou qualquer outro tipo de metacaractere desagradável do shell.

Atualização : se você estiver usando o Python 3.3 ou posterior, use shlex.quote em vez de usar o seu próprio.

shlex.quote() faz o que você quer desde o python 3.

(Use pipes.quotepara suportar python 2 e python 3)

Talvez você tenha uma razão específica para usar os.system(). Mas se não, você provavelmente deveria estar usando o subprocessmódulo . Você pode especificar os tubos diretamente e evitar o uso da concha.

O seguinte é do PEP324 :

Replacing shell pipe line
-------------------------

output=`dmesg | grep hda`
==>
p1 = Popen(["dmesg"], stdout=PIPE)
p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
output = p2.communicate()[0]

Talvez subprocess.list2cmdlineseja uma chance melhor?

Observe que o pipes.quote é realmente quebrado no Python 2.5 e Python 3.1 e não é seguro de usar - ele não manipula argumentos de comprimento zero.

>>> from pipes import quote
>>> args = ['arg1', '', 'arg3']
>>> print 'mycommand %s' % (' '.join(quote(arg) for arg in args))
mycommand arg1  arg3

Veja Python edição 7476 ; foi corrigido no Python 2.6 e 3.2 e mais recente.

Aviso : Esta é uma resposta para o Python 2.7.x.

Segundo a fonte , pipes.quote()é uma maneira de " Citar com segurança uma string como um único argumento para / bin / sh ". (Embora tenha sido descontinuado desde a versão 2.7 e finalmente exposto publicamente no Python 3.3 como a shlex.quote()função.)

Por outro lado , subprocess.list2cmdline()é uma maneira de " Traduzir uma sequência de argumentos em uma sequência de linhas de comando, usando as mesmas regras do tempo de execução do MS C ".

Aqui estamos, a maneira independente da plataforma de citar seqüências de caracteres para linhas de comando.

import sys
mswindows = (sys.platform == "win32")

if mswindows:
    from subprocess import list2cmdline
    quote_args = list2cmdline
else:
    # POSIX
    from pipes import quote

    def quote_args(seq):
        return ' '.join(quote(arg) for arg in seq)

Uso:

# Quote a single argument
print quote_args(['my argument'])

# Quote multiple arguments
my_args = ['This', 'is', 'my arguments']
print quote_args(my_args)

Acredito que o os.system invoque qualquer shell de comando configurado para o usuário, então não acho que você possa fazê-lo de maneira independente da plataforma. Meu shell de comando pode ser qualquer coisa, desde bash, emacs, ruby ​​ou até quake3. Alguns desses programas não esperam o tipo de argumento que você está passando para eles e, mesmo que o fizessem, não há garantia de que eles escapam da mesma maneira.

A função que eu uso é:

def quote_argument(argument):
    return '"%s"' % (
        argument
        .replace('\\', '\\\\')
        .replace('"', '\\"')
        .replace('$', '\\$')
        .replace('`', '\\`')
    )

ou seja: eu sempre coloco o argumento entre aspas duplas e depois aspiro com barra invertida os únicos caracteres especiais entre aspas duplas.

Se você usar o comando system, eu tentaria incluir o que entra na chamada os.system () na lista de permissões. Por exemplo ..

clean_user_input re.sub("[^a-zA-Z]", "", user_input)
os.system("ls %s" % (clean_user_input))

O módulo de subprocesso é uma opção melhor e eu recomendaria tentar evitar usar algo como os.system / subprocess sempre que possível.

A resposta real é: não use os.system()em primeiro lugar. Use em subprocess.callvez disso e forneça os argumentos sem escape.