Filtrando alcuni byte in python

Question

sto ottenendo questo errore nel mio programma Python: ValueError: All strings must be XML compatible: Unicode or ASCII, no NULL bytes or control characters

Questa domanda, random text from /dev/random raising an error in lxml: All strings must be XML compatible: Unicode or ASCII, no NULL bytes, spiega il problema.

La soluzione era filtrare determinati byte, ma sono confuso su come procedere per farlo.

Qualsiasi aiuto?

Modifica: scusa se non ho dato abbastanza informazioni sul problema. i dati di stringa provengono da una query API esterna di cui non ho il controllo sul modo in cui i dati sono formattati.

Answer 1

Come la risposta alla domanda legata detto, lo standard XML definisce un carattere valido come:

Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] 

Traducendo che in Python:

def valid_xml_char_ordinal(c): 
    codepoint = ord(c) 
    # conditions ordered by presumed frequency 
    return (
     0x20 <= codepoint <= 0xD7FF or 
     codepoint in (0x9, 0xA, 0xD) or 
     0xE000 <= codepoint <= 0xFFFD or 
     0x10000 <= codepoint <= 0x10FFFF 
     ) 

È possibile quindi utilizzare tale funzione tuttavia è necessario a, ad es

cleaned_string = ''.join(c for c in input_string if valid_xml_char_ordinal(c)) 

Answer 2

si può fare riferimento alla soluzione su questo sito:

https://mailman-mail5.webfaction.com/pipermail/lxml/2011-July/006090.html

Questa soluzione funziona per me. Potrebbe anche essere necessario prendere in considerazione la soluzione di John Machin.

Buona fortuna!

Answer 3

Penso che questo sia duro/eccessivo e sembra dolorosamente lento, ma il mio programma è ancora veloce e dopo aver tentato di capire cosa stava andando male (anche dopo aver tentato di implementare l'implementazione clean_string di John), ho adattato la sua risposta per eliminare ASCII non stampabile utilizzando la seguente (Python 2.7):

from curses import ascii 
def clean(text): 
    return str(''.join(
      ascii.isprint(c) and c or '?' for c in text 
      )) 

non sono sicuro di quello che ho fatto di sbagliato con l'opzione migliore, ma volevo solo andare avanti ...

Answer 4

Un altro approccio è molto più veloce della risposta di cui sopra è di usare espressioni regolari, in questo modo:

re.sub(u'[^\u0020-\uD7FF\u0009\u000A\u000D\uE000-\uFFFD\U00010000-\U0010FFFF]+', '', text) 

Confrontando la risposta di cui sopra, essa risulta essere più di 10 volte più veloce nel mio test:

import timeit 

func_test = """ 
def valid_xml_char_ordinal(c): 
    codepoint = ord(c) 
    # conditions ordered by presumed frequency 
    return (
     0x20 <= codepoint <= 0xD7FF or 
     codepoint in (0x9, 0xA, 0xD) or 
     0xE000 <= codepoint <= 0xFFFD or 
     0x10000 <= codepoint <= 0x10FFFF 
    ); 
''.join(c for c in r.content if valid_xml_char_ordinal(c)) 
""" 

func_setup = """ 
import requests; 
r = requests.get("https://stackoverflow.com/questions/8733233/") 
""" 

regex_test = """re.sub(u'[^\u0020-\uD7FF\u0009\u000A\u000D\uE000-\uFFFD\U00010000-\U0010FFFF]+', '', r.content)""" 
regex_setup = """ 
import requests, re; 
r = requests.get("https://stackoverflow.com/questions/8733233/") 
""" 

func_test = timeit.Timer(func_test, setup=func_setup) 
regex_test = timeit.Timer(regex_test, setup=regex_setup) 

print func_test.timeit(100) 
print regex_test.timeit(100) 

uscita:

> 2.63773989677 
> 0.221401929855 

Quindi, dare un senso a questo, ciò che Sta facendo sta scaricando questa pagina web una volta (la pagina che stai leggendo attualmente), quindi eseguendo la tecnica funzionale e la tecnica regex sul suo contenuto 100X ciascuno.

L'utilizzo del metodo funzionale richiede circa 2.6 secondi.
L'utilizzo del metodo regex richiede circa 0,2 secondi.

---

Aggiornamento: Come identificate nei commenti, la regex in questa risposta precedentemente cancellato alcuni personaggi, che avrebbero dovuto essere ammessi in XML. Questi personaggi includono qualsiasi cosa nello Supplementary Multilingual Plane, che include script antichi come cuneiforme, geroglifici e (stranamente) emoji.

La regex corretta è ora sopra. Un test rapido per questo in futuro sta usando re.DEBUG, che stampa:

In [52]: re.compile(u'[^\u0020-\uD7FF\u0009\u000A\u000D\uE000-\uFFFD\U00010000-\U0010FFFF]+', re.DEBUG) 
max_repeat 1 4294967295 
    in 
    negate None 
    range (32, 55295) 
    literal 9 
    literal 10 
    literal 13 
    range (57344, 65533) 
    range (65536, 1114111) 
Out[52]: re.compile(ur'[^ -\ud7ff\t\n\r\ue000-\ufffd\U00010000-\U0010ffff]+', re.DEBUG) 

mie scuse per l'errore. Posso solo offrire che ho trovato questa risposta altrove e metterla qui. Era l'errore di qualcun altro, ma l'ho propagato. Le mie sincere scuse a chiunque ne sia affetto.

Aggiornamento 2, 2017-12-12: Ho imparato da alcuni utenti OSX che questo codice non funzionerà sulle cosiddette build strette di Python, che a volte apparentemente OSX ha. Puoi verificarlo eseguendo import sys; sys.maxunicode. Se stampa 65535, il codice qui non funzionerà finché non installerai una "versione larga". See more about this here.