""" Python 'utf-16' Codec  Written by Marc-Andre Lemburg (mal@lemburg.com). (c) Copyright CNRI, All Rights Reserved. NO WARRANTY. """import codecs, sys ### Codec APIs encode = codecs.utf_16_encode def decode(input, errors='strict'):    return codecs.utf_16_decode(input, errors, True) class IncrementalEncoder(codecs.IncrementalEncoder):    def __init__(self, errors='strict'):        codecs.IncrementalEncoder.__init__(self, errors)        self.encoder = None     def encode(self, input, final=False):        if self.encoder is None:            result = codecs.utf_16_encode(input, self.errors)[0]            if sys.byteorder == 'little':                self.encoder = codecs.utf_16_le_encode            else:                self.encoder = codecs.utf_16_be_encode            return result        return self.encoder(input, self.errors)[0]     def reset(self):        codecs.IncrementalEncoder.reset(self)        self.encoder = None class IncrementalDecoder(codecs.BufferedIncrementalDecoder):    def __init__(self, errors='strict'):        codecs.BufferedIncrementalDecoder.__init__(self, errors)        self.decoder = None     def _buffer_decode(self, input, errors, final):        if self.decoder is None:            (output, consumed, byteorder) = \                codecs.utf_16_ex_decode(input, errors, 0, final)            if byteorder == -1:                self.decoder = codecs.utf_16_le_decode            elif byteorder == 1:                self.decoder = codecs.utf_16_be_decode            elif consumed >= 2:                raise UnicodeError("UTF-16 stream does not start with BOM")            return (output, consumed)        return self.decoder(input, self.errors, final)     def reset(self):        codecs.BufferedIncrementalDecoder.reset(self)        self.decoder = None class StreamWriter(codecs.StreamWriter):    def __init__(self, stream, errors='strict'):        self.bom_written = False        codecs.StreamWriter.__init__(self, stream, errors)     def encode(self, input, errors='strict'):        self.bom_written = True        result = codecs.utf_16_encode(input, errors)        if sys.byteorder == 'little':            self.encode = codecs.utf_16_le_encode        else:            self.encode = codecs.utf_16_be_encode        return result class StreamReader(codecs.StreamReader):     def reset(self):        codecs.StreamReader.reset(self)        try:            del self.decode        except AttributeError:            pass     def decode(self, input, errors='strict'):        (object, consumed, byteorder) = \            codecs.utf_16_ex_decode(input, errors, 0, False)        if byteorder == -1:            self.decode = codecs.utf_16_le_decode        elif byteorder == 1:            self.decode = codecs.utf_16_be_decode        elif consumed>=2:            raise UnicodeError,"UTF-16 stream does not start with BOM"        return (object, consumed) ### encodings module API def getregentry():    return codecs.CodecInfo(        name='utf-16',        encode=encode,        decode=decode,        incrementalencoder=IncrementalEncoder,        incrementaldecoder=IncrementalDecoder,        streamreader=StreamReader,        streamwriter=StreamWriter,    )