¿Cómo comprobar si un archivo es un archivo de imagen válido?

Actualmente estoy usando PIL.

from PIL import Image
try:
    im=Image.open(filename)
    # do stuff
except IOError:
    # filename not an image file

Sin embargo, aunque esto cubre suficientemente la mayoría de los casos, algunos archivos de imagen como xcf, svg y psd no se detectan. Los archivos psd arrojan una excepción OverflowError.

¿Hay alguna forma en que pueda incluirlos también?

Muchas veces los primeros dos caracteres serán un número mágico para varios formatos de archivo. Puede verificar esto además de su verificación de excepción anterior.

Acabo de encontrar el módulo imghdr incorporado . De la documentación de Python:

El módulo imghdr determina el tipo de imagen contenida en un archivo o flujo de bytes.

Así es como funciona:

>>> import imghdr
>>> imghdr.what('/tmp/bass')
'gif'

Usar un módulo es mucho mejor que volver a implementar una funcionalidad similar

Además de lo que sugiere Brian, puede utilizar el método de verificación de PIL para comprobar si el archivo está roto.

im.verify ()

Intenta determinar si el archivo está roto, sin realmente decodificar los datos de la imagen. Si este método encuentra algún problema, genera excepciones adecuadas. Este método solo funciona en una imagen recién abierta; si la imagen ya se ha cargado, el resultado no está definido. Además, si necesita cargar la imagen después de usar este método, debe volver a abrir el archivo de imagen. Atributos

Además de la PILverificación de imagen, también puede agregar una verificación de extensión de nombre de archivo como esta:

filename.lower().endswith(('.png', '.jpg', '.jpeg', '.tiff', '.bmp', '.gif'))

Tenga en cuenta que esto solo verifica si el nombre del archivo tiene una extensión de imagen válida, en realidad no abre la imagen para ver si es una imagen válida, es por eso que necesita usar adicionalmente PILo una de las bibliotecas sugeridas en las otras respuestas.

Actualizar

También implementé la siguiente solución en mi script de Python aquí en GitHub .

También verifiqué que los archivos dañados (jpg) con frecuencia no son imágenes 'rotas', es decir, un archivo de imagen dañado a veces sigue siendo un archivo de imagen legítimo, la imagen original se pierde o se altera, pero aún puede cargarla sin errores. Pero, el truncamiento de archivos siempre causa errores.

Finalizar actualización

Puede usar el módulo Python Pillow (PIL), con la mayoría de los formatos de imagen, para verificar si un archivo es un archivo de imagen válido e intacto.

En el caso de que pretenda detectar también imágenes rotas, @Nadia Alramli sugiere correctamente el im.verify()método, pero este no detecta todos los posibles defectos de imagen , por ejemplo, im.verifyno detecta imágenes truncadas (que la mayoría de los espectadores suelen cargar con un área en gris).

Pillow también puede detectar este tipo de defectos, pero debe aplicar la manipulación de imágenes o decodificar / recodificar la imagen o activar la verificación. Finalmente sugiero usar este código:

try:
  im = Image.load(filename)
  im.verify() #I perform also verify, don't know if he sees other types o defects
  im.close() #reload is necessary in my case
  im = Image.load(filename) 
  im.transpose(PIL.Image.FLIP_LEFT_RIGHT)
  im.close()
except: 
  #manage excetions here

En caso de defectos de imagen, este código generará una excepción. Tenga en cuenta que im.verify es aproximadamente 100 veces más rápido que realizar la manipulación de imágenes (y creo que voltear es una de las transformaciones más baratas). Con este código vas a verificar un conjunto de imágenes a unos 10 MBytes / seg con Pillow estándar o 40 MBytes / seg con módulo Pillow-SIMD (CPU moderna x86_64 de 2.5Ghz).

Para los otros formatos psd , xcf , .. puedes usar Imagemagick wrapper Wand , el código es el siguiente:

im = wand.image.Image(filename=filename)
temp = im.flip;
im.close()

Pero, a partir de mis experimentos, Wand no detecta imágenes truncadas, creo que carga las partes que faltan como un área en gris sin preguntar.

Red que Imagemagick tiene una identificación de comando externa que podría hacer el trabajo, pero no he encontrado una manera de invocar esa función programáticamente y no he probado esta ruta.

Sugiero que siempre haga una comprobación preliminar, compruebe el tamaño del archivo a no ser cero (o muy pequeño), es una muy barato idea:

statfile = os.stat(filename)
filesize = statfile.st_size
if filesize == 0:
  #manage here the 'faulty image' case

En Linux, puede usar python-magic ( http://pypi.python.org/pypi/python-magic/0.1 ) que usa libmagic para identificar formatos de archivo.

AFAIK, libmagic busca en el archivo e intenta decirle más sobre él que solo el formato, como las dimensiones del mapa de bits, la versión del formato, etc. Así que puede ver esto como una prueba superficial de "validez".

Para otras definiciones de "válido", es posible que deba escribir sus propias pruebas.

Puede usar los enlaces de Python a libmagic, python-magic y luego verificar los tipos de mime. Esto no le dirá si los archivos están dañados o intactos, pero debería poder determinar qué tipo de imagen es.

Bueno, no conozco el interior de psd, pero sí, sé que, de hecho, svg no es un archivo de imagen en sí mismo, sino que está basado en xml, por lo que es, esencialmente, un archivo de texto sin formato.

Una opción es utilizar el filetypepaquete.

Instalación

python -m pip install filetype

Ventajas

1. Rápido: hace su trabajo cargando los primeros bytes de su imagen ( verifique el número mágico )
2. Admite diferentes tipos de mímica: imágenes, videos, fuentes, audio, archivos.

Ejemplo de solución

import filetype

filename = "/path/to/file.jpg"

if filetype.image(filename):
    print(f"{filename} is a valid image...")
elif filetype.video(filename):
    print(f"{filename} is a valid video...")

Información adicional sobre el repositorio oficial: https://github.com/h2non/filetype.py

¿Sería aceptable comprobar las extensiones de archivo o está tratando de confirmar que los datos en sí representan un archivo de imagen?

Si puede comprobar la extensión del archivo, una expresión regular o una simple comparación podrían satisfacer el requisito.

format = [".jpg",".png",".jpeg"]
 for (path,dirs,files) in os.walk(path):
     for file in files:
         if file.endswith(tuple(format)):
             print(path)
             print ("Valid",file)
         else:
             print(path)
             print("InValid",file)