Python codecs.register方法代码示例

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def decode(input, fallback_encoding, errors='replace'):
    """
    Decode a single string.

    :param input: A byte string
    :param fallback_encoding:
        An :class:`Encoding` object or a label string.
        The encoding to use if :obj:`input` does note have a BOM.
    :param errors: Type of error handling. See :func:`codecs.register`.
    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
    :return:
        A ``(output, encoding)`` tuple of an Unicode string
        and an :obj:`Encoding`.

    """
    # Fail early if `encoding` is an invalid label.
    fallback_encoding = _get_encoding(fallback_encoding)
    bom_encoding, input = _detect_bom(input)
    encoding = bom_encoding or fallback_encoding
    return encoding.codec_info.decode(input, errors)[0], encoding 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def test_all(self):
        api = (
            "encode", "decode",
            "register", "CodecInfo", "Codec", "IncrementalEncoder",
            "IncrementalDecoder", "StreamReader", "StreamWriter", "lookup",
            "getencoder", "getdecoder", "getincrementalencoder",
            "getincrementaldecoder", "getreader", "getwriter",
            "register_error", "lookup_error",
            "strict_errors", "replace_errors", "ignore_errors",
            "xmlcharrefreplace_errors", "backslashreplace_errors",
            "open", "EncodedFile",
            "iterencode", "iterdecode",
            "BOM", "BOM_BE", "BOM_LE",
            "BOM_UTF8", "BOM_UTF16", "BOM_UTF16_BE", "BOM_UTF16_LE",
            "BOM_UTF32", "BOM_UTF32_BE", "BOM_UTF32_LE",
            "BOM32_BE", "BOM32_LE", "BOM64_BE", "BOM64_LE",  # Undocumented
            "StreamReaderWriter", "StreamRecoder",
        )
        self.assertEqual(sorted(api), sorted(codecs.__all__))
        for api in codecs.__all__:
            getattr(codecs, api) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def test_register(self):
        '''
        TODO: test that functions passed in are actually used
        '''
        #sanity check - basically just ensure that functions can be registered
        def garbage_func0(): pass
        def garbage_func1(param1): pass
        codecs.register(garbage_func0)
        codecs.register(garbage_func1)
        
        #negative cases
        self.assertRaises(TypeError, codecs.register)
        self.assertRaises(TypeError, codecs.register, None)
        self.assertRaises(TypeError, codecs.register, ())
        self.assertRaises(TypeError, codecs.register, [])
        self.assertRaises(TypeError, codecs.register, 1)
        self.assertRaises(TypeError, codecs.register, "abc")
        self.assertRaises(TypeError, codecs.register, 3.14) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def test_codecs_lookup(self):
        l = []
        def my_func(encoding, cache = l):
            l.append(encoding)
        
        codecs.register(my_func)
        allchars = ''.join([chr(i) for i in xrange(1, 256)])
        try:
            codecs.lookup(allchars)
            self.assertUnreachable()
        except LookupError:
            pass
            
        lowerchars = allchars.lower().replace(' ', '-')
        for i in xrange(1, 255):
            if l[0][i] != lowerchars[i]:
                self.assertTrue(False, 'bad chars at index %d: %r %r' % (i, l[0][i], lowerchars[i]))
                
        self.assertRaises(TypeError, codecs.lookup, '\0')
        self.assertRaises(TypeError, codecs.lookup, 'abc\0')
        self.assertEqual(len(l), 1) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def teletex_search_function(name):
    """
    Search function for teletex codec that is passed to codecs.register()
    """

    if name != 'teletex':
        return None

    return codecs.CodecInfo(
        name='teletex',
        encode=TeletexCodec().encode,
        decode=TeletexCodec().decode,
        incrementalencoder=TeletexIncrementalEncoder,
        incrementaldecoder=TeletexIncrementalDecoder,
        streamreader=TeletexStreamReader,
        streamwriter=TeletexStreamWriter,
    ) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def test_all(self):
        api = (
            "encode", "decode",
            "register", "CodecInfo", "Codec", "IncrementalEncoder",
            "IncrementalDecoder", "StreamReader", "StreamWriter", "lookup",
            "getencoder", "getdecoder", "getincrementalencoder",
            "getincrementaldecoder", "getreader", "getwriter",
            "register_error", "lookup_error",
            "strict_errors", "replace_errors", "ignore_errors",
            "xmlcharrefreplace_errors", "backslashreplace_errors",
            "namereplace_errors",
            "open", "EncodedFile",
            "iterencode", "iterdecode",
            "BOM", "BOM_BE", "BOM_LE",
            "BOM_UTF8", "BOM_UTF16", "BOM_UTF16_BE", "BOM_UTF16_LE",
            "BOM_UTF32", "BOM_UTF32_BE", "BOM_UTF32_LE",
            "BOM32_BE", "BOM32_LE", "BOM64_BE", "BOM64_LE",  # Undocumented
            "StreamReaderWriter", "StreamRecoder",
        )
        self.assertCountEqual(api, codecs.__all__)
        for api in codecs.__all__:
            getattr(codecs, api) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def writelines(self, lines):
        self._checkClosed()
        for line in lines:
            self.write(line)

#fix me brython
#io.IOBase.register(IOBase) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def write(self, b):
        """Write the given buffer to the IO stream.

        Returns the number of bytes written, which may be less than len(b).
        """
        self._unsupported("write")

#io.RawIOBase.register(RawIOBase)
#fix me brython
#from _io import FileIO
#RawIOBase.register(FileIO) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def detach(self):
        """
        Separate the underlying raw stream from the buffer and return it.

        After the raw stream has been detached, the buffer is in an unusable
        state.
        """
        self._unsupported("detach")

#fix me brython
#io.BufferedIOBase.register(BufferedIOBase) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def errors(self):
        """Error setting of the decoder or encoder.

        Subclasses should override."""
        return None

#fix me brython
#io.TextIOBase.register(TextIOBase) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def encode(input, encoding=UTF8, errors='strict'):
    """
    Encode a single string.

    :param input: An Unicode string.
    :param encoding: An :class:`Encoding` object or a label string.
    :param errors: Type of error handling. See :func:`codecs.register`.
    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
    :return: A byte string.

    """
    return _get_encoding(encoding).codec_info.encode(input, errors)[0] 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def iter_decode(input, fallback_encoding, errors='replace'):
    """
    "Pull"-based decoder.

    :param input:
        An iterable of byte strings.

        The input is first consumed just enough to determine the encoding
        based on the precense of a BOM,
        then consumed on demand when the return value is.
    :param fallback_encoding:
        An :class:`Encoding` object or a label string.
        The encoding to use if :obj:`input` does note have a BOM.
    :param errors: Type of error handling. See :func:`codecs.register`.
    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
    :returns:
        An ``(output, encoding)`` tuple.
        :obj:`output` is an iterable of Unicode strings,
        :obj:`encoding` is the :obj:`Encoding` that is being used.

    """

    decoder = IncrementalDecoder(fallback_encoding, errors)
    generator = _iter_decode_generator(input, decoder)
    encoding = next(generator)
    return generator, encoding 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def iter_encode(input, encoding=UTF8, errors='strict'):
    """
    “Pull”-based encoder.

    :param input: An iterable of Unicode strings.
    :param encoding: An :class:`Encoding` object or a label string.
    :param errors: Type of error handling. See :func:`codecs.register`.
    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
    :returns: An iterable of byte strings.

    """
    # Fail early if `encoding` is an invalid label.
    encode = IncrementalEncoder(encoding, errors).encode
    return _iter_encode_generator(input, encode) 

# 需要导入模块: import codecs [as 别名]
# 或者: from codecs import register [as 别名]
def add_cp65001_codec():
    if PY2:
        try:
            codecs.lookup('cp65001')
        except LookupError:
            codecs.register(
                lambda name: name == 'cp65001' and codecs.lookup('utf-8') or None)
    return