Come posso rilevare se un file è binario (non di testo) in Python?

Come posso sapere se un file è binario (non di testo) in Python?

Sto cercando in un ampio set di file in Python e continuo a ricevere corrispondenze nei file binari. Questo rende l'output incredibilmente disordinato.

So che potrei usare grep -I, ma sto facendo di più con i dati di quanto consente grep.

In passato, avrei cercato solo caratteri più grandi di 0x7f, ma utf8e simili , lo avrei reso impossibile sui sistemi moderni. Idealmente la soluzione sarebbe veloce, ma qualsiasi soluzione andrà bene.

Puoi anche usare il modulo mimetypes :

import mimetypes
...
mime = mimetypes.guess_type(file)

È abbastanza facile compilare un elenco di tipi MIME binari. Ad esempio, Apache distribuisce con un file mime.types che potresti analizzare in un insieme di elenchi, binari e testo e quindi controllare se il mime è nel tuo elenco di testo o binario.

Ancora un altro metodo basato sul comportamento del file (1) :

>>> textchars = bytearray({7,8,9,10,12,13,27} | set(range(0x20, 0x100)) - {0x7f})
>>> is_binary_string = lambda bytes: bool(bytes.translate(None, textchars))

Esempio:

>>> is_binary_string(open('/usr/bin/python', 'rb').read(1024))
True
>>> is_binary_string(open('/usr/bin/dh_python3', 'rb').read(1024))
False

Se stai usando python3 con utf-8 è semplice, apri il file in modalità testo e interrompi l'elaborazione se ottieni un file UnicodeDecodeError. Python3 userà unicode quando gestirà i file in modalità testo (e bytearray in modalità binaria) - se la tua codifica non può decodificare file arbitrari è molto probabile che otterrai UnicodeDecodeError.

Esempio:

try:
    with open(filename, "r") as f:
        for l in f:
             process_line(l)
except UnicodeDecodeError:
    pass # Fond non-text data

Se aiuta, molti molti tipi binari iniziano con numeri magici. Ecco un elenco di firme di file.

Prova questo:

def is_binary(filename):
    """Return true if the given filename is binary.
    @raise EnvironmentError: if the file does not exist or cannot be accessed.
    @attention: found @ http://bytes.com/topic/python/answers/21222-determine-file-type-binary-text on 6/08/2010
    @author: Trent Mick <TrentM@ActiveState.com>
    @author: Jorge Orpinel <jorge@orpinel.com>"""
    fin = open(filename, 'rb')
    try:
        CHUNKSIZE = 1024
        while 1:
            chunk = fin.read(CHUNKSIZE)
            if '\0' in chunk: # found null byte
                return True
            if len(chunk) < CHUNKSIZE:
                break # done
    # A-wooo! Mira, python no necesita el "except:". Achis... Que listo es.
    finally:
        fin.close()

    return False

Ecco un suggerimento che utilizza il comando file Unix :

import re
import subprocess

def istext(path):
    return (re.search(r':.* text',
                      subprocess.Popen(["file", '-L', path], 
                                       stdout=subprocess.PIPE).stdout.read())
            is not None)

Utilizzo di esempio:

>>> istext ('/ etc / motd') 
Vero
>>> istext ('/ vmlinuz') 
falso
>>> open ('/ tmp / japanese'). read ()
'\ XE3 \ x81 \ x93 \ XE3 \ x82 \ x8c \ XE3 \ x81 \ XAF \ XE3 \ x80 \ x81 \ XE3 \ x81 \ XBF \ XE3 \ x81 \ X9a \ XE3 \ x81 \ x8c \ XE3 \ x82 \ x81 \ xe5 \ XBA \ xa7 \ XE3 \ x81 \ XAE \ XE6 \ x99 \ x82 \ XE4 \ xbb \ XA3 \ XE3 \ x81 \ XAE \ xe5 \ XB9 \ x95 \ xe9 \ x96 \ x8b \ XE3 \ x81 \ x91 \ XE3 \ x80 \ x82 \ n'
>>> istext ('/ tmp / japanese') # funziona su UTF-8
Vero

Ha gli svantaggi di non essere portabile su Windows (a meno che tu non abbia qualcosa di simile al filecomando lì) e di dover generare un processo esterno per ogni file, che potrebbe non essere appetibile.

Usa la libreria binaryornot ( GitHub ).

È molto semplice e si basa sul codice trovato in questa domanda su stackoverflow.

Puoi effettivamente scrivere questo in 2 righe di codice, tuttavia questo pacchetto ti evita di dover scrivere e testare a fondo quelle 2 righe di codice con tutti i tipi di strani tipi di file, multipiattaforma.

Di solito devi indovinare.

Puoi considerare le estensioni come un indizio, se i file le hanno.

Puoi anche riconoscere i formati binari conosciuti e ignorarli.

Altrimenti guarda quale proporzione di byte ASCII non stampabili hai e fai un'ipotesi da quello.

Puoi anche provare a decodificare da UTF-8 e vedere se questo produce un output ragionevole.

Una soluzione più breve, con un avviso UTF-16:

def is_binary(filename):
    """ 
    Return true if the given filename appears to be binary.
    File is considered to be binary if it contains a NULL byte.
    FIXME: This approach incorrectly reports UTF-16 as binary.
    """
    with open(filename, 'rb') as f:
        for block in f:
            if b'\0' in block:
                return True
    return False

Possiamo usare lo stesso python per verificare se un file è binario, perché fallisce se proviamo ad aprire il file binario in modalità testo

def is_binary(file_name):
    try:
        with open(file_name, 'tr') as check_file:  # try open file in text mode
            check_file.read()
            return False
    except:  # if fail then file is non-text (binary)
        return True

Se non sei su Windows, puoi usare Python Magic per determinare il tipo di file. Quindi puoi controllare se si tratta di un tipo di testo / mime.

Ecco una funzione che prima controlla se il file inizia con una BOM e in caso contrario cerca uno zero byte entro gli 8192 byte iniziali:

import codecs


#: BOMs to indicate that a file is a text file even if it contains zero bytes.
_TEXT_BOMS = (
    codecs.BOM_UTF16_BE,
    codecs.BOM_UTF16_LE,
    codecs.BOM_UTF32_BE,
    codecs.BOM_UTF32_LE,
    codecs.BOM_UTF8,
)


def is_binary_file(source_path):
    with open(source_path, 'rb') as source_file:
        initial_bytes = source_file.read(8192)
    return not any(initial_bytes.startswith(bom) for bom in _TEXT_BOMS) \
           and b'\0' in initial_bytes

Tecnicamente il controllo per la distinta componenti UTF-8 non è necessario perché non dovrebbe contenere zero byte per tutti gli scopi pratici. Ma poiché è una codifica molto comune, è più veloce controllare la BOM all'inizio invece di scansionare tutti gli 8192 byte per 0.

Prova a usare il python-magic attualmente mantenuto che non è lo stesso modulo nella risposta di @Kami Kisiel. Questo supporta tutte le piattaforme, incluso Windows, tuttavia avrai bisogno dellibmagic file binari. Questo è spiegato nel README.

A differenza del modulo mimetypes , non usa l'estensione del file e invece ispeziona il contenuto del file.

>>> import magic
>>> magic.from_file("testdata/test.pdf", mime=True)
'application/pdf'
>>> magic.from_file("testdata/test.pdf")
'PDF document, version 1.2'
>>> magic.from_buffer(open("testdata/test.pdf").read(1024))
'PDF document, version 1.2'

Sono venuto qui cercando esattamente la stessa cosa: una soluzione completa fornita dalla libreria standard per rilevare binario o testo. Dopo aver esaminato le opzioni suggerite dalle persone, il comando file nix sembra essere la scelta migliore (sto sviluppando solo per linux boxen). Alcuni altri hanno pubblicato soluzioni utilizzando file ma a mio parere sono inutilmente complicate, quindi ecco cosa ho trovato:

def test_file_isbinary(filename):
    cmd = shlex.split("file -b -e soft '{}'".format(filename))
    if subprocess.check_output(cmd)[:4] in {'ASCI', 'UTF-'}:
        return False
    return True

Dovrebbe essere ovvio, ma il codice che chiama questa funzione dovrebbe assicurarsi di poter leggere un file prima di testarlo, altrimenti questo rileverà erroneamente il file come binario.

Immagino che la soluzione migliore sia usare la funzione guess_type. Contiene un elenco con diversi tipi di MIME e puoi anche includere i tuoi tipi. Ecco lo script che ho fatto per risolvere il mio problema:

from mimetypes import guess_type
from mimetypes import add_type

def __init__(self):
        self.__addMimeTypes()

def __addMimeTypes(self):
        add_type("text/plain",".properties")

def __listDir(self,path):
        try:
            return listdir(path)
        except IOError:
            print ("The directory {0} could not be accessed".format(path))

def getTextFiles(self, path):
        asciiFiles = []
        for files in self.__listDir(path):
            if guess_type(files)[0].split("/")[0] == "text":
                asciiFiles.append(files)
        try:
            return asciiFiles
        except NameError:
            print ("No text files in directory: {0}".format(path))
        finally:
            del asciiFiles

È all'interno di una Classe, come puoi vedere in base alla struttura del codice. Ma puoi praticamente cambiare le cose che vuoi implementarlo all'interno della tua applicazione. È abbastanza semplice da usare. Il metodo getTextFiles restituisce un oggetto elenco con tutti i file di testo che risiedono nella directory passata nella variabile di percorso.

su * NIX:

Se hai accesso al filecomando shell, shlex può aiutarti a rendere più utilizzabile il modulo sottoprocesso:

from os.path import realpath
from subprocess import check_output
from shlex import split

filepath = realpath('rel/or/abs/path/to/file')
assert 'ascii' in check_output(split('file {}'.format(filepth).lower()))

Oppure, puoi anche inserirlo in un ciclo for per ottenere l'output per tutti i file nella directory corrente usando:

import os
for afile in [x for x in os.listdir('.') if os.path.isfile(x)]:
    assert 'ascii' in check_output(split('file {}'.format(afile).lower()))

o per tutte le sottocartelle:

for curdir, filelist in zip(os.walk('.')[0], os.walk('.')[2]):
     for afile in filelist:
         assert 'ascii' in check_output(split('file {}'.format(afile).lower()))

La maggior parte dei programmi considera il file binario (che è qualsiasi file non "orientato alla riga") se contiene un carattere NULL .

Ecco la versione perl di pp_fttext()( pp_sys.c) implementata in Python:

import sys
PY3 = sys.version_info[0] == 3

# A function that takes an integer in the 8-bit range and returns
# a single-character byte object in py3 / a single-character string
# in py2.
#
int2byte = (lambda x: bytes((x,))) if PY3 else chr

_text_characters = (
        b''.join(int2byte(i) for i in range(32, 127)) +
        b'\n\r\t\f\b')

def istextfile(fileobj, blocksize=512):
    """ Uses heuristics to guess whether the given file is text or binary,
        by reading a single block of bytes from the file.
        If more than 30% of the chars in the block are non-text, or there
        are NUL ('\x00') bytes in the block, assume this is a binary file.
    """
    block = fileobj.read(blocksize)
    if b'\x00' in block:
        # Files with null bytes are binary
        return False
    elif not block:
        # An empty file is considered a valid text file
        return True

    # Use translate's 'deletechars' argument to efficiently remove all
    # occurrences of _text_characters from the block
    nontext = block.translate(None, _text_characters)
    return float(len(nontext)) / len(block) <= 0.30

Nota anche che questo codice è stato scritto per funzionare sia su Python 2 che su Python 3 senza modifiche.

Fonte: "indovina se il file è di testo o binario" di Perl implementato in Python

sei in unix? in tal caso, prova:

isBinary = os.system("file -b" + name + " | grep text > /dev/null")

I valori restituiti dalla shell sono invertiti (0 va bene, quindi se trova "testo" restituirà uno 0, e in Python questa è un'espressione False).

Il modo più semplice è controllare se il file è composto da caratteri NULL ( \x00) utilizzando l' inoperatore, ad esempio:

b'\x00' in open("foo.bar", 'rb').read()

Vedi sotto l'esempio completo:

#!/usr/bin/env python3
import argparse
if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('file', nargs=1)
    args = parser.parse_args()
    with open(args.file[0], 'rb') as f:
        if b'\x00' in f.read():
            print('The file is binary!')
        else:
            print('The file is not binary!')

Utilizzo del campione:

$ ./is_binary.py /etc/hosts
The file is not binary!
$ ./is_binary.py `which which`
The file is binary!

from binaryornot.check import is_binary
is_binary('filename')

Documentazione