Supponiamo che tu voglia salvare un mucchio di file da qualche parte, ad esempio in BLOB. Supponiamo che tu voglia trasferire questi file tramite una pagina Web e fare in modo che il client apra automaticamente l'applicazione / il visualizzatore corretti.

Presupposto: il browser rileva quale applicazione / visualizzatore utilizzare dall'intestazione mime-type (content-type?) Nella risposta HTTP.

Sulla base di tale presupposto, oltre ai byte del file, si desidera salvare anche il tipo MIME.

Come troveresti il ​​tipo MIME di un file? Sono attualmente su un Mac, ma questo dovrebbe funzionare anche su Windows.

Il browser aggiunge queste informazioni quando pubblica il file nella pagina Web?

Esiste una libreria Python ordinata per trovare queste informazioni? Un servizio Web o (ancora meglio) un database scaricabile?

Il metodo magico-pitone suggerito da toivotuo è obsoleto. L' attuale trunk di Python-magic è su Github e basato sul readme lì, che trova il tipo MIME, viene fatto in questo modo.

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

Il modulo mimetypes nella libreria standard determinerà / indovinerà il tipo MIME da un'estensione di file.

Se gli utenti caricano file, il post HTTP conterrà il tipo MIME del file accanto ai dati. Ad esempio, Django rende disponibili questi dati come attributo dell'oggetto UploadedFile .

Un modo più affidabile rispetto all'utilizzo della libreria mimetypes sarebbe utilizzare il pacchetto python-magic.

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

Ciò equivarrebbe ad usare il file (1).

Su Django si potrebbe anche assicurarsi che il tipo MIME corrisponda a quello di UploadedFile.content_type.

Questo sembra essere molto semplice

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

Per favore, riferisci Old Post

Aggiornamento - Secondo il commento di @Garrets, in python 3 è più semplice:

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

Ci sono 3 diverse librerie che avvolgono libmagic.

2 di questi sono disponibili su pypi (quindi l'installazione pip funzionerà):

• filemagic
• python-magic

E un altro, simile a Python-Magic, è disponibile direttamente nelle ultime fonti libmagic, ed è quello che probabilmente hai nella tua distribuzione Linux.

In Debian il pacchetto python-magic parla di questo ed è usato come detto toivotuo e non è obsoleto come diceva Simon Zimmermann (IMHO).

Mi sembra un'altra interpretazione (dall'autore originale di libmagic).

Peccato che non sia disponibile direttamente su Pypi.

in Python 2.6:

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

Aggiornamento 2017

Non c'è bisogno di andare su github, è su PyPi con un nome diverso:

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

Anche il codice può essere semplificato:

>>> import magic

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

Python si lega a libmagic

Tutte le diverse risposte su questo argomento sono molto confuse, quindi spero di dare un po 'più di chiarezza con questa panoramica delle diverse associazioni di libmagic. Precedentemente mammadori ha dato una breve risposta elencando l'opzione disponibile.

libmagic

• nome del modulo: magic
• pypi: file-magic
• fonte: https://github.com/file/file/tree/master/python

Quando si determina un tipo mime di file, lo strumento preferito viene semplicemente chiamato filee viene chiamato il suo back-end libmagic. (Vedi la home page del Progetto .) Il progetto è sviluppato in un repository cvs privato, ma c'è un mirror git di sola lettura su github .

Ora questo strumento, che ti servirà se vuoi usare una qualsiasi delle associazioni libmagiche con Python, viene già fornito con le sue stesse associazioni Python chiamate file-magic. Non c'è molto di documentazione dedicato per loro, ma si può sempre avere uno sguardo alla pagina man del c-library: man libmagic. L'utilizzo di base è descritto nel file Leggimi :

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)

Oltre a questo, puoi anche usare la libreria creando un Magicoggetto usando magic.open(flags)come mostrato nel file di esempio .

Sia toivotuo e l'uso ewr2san questi file-magicattacchi inclusi nel filestrumento. Presumono erroneamente che stanno usando il python-magicpacchetto. Questo sembra indicare che se entrambi filee python-magicsono installati, il modulo python si magicriferisce a quello precedente.

python-magic

• nome del modulo: magic
• pypi: python-magic
• fonte: https://github.com/ahupp/python-magic

Questa è la biblioteca di cui Simon Zimmermann parla nella sua risposta e che è anche impiegato da Claude COULOMBE e da Gringo Suave .

filemagic

• nome del modulo: magic
• pypi: filemagic
• fonte: https://github.com/aliles/filemagic

Nota : questo progetto è stato aggiornato l'ultima volta nel 2013!

Essendo basato sullo stesso c-api, questa libreria ha alcune somiglianze con file-magicincluso in libmagic. Viene menzionato solo da mammadori e nessun'altra risposta lo utilizza.

Il metodo di @toivotuo ha funzionato meglio e in modo più affidabile per me con Python3. Il mio obiettivo era quello di identificare i file compressi con gzip che non hanno un'estensione affidabile .gz. Ho installato 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))

per un file gzipped restituisce: application / gzip; charset = binario

per un file txt decompresso (dati iostat): text / plain; charset = us-ascii

per un file tar: application / x-tar; charset = binario

per un file bz2: application / x-bzip2; charset = binario

e ultimo ma non meno importante per me un file .zip: application / zip; charset = binario

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

mimetypes.guess_type (url, strict = True) Indovina il tipo di un file in base al suo nome file o URL, fornito da url. Il valore restituito è una tupla (tipo, codifica) in cui il tipo è Nessuno se il tipo non può essere indovinato (suffisso mancante o sconosciuto) o una stringa della forma "tipo / sottotipo", utilizzabile per un'intestazione del tipo di contenuto MIME.

la codifica è Nessuna per nessuna codifica o il nome del programma utilizzato per codificare (ad esempio compress o gzip). La codifica è adatta per l'uso come intestazione Content-Encoding, non come intestazione Content-Transfer-Encoding. I mapping sono guidati da tabella. I suffissi di codifica fanno distinzione tra maiuscole e minuscole; i suffissi di tipo vengono prima provati in modo sensibile a maiuscole e minuscole, poi senza maiuscole e minuscole.

L'argomento rigoroso facoltativo è una bandiera che specifica se l'elenco di tipi MIME noti è limitato ai soli tipi ufficiali registrati con IANA. Quando rigoroso è True (impostazione predefinita), sono supportati solo i tipi IANA; quando rigoroso è False, vengono riconosciuti anche alcuni tipi MIME aggiuntivi non standard ma comunemente utilizzati.

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

Non hai indicato quale server web stavi utilizzando, ma Apache ha un bel modulo chiamato Mime Magic che usa per determinare il tipo di file quando ti viene detto di farlo. Legge alcuni dei contenuti del file e cerca di capire quale tipo si basa sui caratteri trovati. E come Dave Webb ha menzionato il modulo MimeTypes sotto python funzionerà, a condizione che un'estensione sia utile.

In alternativa, se sei seduto su una scatola UNIX puoi usare sys.popen('file -i ' + fileName, mode='r')per afferrare il tipo MIME. Windows dovrebbe avere un comando equivalente, ma non sono sicuro di cosa sia.

In Python 3.xe webapp con URL al file che non può avere un'estensione o un'estensione falsa. Dovresti installare python-magic, usando

pip3 install python-magic

Per Mac OS X, dovresti anche installare libmagic usando

brew install libmagic

Snippet di codice

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)

in alternativa puoi inserire una dimensione nella lettura

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)

Provo prima la libreria dei mimetipi. Se non funziona, utilizzo invece libary python-magic.

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

Il modulo mimetypes riconosce solo un tipo di file basato sull'estensione del file. Se proverai a recuperare un tipo di file di un file senza estensione, i mimetipi non funzioneranno.

Sono sorpreso che nessuno lo abbia menzionato tranne Pygments è in grado di fare un'ipotesi colta sul tipo mime, in particolare, dei documenti di testo.

Pygments è in realtà una libreria di evidenziazione della sintassi di Python ma ha un metodo che farà un'ipotesi mirata su quale dei 500 tipi di documenti supportati sia il tuo documento. cioè c ++ vs C # vs Python vs ecc

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)

Produzione:

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

Ora, non è perfetto, ma se devi essere in grado di dire quale dei 500 formati di documento vengono utilizzati, questo è davvero utile.

Ho provato molti esempi ma con Django il mutageno suona bene.

Esempio di verifica se i file sono mp3

from mutagen.mp3 import MP3, HeaderNotFoundError  

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

Il rovescio della medaglia è che la tua capacità di controllare i tipi di file è limitata, ma è un ottimo modo se vuoi non solo controllare il tipo di file ma anche accedere a informazioni aggiuntive.

Potrebbe essere già vecchio, ma perché non utilizzare UploadedFile.content_type direttamente da Django? Non è lo stesso? ( Https://docs.djangoproject.com/en/1.11/ref/files/uploads/#django.core.files.uploadedfile.UploadedFile.content_type )

Per i dati di tipo array di byte è possibile utilizzare magic.from_buffer (_byte_array, mime = True)

puoi usare il modulo imghdr Python.