def PyCodec_IncrementalEncoder(space, encoding, errors):
w_codec = interp_codecs.lookup_codec(space, rffi.charp2str(encoding))
if errors:
w_errors = space.wrap(rffi.charp2str(errors))
return space.call_method(w_codec, "incrementalencoder", w_errors)
else:
return space.call_method(w_codec, "incrementalencoder")
def encode_object(space, w_object, encoding, errors):
if encoding is None:
# Get the encoder functions as a wrapped object.
# This lookup is cached.
w_encoder = space.sys.get_w_default_encoder()
else:
if errors is None or errors == 'strict':
try:
if encoding == 'ascii':
u = space.unicode_w(w_object)
eh = unicodehelper.rpy_encode_error_handler()
return space.wrap(unicode_encode_ascii(
u, len(u), None, errorhandler=eh))
if encoding == 'utf-8':
u = space.unicode_w(w_object)
eh = unicodehelper.rpy_encode_error_handler()
return space.wrap(unicode_encode_utf_8(
u, len(u), None, errorhandler=eh,
allow_surrogates=True))
except unicodehelper.RUnicodeEncodeError, ue:
raise OperationError(space.w_UnicodeEncodeError,
space.newtuple([
space.wrap(ue.encoding),
space.wrap(ue.object),
space.wrap(ue.start),
space.wrap(ue.end),
space.wrap(ue.reason)]))
from pypy.module._codecs.interp_codecs import lookup_codec
w_encoder = space.getitem(lookup_codec(space, encoding), space.wrap(0))
def encode_object(space, w_object, encoding, errors):
if encoding is None:
# Get the encoder functions as a wrapped object.
# This lookup is cached.
w_encoder = space.sys.get_w_default_encoder()
else:
if errors is None or errors == 'strict':
if encoding == 'ascii':
u = space.unicode_w(w_object)
eh = unicodehelper.encode_error_handler(space)
return space.newbytes(
unicode_encode_ascii(u, len(u), None, errorhandler=eh))
if encoding == 'utf-8':
u = space.unicode_w(w_object)
eh = unicodehelper.encode_error_handler(space)
return space.newbytes(
unicode_encode_utf_8(u,
len(u),
None,
errorhandler=eh,
allow_surrogates=True))
from pypy.module._codecs.interp_codecs import lookup_codec
w_encoder = space.getitem(lookup_codec(space, encoding),
space.newint(0))
if errors is None:
w_errors = space.newtext('strict')
else:
w_errors = space.newtext(errors)
w_restuple = space.call_function(w_encoder, w_object, w_errors)
w_retval = space.getitem(w_restuple, space.newint(0))
if not space.isinstance_w(w_retval, space.w_bytes):
raise oefmt(space.w_TypeError,
"encoder did not return an string object (type '%T')",
w_retval)
return w_retval
def encode_object(space, w_object, encoding, errors):
if encoding is None:
# Get the encoder functions as a wrapped object.
# This lookup is cached.
w_encoder = space.sys.get_w_default_encoder()
else:
if errors is None or errors == 'strict':
try:
if encoding == 'ascii':
u = space.unicode_w(w_object)
eh = unicodehelper.raise_unicode_exception_encode
return space.wrap(
unicode_encode_ascii(u, len(u), None, errorhandler=eh))
if encoding == 'utf-8':
u = space.unicode_w(w_object)
eh = unicodehelper.raise_unicode_exception_encode
return space.wrap(
unicode_encode_utf_8(u,
len(u),
None,
errorhandler=eh,
allow_surrogates=True))
except unicodehelper.RUnicodeEncodeError, ue:
raise OperationError(
space.w_UnicodeEncodeError,
space.newtuple([
space.wrap(ue.encoding),
space.wrap(ue.object),
space.wrap(ue.start),
space.wrap(ue.end),
space.wrap(ue.reason)
]))
from pypy.module._codecs.interp_codecs import lookup_codec
w_encoder = space.getitem(lookup_codec(space, encoding), space.wrap(0))
def encode_object(space, w_object, encoding, errors):
if encoding is None:
# Get the encoder functions as a wrapped object.
# This lookup is cached.
w_encoder = space.sys.get_w_default_encoder()
else:
if errors is None or errors == 'strict':
if encoding == 'ascii':
u = space.unicode_w(w_object)
eh = unicodehelper.encode_error_handler(space)
return space.wrap(unicode_encode_ascii(
u, len(u), None, errorhandler=eh))
if encoding == 'utf-8':
u = space.unicode_w(w_object)
eh = unicodehelper.encode_error_handler(space)
return space.wrap(unicode_encode_utf_8(
u, len(u), None, errorhandler=eh,
allow_surrogates=True))
from pypy.module._codecs.interp_codecs import lookup_codec
w_encoder = space.getitem(lookup_codec(space, encoding), space.wrap(0))
if errors is None:
w_errors = space.wrap('strict')
else:
w_errors = space.wrap(errors)
w_restuple = space.call_function(w_encoder, w_object, w_errors)
w_retval = space.getitem(w_restuple, space.wrap(0))
if not space.isinstance_w(w_retval, space.w_str):
raise oefmt(space.w_TypeError,
"encoder did not return an string object (type '%T')",
w_retval)
return w_retval
def PyCodec_IncrementalEncoder(space, encoding, errors):
w_codec = interp_codecs.lookup_codec(space, rffi.charp2str(encoding))
if errors:
w_errors = space.wrap(rffi.charp2str(errors))
return space.call_method(w_codec, "incrementalencoder", w_errors)
else:
return space.call_method(w_codec, "incrementalencoder")
def encode_object(space, w_object, encoding, errors):
if encoding is None:
# Get the encoder functions as a wrapped object.
# This lookup is cached.
w_encoder = space.sys.get_w_default_encoder()
else:
from pypy.module._codecs.interp_codecs import lookup_codec
w_encoder = space.getitem(lookup_codec(space, encoding), space.wrap(0))
if errors is None:
w_errors = space.wrap('strict')
else:
w_errors = space.wrap(errors)
w_restuple = space.call_function(w_encoder, w_object, w_errors)
w_retval = space.getitem(w_restuple, space.wrap(0))
if not space.is_true(space.isinstance(w_retval, space.w_str)):
raise OperationError(
space.w_TypeError,
space.wrap("encoder did not return an string object (type=%s)" %
space.type(w_retval).getname(space, '?')))
return w_retval
def encode_object(space, w_object, encoding, errors):
if encoding is None:
# Get the encoder functions as a wrapped object.
# This lookup is cached.
w_encoder = space.sys.get_w_default_encoder()
else:
from pypy.module._codecs.interp_codecs import lookup_codec
w_encoder = space.getitem(lookup_codec(space, encoding), space.wrap(0))
if errors is None:
w_errors = space.wrap('strict')
else:
w_errors = space.wrap(errors)
w_restuple = space.call_function(w_encoder, w_object, w_errors)
w_retval = space.getitem(w_restuple, space.wrap(0))
if not space.is_true(space.isinstance(w_retval, space.w_str)):
raise OperationError(
space.w_TypeError,
space.wrap(
"encoder did not return an string object (type=%s)" %
space.type(w_retval).getname(space, '?')))
return w_retval
def _set_encoder_decoder(self, w_encoding, w_errors):
space = self.space
w_codec = interp_codecs.lookup_codec(space, space.text_w(w_encoding))
if not space.is_true(
space.getattr(w_codec, space.newtext('_is_text_encoding'))):
msg = ("%R is not a text encoding; "
"use codecs.open() to handle arbitrary codecs")
raise oefmt(space.w_LookupError, msg, w_encoding)
# build the decoder object
if space.is_true(space.call_method(self.w_buffer, "readable")):
self.w_decoder = space.call_method(w_codec, "incrementaldecoder",
w_errors)
if self.readuniversal:
self.w_decoder = space.call_function(
space.gettypeobject(W_IncrementalNewlineDecoder.typedef),
self.w_decoder, space.newbool(self.readtranslate))
# build the encoder object
if space.is_true(space.call_method(self.w_buffer, "writable")):
self.w_encoder = space.call_method(w_codec, "incrementalencoder",
w_errors)
def encode_object(space, w_object, encoding, errors):
if encoding is None:
# Get the encoder functions as a wrapped object.
# This lookup is cached.
w_encoder = space.sys.get_w_default_encoder()
else:
if errors is None or errors == 'strict':
try:
if encoding == 'ascii':
u = space.unicode_w(w_object)
eh = unicodehelper.rpy_encode_error_handler()
return space.wrapbytes(
unicode_encode_ascii(u, len(u), None, errorhandler=eh))
if encoding == 'utf-8':
u = space.unicode_w(w_object)
eh = unicodehelper.rpy_encode_error_handler()
return space.wrapbytes(
unicode_encode_utf_8(u, len(u), None, errorhandler=eh))
except unicodehelper.RUnicodeEncodeError, ue:
raise wrap_encode_error(space, ue)
from pypy.module._codecs.interp_codecs import lookup_codec
w_encoder = space.getitem(lookup_codec(space, encoding), space.wrap(0))
def descr_init(self,
space,
w_buffer,
encoding=None,
w_errors=None,
w_newline=None,
line_buffering=0):
self.state = STATE_ZERO
self.w_buffer = w_buffer
self.w_encoding = _determine_encoding(space, encoding)
if space.is_none(w_errors):
w_errors = space.newtext("strict")
self.w_errors = w_errors
if space.is_none(w_newline):
newline = None
else:
newline = space.utf8_w(w_newline)
if newline and newline not in ('\n', '\r\n', '\r'):
raise oefmt(space.w_ValueError, "illegal newline value: %R",
w_newline)
self.line_buffering = line_buffering
self.readuniversal = not newline # null or empty
self.readtranslate = newline is None
self.readnl = newline
self.writetranslate = (newline != '')
if not self.readuniversal:
self.writenl = self.readnl
if self.writenl == '\n':
self.writenl = None
elif _WINDOWS:
self.writenl = "\r\n"
else:
self.writenl = None
# build the decoder object
if space.is_true(space.call_method(w_buffer, "readable")):
w_codec = interp_codecs.lookup_codec(space,
space.text_w(self.w_encoding))
self.w_decoder = space.call_method(w_codec, "incrementaldecoder",
w_errors)
if self.readuniversal:
self.w_decoder = space.call_function(
space.gettypeobject(W_IncrementalNewlineDecoder.typedef),
self.w_decoder, space.newbool(self.readtranslate))
# build the encoder object
if space.is_true(space.call_method(w_buffer, "writable")):
w_codec = interp_codecs.lookup_codec(space,
space.text_w(self.w_encoding))
self.w_encoder = space.call_method(w_codec, "incrementalencoder",
w_errors)
self.seekable = space.is_true(space.call_method(w_buffer, "seekable"))
self.telling = self.seekable
self.encoding_start_of_stream = False
if self.seekable and self.w_encoder:
self.encoding_start_of_stream = True
w_cookie = space.call_method(self.w_buffer, "tell")
if not space.eq_w(w_cookie, space.newint(0)):
self.encoding_start_of_stream = False
space.call_method(self.w_encoder, "setstate", space.newint(0))
self.state = STATE_OK
def descr_init(self,
space,
w_buffer,
encoding=None,
w_errors=None,
w_newline=None,
line_buffering=0,
write_through=0):
self.state = STATE_ZERO
self.w_buffer = w_buffer
self.w_encoding = _determine_encoding(space, encoding, w_buffer)
if space.is_none(w_errors):
w_errors = space.newtext("strict")
self.w_errors = w_errors
if space.is_none(w_newline):
newline = None
else:
newline = space.unicode_w(w_newline)
if newline and newline not in (u'\n', u'\r\n', u'\r'):
raise oefmt(space.w_ValueError, "illegal newline value: %R",
w_newline)
self.line_buffering = line_buffering
self.write_through = write_through
self.readuniversal = not newline # null or empty
self.readtranslate = newline is None
self.readnl = newline
self.writetranslate = (newline != u'')
if not self.readuniversal:
self.writenl = self.readnl
if self.writenl == u'\n':
self.writenl = None
elif _WINDOWS:
self.writenl = u"\r\n"
else:
self.writenl = None
w_codec = interp_codecs.lookup_codec(space,
space.text_w(self.w_encoding))
if not space.is_true(
space.getattr(w_codec, space.newtext('_is_text_encoding'))):
msg = ("%R is not a text encoding; "
"use codecs.open() to handle arbitrary codecs")
raise oefmt(space.w_LookupError, msg, self.w_encoding)
# build the decoder object
if space.is_true(space.call_method(w_buffer, "readable")):
self.w_decoder = space.call_method(w_codec, "incrementaldecoder",
w_errors)
if self.readuniversal:
self.w_decoder = space.call_function(
space.gettypeobject(W_IncrementalNewlineDecoder.typedef),
self.w_decoder, space.newbool(self.readtranslate))
# build the encoder object
if space.is_true(space.call_method(w_buffer, "writable")):
self.w_encoder = space.call_method(w_codec, "incrementalencoder",
w_errors)
self.seekable = space.is_true(space.call_method(w_buffer, "seekable"))
self.telling = self.seekable
self.has_read1 = space.findattr(w_buffer, space.newtext("read1"))
self.encoding_start_of_stream = False
if self.seekable and self.w_encoder:
self.encoding_start_of_stream = True
w_cookie = space.call_method(self.w_buffer, "tell")
if not space.eq_w(w_cookie, space.newint(0)):
self.encoding_start_of_stream = False
space.call_method(self.w_encoder, "setstate", space.newint(0))
self.state = STATE_OK
def descr_init(self, space, w_buffer, encoding=None,
w_errors=None, w_newline=None, line_buffering=0):
self.state = STATE_ZERO
self.w_buffer = w_buffer
self.w_encoding = _determine_encoding(space, encoding)
if space.is_none(w_errors):
w_errors = space.wrap("strict")
self.w_errors = w_errors
if space.is_none(w_newline):
newline = None
else:
newline = space.unicode_w(w_newline)
if newline and newline not in (u'\n', u'\r\n', u'\r'):
r = space.str_w(space.repr(w_newline))
raise oefmt(space.w_ValueError,
"illegal newline value: %s", r)
self.line_buffering = line_buffering
self.readuniversal = not newline # null or empty
self.readtranslate = newline is None
self.readnl = newline
self.writetranslate = (newline != u'')
if not self.readuniversal:
self.writenl = self.readnl
if self.writenl == u'\n':
self.writenl = None
elif _WINDOWS:
self.writenl = u"\r\n"
else:
self.writenl = None
# build the decoder object
if space.is_true(space.call_method(w_buffer, "readable")):
w_codec = interp_codecs.lookup_codec(space,
space.str_w(self.w_encoding))
self.w_decoder = space.call_method(w_codec,
"incrementaldecoder", w_errors)
if self.readuniversal:
self.w_decoder = space.call_function(
space.gettypeobject(W_IncrementalNewlineDecoder.typedef),
self.w_decoder, space.wrap(self.readtranslate))
# build the encoder object
if space.is_true(space.call_method(w_buffer, "writable")):
w_codec = interp_codecs.lookup_codec(space,
space.str_w(self.w_encoding))
self.w_encoder = space.call_method(w_codec,
"incrementalencoder", w_errors)
self.seekable = space.is_true(space.call_method(w_buffer, "seekable"))
self.telling = self.seekable
self.encoding_start_of_stream = False
if self.seekable and self.w_encoder:
self.encoding_start_of_stream = True
w_cookie = space.call_method(self.w_buffer, "tell")
if not space.eq_w(w_cookie, space.wrap(0)):
self.encoding_start_of_stream = False
space.call_method(self.w_encoder, "setstate", space.wrap(0))
self.state = STATE_OK
def PyCodec_Decoder(space, encoding):
w_codec = interp_codecs.lookup_codec(space, rffi.charp2str(encoding))
return space.getitem(w_codec, space.newint(1))
