¿Convertir una cadena en un nombre de archivo válido?

Tengo una cadena que quiero usar como nombre de archivo, por lo que quiero eliminar todos los caracteres que no se permitirían en los nombres de archivo, usando Python.

Prefiero ser estricto que lo contrario, así que digamos que quiero retener solo letras, dígitos y un pequeño conjunto de otros caracteres como "_-.() ". ¿Cuál es la solución más elegante?

El nombre de archivo debe ser válido en varios sistemas operativos (Windows, Linux y Mac OS): es un archivo MP3 en mi biblioteca con el título de la canción como nombre de archivo, y se comparte y realiza una copia de seguridad entre 3 máquinas.

Puede ver el marco de Django para ver cómo crean una "babosa" a partir de texto arbitrario. Una babosa es compatible con URL y nombre de archivo.

Las utilidades de texto de Django definen una función, slugify()que probablemente sea el estándar de oro para este tipo de cosas. Esencialmente, su código es el siguiente.

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

Hay más, pero lo dejé fuera, ya que no aborda la slugificación, sino el escape.

Este enfoque de la lista blanca (es decir, permitir solo los caracteres presentes en valid_chars) funcionará si no hay límites en el formato de los archivos o la combinación de caracteres válidos que son ilegales (como ".."), por ejemplo, lo que usted dice permitiría un nombre de archivo llamado ". txt" que creo que no es válido en Windows. Como este es el enfoque más simple, trataría de eliminar los espacios en blanco de los valid_chars y anteponer una cadena válida conocida en caso de error, cualquier otro enfoque tendrá que saber qué está permitido dónde hacer frente a las limitaciones de nomenclatura de archivos de Windows y así ser Mucho más complejo.

>>> 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'

Puede usar la comprensión de listas junto con los métodos de cadena.

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

¿Cuál es la razón para usar las cadenas como nombres de archivo? Si la legibilidad humana no es un factor, optaría por el módulo base64 que puede producir cadenas seguras del sistema de archivos. No será legible, pero no tendrá que lidiar con colisiones y es reversible.

import base64
file_name_string = base64.urlsafe_b64encode(your_string)

Actualización : modificado según el comentario de Matthew.

Para complicar aún más las cosas, no se garantiza que obtenga un nombre de archivo válido simplemente eliminando caracteres no válidos. Dado que los caracteres permitidos difieren en diferentes nombres de archivo, un enfoque conservador podría terminar convirtiendo un nombre válido en uno inválido. Es posible que desee agregar un manejo especial para los casos donde:

• La cadena son todos caracteres no válidos (dejándolo con una cadena vacía)

• Terminas con una cadena con un significado especial, por ejemplo, "." o ".."

• En Windows, ciertos nombres de dispositivos están reservados. Por ejemplo, no puede crear un archivo llamado "nul", "nul.txt" (o nul.anything de hecho) Los nombres reservados son:

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

Probablemente pueda solucionar estos problemas anteponiendo alguna cadena a los nombres de archivo que nunca pueden dar lugar a uno de estos casos y eliminando caracteres no válidos.

Hay un buen proyecto en Github llamado python-slugify :

Instalar en pc:

pip install python-slugify

Luego usa:

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

Al igual que S.Lott respondió, puede ver el Marco de Django para ver cómo convierten una cadena en un nombre de archivo válido.

La versión más reciente y actualizada se encuentra en utils / text.py, y define "get_valid_filename", que es el siguiente:

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

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

Esta es la solución que finalmente utilicé:

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)

La llamada unicodedata.normalize reemplaza los caracteres acentuados con el equivalente sin acento, lo cual es mejor que simplemente eliminarlos. Después de eso, se eliminan todos los caracteres no permitidos.

Mi solución no antepone una cadena conocida para evitar posibles nombres de archivo no permitidos, porque sé que no pueden aparecer dado mi formato de nombre de archivo particular. Una solución más general necesitaría hacerlo.

Tenga en cuenta que en realidad no hay restricciones para los nombres de archivos en sistemas Unix que no sean

• Puede no contener \ 0
• Puede no contener /

Todo lo demás es juego limpio.

$ touch "
> incluso multilínea
> jaja
> ^ [[31m rojo ^ [[0m
> maldad "
$ ls -la 
-rw-r - r-- 0 17 de noviembre 23:39? incluso multilínea? jaja ?? [31m rojo? [0m? malvado
$ ls -lab
-rw-r - r-- 0 17 de noviembre 23:39 \ neven \ multiline \ nhaha \ n \ 033 [31m \ red \ \ 033 [0m \ nevil
$ perl -e 'para mi $ i (glob (q {./* even *})) {print $ i; } '
./
incluso multilínea
jaja
 rojo 
mal

Sí, acabo de almacenar códigos de color ANSI en un nombre de archivo y los hice surtir efecto.

Para entretenerse, coloque un carácter BEL en el nombre de un directorio y vea la diversión que se produce cuando lo graba en CD;)

En una linea:

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

También puede poner el carácter '_' para hacerlo más legible (por ejemplo, en caso de reemplazar barras)

Puede usar el método re.sub () para reemplazar cualquier cosa que no sea "similar a un archivo". Pero en efecto, cada personaje podría ser válido; así que no hay funciones preconstruidas (creo), para hacerlo.

import re

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

Resultaría en un identificador de archivo 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'

No maneja cadenas vacías, nombres de archivo especiales ('nul', 'con', etc.).

Aunque tienes que tener cuidado. No se dice claramente en su introducción, si solo está mirando el lenguaje latine. Algunas palabras pueden dejar de tener sentido u otro significado si las desinfecta con caracteres ascii solamente.

imagina que tienes "forêt poésie" (poesía forestal), tu desinfección podría dar "fort-posie" (fuerte + algo sin sentido)

Peor si tienes que lidiar con caracteres chinos.

"下 北 沢" su sistema podría terminar haciendo "---" que está condenado a fallar después de un tiempo y no es muy útil. Por lo tanto, si maneja solo archivos, le recomendaría que los llame una cadena genérica que usted controla o que mantenga los caracteres como están. Para los URI, casi lo mismo.

¿Por qué no simplemente envolver el "osopen" con un try / except y dejar que el sistema operativo subyacente sepa si el archivo es válido?

Esto parece mucho menos trabajo y es válido sin importar qué sistema operativo use.

Otro problema que los otros comentarios aún no han abordado es la cadena vacía, que obviamente no es un nombre de archivo válido. También puede terminar con una cadena vacía al eliminar demasiados caracteres.

¿Qué pasa con los nombres de archivos reservados de Windows y los problemas con los puntos, la respuesta más segura a la pregunta "¿cómo normalizo un nombre de archivo válido a partir de la entrada arbitraria del usuario?" es "no te molestes en intentarlo": si puedes encontrar alguna otra forma de evitarlo (por ejemplo, usando claves primarias enteras de una base de datos como nombres de archivo), hazlo.

Si debe hacerlo, y realmente necesita permitir espacios y '.' para extensiones de archivo como parte del nombre, intente 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

Incluso esto no se puede garantizar correctamente, especialmente en sistemas operativos inesperados, por ejemplo, el sistema operativo RISC odia los espacios y usa ''. como un separador de directorio

Me gustó el enfoque de pitón-slugify aquí, pero también estaba quitando puntos que no era deseable. Así que lo optimicé para subir un nombre de archivo limpio a s3 de esta manera:

pip install python-slugify

Código de ejemplo:

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

Salida:

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

Esto es tan seguro, funciona con nombres de archivo sin extensión e incluso funciona solo con nombres de archivos de caracteres inseguros (el resultado está noneaquí).

Respuesta 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)

Me doy cuenta de que hay muchas respuestas, pero en su mayoría se basan en expresiones regulares o módulos externos, por lo que me gustaría agregar mi propia respuesta. Una función de Python pura, no se necesita un módulo externo, no se utiliza ninguna expresión regular. Mi enfoque no es limpiar los caracteres inválidos, sino solo permitir los 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    

si lo desea, puede agregar sus propios caracteres válidos a la validchars variable al principio, como sus letras nacionales que no existen en el alfabeto inglés. Esto es algo que puede querer o no: algunos sistemas de archivos que no se ejecutan en UTF-8 podrían tener problemas con caracteres no ASCII.

Esta función es para probar la validez de un solo nombre de archivo, por lo que reemplazará los separadores de ruta con _ considerándolos caracteres no válidos. Si desea agregar eso, es trivial modificar el ifseparador de ruta para incluir OS.

La mayoría de estas soluciones no funcionan.

'/ hello / world' -> 'helloworld'

'/ helloworld' / -> 'helloworld'

En general, esto no es lo que desea, digamos que está guardando el html para cada enlace, va a sobrescribir el html para una página web diferente.

Me salmuera un dictado como:

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

2 representa el número que debe agregarse al siguiente nombre de archivo.

Busco el nombre de archivo cada vez del dict. Si no está allí, creo uno nuevo, agregando el número máximo si es necesario.

No es exactamente lo que estaba pidiendo OP, pero esto es lo que uso porque necesito conversiones únicas y reversibles:

# 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+-_ .'))

El resultado es "algo" legible, al menos desde el punto de vista del administrador de sistemas.

Si no le importa instalar un paquete, esto debería ser útil: https://pypi.org/project/pathvalidate/

Desde 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")

Salida

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

Estoy seguro de que esta no es una gran respuesta, ya que modifica la cadena sobre la que se repite, pero parece funcionar bien:

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, '')

ACTUALIZAR

Todos los enlaces rotos sin posibilidad de reparación en esta respuesta de 6 años.

Además, tampoco lo haría de esta manera, solo base64codificaría o soltaría caracteres inseguros. Ejemplo 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'

Con base64usted puede codificar y decodificar, para que pueda recuperar el nombre de archivo original nuevamente.

Pero dependiendo del caso de uso, es mejor que genere un nombre de archivo aleatorio y almacene los metadatos en un archivo separado o DB.

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'

RESPUESTA ORIGINAL LINKROTTEN :

El bobcatproyecto contiene un módulo de Python que hace exactamente esto.

No es completamente robusto, mira esta publicación y esta respuesta .

Entonces, como se señaló: la base64codificación es probablemente una mejor idea si la legibilidad no importa.

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