Supongamos que desea guardar un montón de archivos en algún lugar, por ejemplo, en BLOB. Supongamos que desea distribuir estos archivos a través de una página web y que el cliente abra automáticamente la aplicación / visor correcto.

Suposición: el navegador determina qué aplicación / visor debe usar el encabezado mime-type (content-type?) En la respuesta HTTP.

Según esa suposición, además de los bytes del archivo, también desea guardar el tipo MIME.

¿Cómo encontrarías el tipo MIME de un archivo? Actualmente estoy en una Mac, pero esto también debería funcionar en Windows.

¿El navegador agrega esta información cuando publica el archivo en la página web?

¿Hay una biblioteca de Python ordenada para encontrar esta información? ¿Un servicio web o (aún mejor) una base de datos descargable?

El método python-magic sugerido por toivotuo está desactualizado. El tronco actual de Python-magic está en Github y, según el archivo Léame allí, encontrar el tipo MIME se hace así.

# For MIME types
import magic
mime = magic.Magic(mime=True)
mime.from_file("testdata/test.pdf") # 'application/pdf'

El módulo mimetypes en la biblioteca estándar determinará / adivinará el tipo MIME a partir de una extensión de archivo.

Si los usuarios están cargando archivos, la publicación HTTP contendrá el tipo MIME del archivo junto con los datos. Por ejemplo, Django hace que estos datos estén disponibles como un atributo del objeto UploadedFile .

Una forma más confiable de usar la biblioteca de tipos de mime sería utilizar el paquete python-magic.

import magic
m = magic.open(magic.MAGIC_MIME)
m.load()
m.file("/tmp/document.pdf")

Esto sería equivalente a usar el archivo (1).

En Django también se puede asegurar que el tipo MIME coincida con el de UploadedFile.content_type.

Esto parece ser muy fácil.

>>> from mimetypes import MimeTypes
>>> import urllib 
>>> mime = MimeTypes()
>>> url = urllib.pathname2url('Upload.xml')
>>> mime_type = mime.guess_type(url)
>>> print mime_type
('application/xml', None)

Por favor, consulte la publicación anterior

Actualización : según el comentario de @Garrets, en python 3 es más simple:

import mimetypes
print(mimetypes.guess_type("sample.html"))

Hay 3 bibliotecas diferentes que envuelven libmagic.

2 de ellos están disponibles en pypi (por lo que la instalación de pip funcionará):

• filemagic
• pitón-magia

Y otro, similar a python-magic, está disponible directamente en las últimas fuentes de libmagic, y es el que probablemente tenga en su distribución de Linux.

En Debian, el paquete python-magic es sobre este y se usa como dijo toivotuo y no está obsoleto como dijo Simon Zimmermann (en mi humilde opinión).

Me parece otra toma (por el autor original de libmagic).

Lástima que no esté disponible directamente en pypi.

en python 2.6:

mime = subprocess.Popen("/usr/bin/file --mime PATH", shell=True, \
    stdout=subprocess.PIPE).communicate()[0]

Actualización 2017

No es necesario ir a github, está en PyPi con un nombre diferente:

pip3 install --user python-magic
# or:
sudo apt install python3-magic  # Ubuntu distro package

El código también se puede simplificar:

>>> import magic

>>> magic.from_file('/tmp/img_3304.jpg', mime=True)
'image/jpeg'

Enlaces de Python a libmagic

Todas las diferentes respuestas sobre este tema son muy confusas, por lo que espero dar un poco más de claridad con esta descripción general de los diferentes enlaces de libmagic. Anteriormente, mammadori dio una respuesta breve que enumeraba la opción disponible.

libmagic

• Nombre del módulo: magic
• pypi: file-magic
• fuente: https://github.com/file/file/tree/master/python

Al determinar un tipo de archivos MIME, la herramienta de elección simplemente se llama filey se llama a su back-end libmagic. (Consulte la página de inicio del Proyecto ). El proyecto se desarrolla en un repositorio privado cvs, pero hay un espejo git de solo lectura en github .

Ahora esta herramienta, que necesitará si desea utilizar cualquiera de los enlaces de libmagic con python, ya viene con sus propios enlaces de python llamados file-magic. No hay mucha documentación específica para ellos, pero siempre se puede echar un vistazo a la página del manual de la biblioteca C: man libmagic. El uso básico se describe en el archivo Léame :

import magic

detected = magic.detect_from_filename('magic.py')
print 'Detected MIME type: {}'.format(detected.mime_type)
print 'Detected encoding: {}'.format(detected.encoding)
print 'Detected file type name: {}'.format(detected.name)

Además de esto, también puede usar la biblioteca creando un Magicobjeto usando magic.open(flags)como se muestra en el archivo de ejemplo .

Tanto toivotuo como ewr2san usan estos file-magicenlaces incluidos en la fileherramienta. Asumen erróneamente que están usando el python-magicpaquete. Esto parece indicar, que si ambos filey python-magicestán instalados, el módulo de Python magicse refiere a la anterior.

pitón-magia

• Nombre del módulo: magic
• pypi: python-magic
• fuente: https://github.com/ahupp/python-magic

Esta es la biblioteca de la que Simon Zimmermann habla en su respuesta y que también es empleada por Claude COULOMBE y Gringo Suave .

filemagic

• Nombre del módulo: magic
• pypi: filemagic
• fuente: https://github.com/aliles/filemagic

Nota : ¡Este proyecto se actualizó por última vez en 2013!

Debido a que se basa en la misma c-api, esta biblioteca tiene cierta similitud con la file-magicincluida en libmagic. Mammadori solo lo menciona y ninguna otra respuesta lo emplea.

El método de @toivotuo funcionó mejor y más confiable para mí en python3. Mi objetivo era identificar los archivos comprimidos que no tienen una extensión .gz confiable. Instalé python3-magic.

import magic

filename = "./datasets/test"

def file_mime_type(filename):
    m = magic.open(magic.MAGIC_MIME)
    m.load()
    return(m.file(filename))

print(file_mime_type(filename))

para un archivo comprimido devuelve: application / gzip; juego de caracteres = binario

para un archivo txt descomprimido (datos de iostat): text / plain; charset = us-ascii

para un archivo tar: application / x-tar; juego de caracteres = binario

para un archivo bz2: application / x-bzip2; juego de caracteres = binario

y por último, pero no menos importante para mí, un archivo .zip: application / zip; juego de caracteres = binario

Python 3 ref: https://docs.python.org/3.2/library/mimetypes.html

mimetypes.guess_type (url, strictly = True) Adivina el tipo de archivo basado en su nombre de archivo o URL, dado por url. El valor de retorno es una tupla (tipo, codificación) donde el tipo es Ninguno si el tipo no se puede adivinar (sufijo perdido o desconocido) o una cadena de la forma 'tipo / subtipo', utilizable para un encabezado de tipo de contenido MIME.

encoding es None para ninguna codificación o el nombre del programa utilizado para codificar (por ejemplo, comprimir o gzip). La codificación es adecuada para su uso como encabezado de codificación de contenido, no como encabezado de codificación de transferencia de contenido. Las asignaciones son manejadas por tablas. Los sufijos de codificación distinguen entre mayúsculas y minúsculas; los sufijos de tipo se prueban primero con mayúsculas y minúsculas, luego con mayúsculas y minúsculas.

El argumento estricto opcional es una bandera que especifica si la lista de tipos MIME conocidos se limita solo a los tipos oficiales registrados con IANA. Cuando estricto es verdadero (el valor predeterminado), solo se admiten los tipos de IANA; cuando estricto es Falso, también se reconocen algunos tipos MIME adicionales no estándar pero comúnmente utilizados.

import mimetypes
print(mimetypes.guess_type("sample.html"))

No indicó qué servidor web estaba utilizando, pero Apache tiene un pequeño y agradable módulo llamado Mime Magic que utiliza para determinar el tipo de archivo cuando se le indica que lo haga. Lee parte del contenido del archivo e intenta averiguar qué tipo se basa en los caracteres encontrados. Y como Dave Webb mencionó, el módulo MimeTypes en Python funcionará, siempre que una extensión sea útil.

Alternativamente, si está sentado en un cuadro de UNIX, puede usar sys.popen('file -i ' + fileName, mode='r')para tomar el tipo MIME. Windows debería tener un comando equivalente, pero no estoy seguro de qué es.

En Python 3.xy webapp con url al archivo que no podía tener una extensión o una extensión falsa. Debes instalar python-magic, usando

pip3 install python-magic

Para Mac OS X, también debe instalar libmagic usando

brew install libmagic

Fragmento de código

import urllib
import magic
from urllib.request import urlopen

url = "http://...url to the file ..."
request = urllib.request.Request(url)
response = urlopen(request)
mime_type = magic.from_buffer(response.readline())
print(mime_type)

alternativamente, podría poner un tamaño en la lectura

import urllib
import magic
from urllib.request import urlopen

url = "http://...url to the file ..."
request = urllib.request.Request(url)
response = urlopen(request)
mime_type = magic.from_buffer(response.read(128))
print(mime_type)

Intento primero la biblioteca mimetypes. Si no funciona, utilizo la biblioteca python-magic en su lugar.

import mimetypes
def guess_type(filename, buffer=None):
mimetype, encoding = mimetypes.guess_type(filename)
if mimetype is None:
    try:
        import magic
        if buffer:
            mimetype = magic.from_buffer(buffer, mime=True)
        else:
            mimetype = magic.from_file(filename, mime=True)
    except ImportError:
        pass
return mimetype

El módulo mimetypes solo reconoce un tipo de archivo basado en la extensión del archivo. Si intenta recuperar un tipo de archivo sin extensión, los tipos mime no funcionarán.

Me sorprende que nadie lo haya mencionado, pero Pygments es capaz de hacer una conjetura sobre el tipo de mimo de, en particular, los documentos de texto.

Pygments es en realidad una biblioteca de resaltado de sintaxis de Python, pero tiene un método que hará una suposición educada sobre cuál de los 500 tipos de documentos admitidos es su documento. es decir, C ++ vs C # vs Python vs etc.

import inspect

def _test(text: str):
    from pygments.lexers import guess_lexer
    lexer = guess_lexer(text)
    mimetype = lexer.mimetypes[0] if lexer.mimetypes else None
    print(mimetype)

if __name__ == "__main__":
    # Set the text to the actual defintion of _test(...) above
    text = inspect.getsource(_test)
    print('Text:')
    print(text)
    print()
    print('Result:')
    _test(text)

Salida:

Text:
def _test(text: str):
    from pygments.lexers import guess_lexer
    lexer = guess_lexer(text)
    mimetype = lexer.mimetypes[0] if lexer.mimetypes else None
    print(mimetype)


Result:
text/x-python

Ahora, no es perfecto, pero si necesita saber cuál de los 500 formatos de documentos se están utilizando, esto es bastante útil.

He probado muchos ejemplos, pero con Django mutagen funciona muy bien.

Ejemplo de comprobación de si los archivos son mp3

from mutagen.mp3 import MP3, HeaderNotFoundError  

try:
    audio = MP3(file)
except HeaderNotFoundError:
    raise ValidationError('This file should be mp3')

La desventaja es que su capacidad para verificar los tipos de archivos es limitada, pero es una excelente manera si no solo desea verificar el tipo de archivo sino también acceder a información adicional.

Esto ya puede ser antiguo, pero ¿por qué no usar UploadedFile.content_type directamente desde Django? ¿No es lo mismo? ( Https://docs.djangoproject.com/en/1.11/ref/files/uploads/#django.core.files.uploadedfile.UploadedFile.content_type )

Para los datos de tipo de matriz de bytes, puede usar magic.from_buffer (_byte_array, mime = True)

puedes usar el módulo imghdr Python.