Transformar uma string em um nome de arquivo válido?

Eu tenho uma string que quero usar como nome de arquivo, então quero remover todos os caracteres que não seriam permitidos nos nomes de arquivos, usando Python.

Prefiro ser rigoroso do que o contrário, então digamos que quero reter apenas letras, dígitos e um pequeno conjunto de outros caracteres, como "_-.() ". Qual é a solução mais elegante?

O nome do arquivo precisa ser válido em vários sistemas operacionais (Windows, Linux e Mac OS) - é um arquivo MP3 na minha biblioteca com o título da música como nome do arquivo e é compartilhado e copiado entre três máquinas.

Você pode olhar para o estrutura do Django para saber como eles criam uma "lesma" a partir de texto arbitrário. Uma lesma é compatível com URL e nome de arquivo.

Os utilitários de texto do Django definem uma função, slugify()que provavelmente é o padrão-ouro para esse tipo de coisa. Essencialmente, o código deles é o seguinte.

def slugify(value):
    """
    Normalizes string, converts to lowercase, removes non-alpha characters,
    and converts spaces to hyphens.
    """
    import unicodedata
    value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore')
    value = unicode(re.sub('[^\w\s-]', '', value).strip().lower())
    value = unicode(re.sub('[-\s]+', '-', value))
    # ...
    return value

Há mais, mas deixei de fora, já que não trata de slugification, mas de escapar.

Essa abordagem da lista de permissões (ou seja, permitir apenas os caracteres presentes em valid_chars) funcionará se não houver limites na formatação dos arquivos ou na combinação de caracteres válidos que são ilegais (como ".."), por exemplo, o que você diz permitiria um nome de arquivo chamado ". txt" que eu acho que não é válido no Windows. Como esta é a abordagem mais simples, eu tentaria remover o espaço em branco dos valid_chars e acrescentar uma sequência válida conhecida em caso de erro, qualquer outra abordagem precisará saber sobre o que é permitido lidar com as limitações de nomeação de arquivos do Windows e, portanto, ser muito mais complexo.

>>> import string
>>> valid_chars = "-_.() %s%s" % (string.ascii_letters, string.digits)
>>> valid_chars
'-_.() abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
>>> filename = "This Is a (valid) - filename%$&$ .txt"
>>> ''.join(c for c in filename if c in valid_chars)
'This Is a (valid) - filename .txt'

Você pode usar a compreensão da lista junto com os métodos de string.

>>> s
'foo-bar#baz?qux@127/\\9]'
>>> "".join(x for x in s if x.isalnum())
'foobarbazqux1279'

Qual é o motivo para usar as strings como nomes de arquivo? Se a legibilidade humana não for um fator, eu usaria o módulo base64, que pode produzir seqüências seguras do sistema de arquivos. Não será legível, mas você não terá que lidar com colisões e é reversível.

import base64
file_name_string = base64.urlsafe_b64encode(your_string)

Atualização : Alterada com base no comentário de Matthew.

Só para complicar ainda mais as coisas, não é garantido que você obtenha um nome de arquivo válido apenas removendo caracteres inválidos. Como os caracteres permitidos diferem em nomes de arquivos diferentes, uma abordagem conservadora pode acabar transformando um nome válido em um nome inválido. Você pode adicionar um tratamento especial para os casos em que:

• A sequência é composta por todos os caracteres inválidos (deixando uma sequência vazia)

• Você acaba com uma string com um significado especial, por exemplo, "." ou ".."

• No Windows, determinados nomes de dispositivos são reservados. Por exemplo, você não pode criar um arquivo chamado "nul", "nul.txt" (ou nul.anything, de fato). Os nomes reservados são:

  CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, ​​COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 e LPT9

Provavelmente, você pode solucionar esses problemas anexando alguma sequência aos nomes de arquivos que nunca podem resultar em um desses casos e eliminando caracteres inválidos.

Existe um bom projeto no Github chamado python-slugify :

Instalar:

pip install python-slugify

Então use:

>>> from slugify import slugify
>>> txt = "This\ is/ a%#$ test ---"
>>> slugify(txt)
'this-is-a-test'

Assim como S.Lott respondeu, você pode olhar para o Django Framework para saber como eles convertem uma string em um nome de arquivo válido.

A versão mais recente e atualizada é encontrada em utils / text.py e define "get_valid_filename", que é o seguinte:

def get_valid_filename(s):
    s = str(s).strip().replace(' ', '_')
    return re.sub(r'(?u)[^-\w.]', '', s)

(Consulte https://github.com/django/django/blob/master/django/utils/text.py )

Esta é a solução que eu finalmente usei:

import unicodedata

validFilenameChars = "-_.() %s%s" % (string.ascii_letters, string.digits)

def removeDisallowedFilenameChars(filename):
    cleanedFilename = unicodedata.normalize('NFKD', filename).encode('ASCII', 'ignore')
    return ''.join(c for c in cleanedFilename if c in validFilenameChars)

A chamada unicodedata.normalize substitui caracteres acentuados pelo equivalente não acentuado, o que é melhor do que simplesmente removê-los. Depois disso, todos os caracteres não permitidos são removidos.

Minha solução não anexa uma sequência conhecida para evitar possíveis nomes de arquivos não permitidos, porque eu sei que eles não podem ocorrer devido ao meu formato de nome de arquivo específico. Uma solução mais geral precisaria fazê-lo.

Lembre-se de que não há restrições sobre nomes de arquivos em sistemas Unix além de

• Pode não conter \ 0
• Pode não conter /

Tudo o resto é jogo justo.

$ touch "
> mesmo multilinha
> haha
> ^ [[31m vermelho ^ [[0m
> mal "
$ ls -la 
-rw-r - r-- 0 Nov 17 23:39? mesmo multilinha? haha ​​?? [31m vermelho? [0m? mal
$ ls -lab
-rw-r - r-- 0 17 de novembro 23:39 \ neven \ multiline \ nhaha \ n \ 033 [31m \ red \ \ 033 [0m \ nevil
$ perl -e 'para o meu $ i (glob (q {./* even *})) {print $ i; } '
./
mesmo multilinha
haha
 vermelho 
mal

Sim, eu apenas armazenei códigos de cores ANSI em um nome de arquivo e os fiz efeito.

Para entretenimento, coloque um caractere BEL em um nome de diretório e assista à diversão que se segue quando você faz o CD nele;)

Em uma linha:

valid_file_name = re.sub('[^\w_.)( -]', '', any_string)

você também pode colocar o caractere '_' para torná-lo mais legível (no caso de substituir barras, por exemplo)

Você pode usar o método re.sub () para substituir qualquer coisa que não seja "semelhante a um arquivo". Mas, na verdade, todo personagem pode ser válido; então não há funções pré-construídas (acredito), para fazê-lo.

import re

str = "File!name?.txt"
f = open(os.path.join("/tmp", re.sub('[^-a-zA-Z0-9_.() ]+', '', str))

Resultaria em uma manipulação de arquivo para /tmp/filename.txt.

>>> import string
>>> safechars = bytearray(('_-.()' + string.digits + string.ascii_letters).encode())
>>> allchars = bytearray(range(0x100))
>>> deletechars = bytearray(set(allchars) - set(safechars))
>>> filename = u'#ab\xa0c.$%.txt'
>>> safe_filename = filename.encode('ascii', 'ignore').translate(None, deletechars).decode()
>>> safe_filename
'abc..txt'

Ele não lida com strings vazias, nomes de arquivos especiais ('nul', 'con' etc.).

Embora você tenha que ter cuidado. Não está claramente dito em sua introdução, se você estiver olhando apenas para o idioma latino. Algumas palavras podem se tornar sem sentido ou outro significado se você as higienizar apenas com caracteres ascii.

imagine que você tem "forêt poésie" (poesia florestal), sua sanitização pode dar "fort-posie" (forte + algo sem sentido)

Pior se você tiver que lidar com caracteres chineses.

"下 北 沢" seu sistema pode acabar fazendo "---", que está fadado a falhar depois de um tempo e não é muito útil. Portanto, se você lida apenas com arquivos, eu os incentivaria a chamá-los de uma cadeia genérica que você controla ou a manter os caracteres como são. Para URIs, aproximadamente o mesmo.

Por que não apenas envolver o "osopen" com uma tentativa / exceção e deixar o sistema operacional subjacente determinar se o arquivo é válido?

Isso parece muito menos trabalho e é válido, independentemente do sistema operacional que você usa.

Outro problema que os outros comentários ainda não abordaram é a string vazia, que obviamente não é um nome de arquivo válido. Você também pode acabar com uma string vazia, eliminando muitos caracteres.

O que com os nomes de arquivos reservados do Windows e os problemas com pontos, a resposta mais segura para a pergunta "como normalizar um nome de arquivo válido a partir de entradas arbitrárias do usuário?" é “nem se preocupe em tentar”: se você encontrar outra maneira de evitá-lo (por exemplo, usando chaves primárias inteiras de um banco de dados como nomes de arquivos), faça isso.

Se você precisar, e realmente precisa permitir espaços e '.' para extensões de arquivo como parte do nome, tente algo como:

import re
badchars= re.compile(r'[^A-Za-z0-9_. ]+|^\.|\.$|^ | $|^$')
badnames= re.compile(r'(aux|com[1-9]|con|lpt[1-9]|prn)(\.|$)')

def makeName(s):
    name= badchars.sub('_', s)
    if badnames.match(name):
        name= '_'+name
    return name

Mesmo isso não pode ser garantido, especialmente em sistemas operacionais inesperados - por exemplo, o RISC OS odeia espaços e usa '.' como um separador de diretório.

Gostei da abordagem python-slugify aqui, mas ela também estava removendo pontos, o que não era desejado. Então, eu o otimizei para enviar um nome de arquivo limpo para o s3 desta maneira:

pip install python-slugify

Código de exemplo:

s = 'Very / Unsafe / file\nname hähä \n\r .txt'
clean_basename = slugify(os.path.splitext(s)[0])
clean_extension = slugify(os.path.splitext(s)[1][1:])
if clean_extension:
    clean_filename = '{}.{}'.format(clean_basename, clean_extension)
elif clean_basename:
    clean_filename = clean_basename
else:
    clean_filename = 'none' # only unclean characters

Resultado:

>>> clean_filename
'very-unsafe-file-name-haha.txt'

Isso é à prova de falhas, funciona com nomes de arquivos sem extensão e funciona apenas para nomes de arquivos de caracteres não seguros (o resultado está noneaqui).

Resposta modificada para python 3.6

import string
import unicodedata

validFilenameChars = "-_.() %s%s" % (string.ascii_letters, string.digits)
def removeDisallowedFilenameChars(filename):
    cleanedFilename = unicodedata.normalize('NFKD', filename).encode('ASCII', 'ignore')
    return ''.join(chr(c) for c in cleanedFilename if chr(c) in validFilenameChars)

Sei que há muitas respostas, mas elas se baseiam principalmente em expressões regulares ou módulos externos, então eu gostaria de dar minha própria resposta. Uma função python pura, nenhum módulo externo necessário, nenhuma expressão regular usada. Minha abordagem não é limpar caracteres inválidos, mas apenas permitir caracteres válidos.

def normalizefilename(fn):
    validchars = "-_.() "
    out = ""
    for c in fn:
      if str.isalpha(c) or str.isdigit(c) or (c in validchars):
        out += c
      else:
        out += "_"
    return out    

se desejar, você pode adicionar seus próprios caracteres válidos à validcharsvariável no início, como as letras nacionais que não existem no alfabeto inglês. Isso é algo que você pode ou não querer: alguns sistemas de arquivos que não são executados no UTF-8 ainda podem ter problemas com caracteres não-ASCII.

Esta função é para testar a validade de um único arquivo, portanto substituirá os separadores de caminho por _ considerando-os como caracteres inválidos. Se você quiser adicionar isso, é trivial modificar o ifpara incluir o separador de caminho os.

A maioria dessas soluções não funciona.

'/ olá / mundo' -> 'helloworld'

'/ helloworld' / -> 'helloworld'

Isso não é o que você deseja em geral, digamos que você esteja salvando o html para cada link, você substituirá o html por uma página da web diferente.

Eu escolho um ditado como:

{'helloworld': 
    (
    {'/hello/world': 'helloworld', '/helloworld/': 'helloworld1'},
    2)
    }

2 representa o número que deve ser anexado ao próximo nome do arquivo.

Eu procuro o nome do arquivo toda vez que ditar. Se não estiver lá, eu crio um novo, acrescentando o número máximo, se necessário.

Não é exatamente o que o OP estava pedindo, mas é isso que eu uso, porque preciso de conversões únicas e reversíveis:

# p3 code
def safePath (url):
    return ''.join(map(lambda ch: chr(ch) if ch in safePath.chars else '%%%02x' % ch, url.encode('utf-8')))
safePath.chars = set(map(lambda x: ord(x), '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+-_ .'))

O resultado é "um pouco" legível, pelo menos do ponto de vista do administrador de sistemas.

Se você não se importa em instalar um pacote, isso deve ser útil: https://pypi.org/project/pathvalidate/

Em https://pypi.org/project/pathvalidate/#sanitize-a-filename :

from pathvalidate import sanitize_filename

fname = "fi:l*e/p\"a?t>h|.t<xt"
print(f"{fname} -> {sanitize_filename(fname)}\n")
fname = "\0_a*b:c<d>e%f/(g)h+i_0.txt"
print(f"{fname} -> {sanitize_filename(fname)}\n")

Resultado

fi:l*e/p"a?t>h|.t<xt -> filepath.txt
_a*b:c<d>e%f/(g)h+i_0.txt -> _abcde%f(g)h+i_0.txt

Tenho certeza de que essa não é uma ótima resposta, pois modifica a string em que está sendo repetida, mas parece funcionar bem:

import string
for chr in your_string:
 if chr == ' ':
   your_string = your_string.replace(' ', '_')
 elif chr not in string.ascii_letters or chr not in string.digits:
    your_string = your_string.replace(chr, '')

ATUALIZAR

Todos os links quebrados além do reparo nesta resposta de 6 anos.

Além disso, eu também não faria mais dessa maneira, apenas base64codificaria ou soltaria caracteres não seguros. Exemplo de Python 3:

import re
t = re.compile("[a-zA-Z0-9.,_-]")
unsafe = "abc∂éåß®∆˚˙©¬ñ√ƒµ©∆∫ø"
safe = [ch for ch in unsafe if t.match(ch)]
# => 'abc'

Com base64você pode codificar e decodificar, para recuperar o nome do arquivo original novamente.

Mas, dependendo do caso de uso, é melhor gerar um nome de arquivo aleatório e armazenar os metadados em um arquivo ou banco de dados separado.

from random import choice
from string import ascii_lowercase, ascii_uppercase, digits
allowed_chr = ascii_lowercase + ascii_uppercase + digits

safe = ''.join([choice(allowed_chr) for _ in range(16)])
# => 'CYQ4JDKE9JfcRzAZ'

RESPOSTA ORIGINAL LINKROTTEN :

O bobcatprojeto contém um módulo python que faz exatamente isso.

Não é completamente robusto, veja este post e esta resposta .

Portanto, como observado: a base64codificação é provavelmente uma idéia melhor se a legibilidade não for importante.

• Documentos https://svn.origo.ethz.ch/bobcat/src-doc/safefilename-module.html
• Fonte https://svn.origo.ethz.ch/bobcat/trunk/src/bobcatlib/safefilename.py