def test_destructor(self):
space = self.space
class W_Level1(W_Root):
def __init__(self, space1):
assert space1 is space
self.register_finalizer(space)
def _finalize_(self):
space.call_method(w_seen, 'append', space.wrap(1))
W_Level1.typedef = typedef.TypeDef(
'level1', __new__=typedef.generic_new_descr(W_Level1))
#
w_seen = space.newlist([])
W_Level1(space)
gc.collect()
gc.collect()
assert space.str_w(space.repr(w_seen)) == "[]" # not called yet
ec = space.getexecutioncontext()
self.space.user_del_action.perform(ec, None)
assert space.unwrap(w_seen) == [1] # called by user_del_action
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef)],
"""(level1):
class A3(level1):
pass
A3()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [1]
#
w_seen = space.newlist([])
self.space.appexec(
[self.space.gettypeobject(W_Level1.typedef), w_seen],
"""(level1, seen):
class A4(level1):
def __del__(self):
seen.append(4)
A4()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [4, 1] # user __del__, and _finalize_
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef)],
"""(level2):
class A5(level2):
pass
A5()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [1] # _finalize_ only
def test_destructor(self):
space = self.space
class W_Level1(W_Root):
def __init__(self, space1):
assert space1 is space
self.register_finalizer(space)
def _finalize_(self):
space.call_method(w_seen, 'append', space.wrap(1))
W_Level1.typedef = typedef.TypeDef(
'level1',
__new__ = typedef.generic_new_descr(W_Level1))
#
w_seen = space.newlist([])
W_Level1(space)
gc.collect(); gc.collect()
assert space.str_w(space.repr(w_seen)) == "[]" # not called yet
ec = space.getexecutioncontext()
self.space.user_del_action.perform(ec, None)
assert space.unwrap(w_seen) == [1] # called by user_del_action
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef)],
"""(level1):
class A3(level1):
pass
A3()
""")
gc.collect(); gc.collect()
assert space.unwrap(w_seen) == [1]
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef),
w_seen],
"""(level1, seen):
class A4(level1):
def __del__(self):
seen.append(4)
A4()
""")
gc.collect(); gc.collect()
assert space.unwrap(w_seen) == [4, 1] # user __del__, and _finalize_
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef)],
"""(level2):
class A5(level2):
pass
A5()
""")
gc.collect(); gc.collect()
assert space.unwrap(w_seen) == [1] # _finalize_ only
try:
w_type = space.getattr(w_obj_or_type, space.newtext('__class__'))
except OperationError as e:
if not e.match(space, space.w_AttributeError):
raise
w_type = w_objtype
if space.issubtype_w(w_type, w_starttype):
return w_type
raise oefmt(space.w_TypeError,
"super(type, obj): obj must be an instance or subtype of type")
W_Super.typedef = TypeDef(
'super',
__new__ = generic_new_descr(W_Super),
__init__ = interp2app(W_Super.descr_init),
__repr__ = interp2app(W_Super.descr_repr),
__thisclass__ = interp_attrproperty_w("w_starttype", W_Super),
__self__ = interp_attrproperty_w("w_self", W_Super),
__self_class__ = interp_attrproperty_w("w_objtype", W_Super),
__getattribute__ = interp2app(W_Super.getattribute),
__get__ = interp2app(W_Super.get),
__doc__ = """\
super(type) -> unbound super object
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
"%T.__setstate__ argument should be 3-tuple, got %T",
self, w_state)
w_content, w_pos, w_dict = space.unpackiterable(w_state, 3)
self.truncate(0)
self.write_w(space, w_content)
pos = space.int_w(w_pos)
if pos < 0:
raise OperationError(space.w_ValueError, space.wrap(
"position value cannot be negative"))
self.seek(pos)
if not space.is_w(w_dict, space.w_None):
space.call_method(self.getdict(space), "update", w_dict)
W_BytesIO.typedef = TypeDef(
'_io.BytesIO', W_BufferedIOBase.typedef,
__new__ = generic_new_descr(W_BytesIO),
__init__ = interp2app(W_BytesIO.descr_init),
read = interp2app(W_BytesIO.read_w),
read1 = interp2app(W_BytesIO.read1_w),
readline = interp2app(W_BytesIO.readline_w),
readinto = interp2app(W_BytesIO.readinto_w),
write = interp2app(W_BytesIO.write_w),
truncate = interp2app(W_BytesIO.truncate_w),
getvalue = interp2app(W_BytesIO.getvalue_w),
seek = interp2app(W_BytesIO.seek_w),
tell = interp2app(W_BytesIO.tell_w),
readable = interp2app(W_BytesIO.readable_w),
writable = interp2app(W_BytesIO.writable_w),
seekable = interp2app(W_BytesIO.seekable_w),
close = interp2app(W_BytesIO.close_w),
def readinto_w(self, space, w_buffer):
rwbuffer = space.rwbuffer_w(w_buffer)
length = rwbuffer.getlength()
w_data = space.call_method(self, "read", space.wrap(length))
if not space.isinstance_w(w_data, space.w_str):
raise OperationError(space.w_TypeError, space.wrap(
"read() should return bytes"))
data = space.str_w(w_data)
rwbuffer.setslice(0, data)
return space.wrap(len(data))
W_BufferedIOBase.typedef = TypeDef(
'_io._BufferedIOBase', W_IOBase.typedef,
__new__ = generic_new_descr(W_BufferedIOBase),
read = interp2app(W_BufferedIOBase.read_w),
read1 = interp2app(W_BufferedIOBase.read1_w),
write = interp2app(W_BufferedIOBase.write_w),
detach = interp2app(W_BufferedIOBase.detach_w),
readinto = interp2app(W_BufferedIOBase.readinto_w),
)
class RawBuffer(RWBuffer):
def __init__(self, buf, start, length):
self.buf = buf
self.start = start
self.length = length
def getlength(self):
return self.length
if not e.match(space, space.w_StopIteration):
raise
break # done
while True:
try:
space.call_method(self, "write", w_line)
except OperationError, e:
if trap_eintr(space, e):
continue
raise
else:
break
W_IOBase.typedef = TypeDef(
'_io._IOBase',
__new__ = generic_new_descr(W_IOBase),
__enter__ = interp2app(W_IOBase.enter_w),
__exit__ = interp2app(W_IOBase.exit_w),
__iter__ = interp2app(W_IOBase.iter_w),
next = interp2app(W_IOBase.next_w),
close = interp2app(W_IOBase.close_w),
flush = interp2app(W_IOBase.flush_w),
seek = interp2app(W_IOBase.seek_w),
tell = interp2app(W_IOBase.tell_w),
truncate = interp2app(W_IOBase.truncate_w),
fileno = interp2app(W_IOBase.fileno_w),
isatty = interp2app(W_IOBase.isatty_w),
readable = interp2app(W_IOBase.readable_w),
writable = interp2app(W_IOBase.writable_w),
seekable = interp2app(W_IOBase.seekable_w),
# Directory should not exist
try:
st = os.stat(path)
except OSError:
pass
else:
if stat.S_ISDIR(st.st_mode):
raise OperationError(space.w_ImportError, space.wrap(
"existing directory"))
def find_module_w(self, space, __args__):
return space.wrap(None)
W_NullImporter.typedef = TypeDef(
'imp.NullImporter',
__new__=generic_new_descr(W_NullImporter),
__init__=interp2app(W_NullImporter.descr_init),
find_module=interp2app(W_NullImporter.find_module_w),
)
class FindInfo:
def __init__(self, modtype, filename, stream,
suffix="", filemode="", w_loader=None):
self.modtype = modtype
self.filename = filename
self.stream = stream
self.suffix = suffix
self.filemode = filemode
self.w_loader = w_loader
@staticmethod
try:
st = os.stat(path)
except OSError:
pass
else:
if stat.S_ISDIR(st.st_mode):
raise OperationError(space.w_ImportError,
space.wrap("existing directory"))
def find_module_w(self, space, __args__):
return space.wrap(None)
W_NullImporter.typedef = TypeDef(
'imp.NullImporter',
__new__=generic_new_descr(W_NullImporter),
__init__=interp2app(W_NullImporter.descr_init),
find_module=interp2app(W_NullImporter.find_module_w),
)
class FindInfo:
def __init__(self,
modtype,
filename,
stream,
suffix="",
filemode="",
w_loader=None):
self.modtype = modtype
self.filename = filename
def closed_get_w(self, space):
return space.wrap(self.buf is None)
def line_buffering_get_w(self, space):
return space.w_False
def newlines_get_w(self, space):
if self.w_decoder is None:
return space.w_None
return space.getattr(self.w_decoder, space.wrap("newlines"))
W_StringIO.typedef = TypeDef(
'StringIO', W_TextIOBase.typedef,
__module__ = "_io",
__new__ = generic_new_descr(W_StringIO),
__init__ = interp2app(W_StringIO.descr_init),
__getstate__ = interp2app(W_StringIO.descr_getstate),
__setstate__ = interp2app(W_StringIO.descr_setstate),
write = interp2app(W_StringIO.write_w),
read = interp2app(W_StringIO.read_w),
readline = interp2app(W_StringIO.readline_w),
seek = interp2app(W_StringIO.seek_w),
truncate = interp2app(W_StringIO.truncate_w),
getvalue = interp2app(W_StringIO.getvalue_w),
readable = interp2app(W_StringIO.readable_w),
writable = interp2app(W_StringIO.writable_w),
seekable = interp2app(W_StringIO.seekable_w),
close = interp2app(W_StringIO.close_w),
closed = GetSetProperty(W_StringIO.closed_get_w),
line_buffering = GetSetProperty(W_StringIO.line_buffering_get_w),
raise
break # done
while True:
try:
space.call_method(self, "write", w_line)
except OperationError, e:
if trap_eintr(space, e):
continue
raise
else:
break
W_IOBase.typedef = TypeDef(
'_io._IOBase',
__new__=generic_new_descr(W_IOBase),
__enter__=interp2app(W_IOBase.enter_w),
__exit__=interp2app(W_IOBase.exit_w),
__iter__=interp2app(W_IOBase.iter_w),
next=interp2app(W_IOBase.next_w),
close=interp2app(W_IOBase.close_w),
flush=interp2app(W_IOBase.flush_w),
seek=interp2app(W_IOBase.seek_w),
tell=interp2app(W_IOBase.tell_w),
truncate=interp2app(W_IOBase.truncate_w),
fileno=interp2app(W_IOBase.fileno_w),
isatty=interp2app(W_IOBase.isatty_w),
readable=interp2app(W_IOBase.readable_w),
writable=interp2app(W_IOBase.writable_w),
seekable=interp2app(W_IOBase.seekable_w),
_checkReadable=interp2app(check_readable_w),
"override __buffer__ in a subclass")
return space.call_method(self, '__buffer__', w_flags)
def readbuf_w(self, space):
mv = space.call_method(self, '__buffer__', space.newint(0))
return mv.buffer_w(space, 0).as_readbuf()
W_Bufferable.typedef = TypeDef(
"Bufferable",
None,
None,
'read-write',
__doc__="""a helper class for a app-level class (like _ctypes.Array)
that want to support tp_as_buffer.bf_getbuffer via a __buffer__ method""",
__new__=generic_new_descr(W_Bufferable),
__buffer__=interp2app(W_Bufferable.descr_buffer),
)
@unwrap_spec(itemsize=int, format='text')
def newmemoryview(space,
w_obj,
itemsize,
format,
w_shape=None,
w_strides=None):
'''
newmemoryview(buf, itemsize, format, shape=None, strides=None)
'''
if not space.isinstance_w(w_obj, space.w_memoryview):
def test_destructor(self):
space = self.space
class W_Level1(W_Root):
def __init__(self, space1):
assert space1 is space
def __del__(self):
space.call_method(w_seen, 'append', space.wrap(1))
class W_Level2(W_Root):
def __init__(self, space1):
assert space1 is space
def __del__(self):
self.enqueue_for_destruction(space, W_Level2.destructormeth,
'FOO ')
def destructormeth(self):
space.call_method(w_seen, 'append', space.wrap(2))
W_Level1.typedef = typedef.TypeDef(
'level1', __new__=typedef.generic_new_descr(W_Level1))
W_Level2.typedef = typedef.TypeDef(
'level2', __new__=typedef.generic_new_descr(W_Level2))
#
w_seen = space.newlist([])
W_Level1(space)
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [1]
#
w_seen = space.newlist([])
W_Level2(space)
gc.collect()
gc.collect()
assert space.str_w(space.repr(w_seen)) == "[]" # not called yet
ec = space.getexecutioncontext()
self.space.user_del_action.perform(ec, None)
assert space.unwrap(w_seen) == [2]
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef)],
"""(level1):
class A3(level1):
pass
A3()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [1]
#
w_seen = space.newlist([])
self.space.appexec(
[self.space.gettypeobject(W_Level1.typedef), w_seen],
"""(level1, seen):
class A4(level1):
def __del__(self):
seen.append(4)
A4()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [4, 1]
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level2.typedef)],
"""(level2):
class A5(level2):
pass
A5()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [2]
#
w_seen = space.newlist([])
self.space.appexec(
[self.space.gettypeobject(W_Level2.typedef), w_seen],
"""(level2, seen):
class A6(level2):
def __del__(self):
seen.append(6)
A6()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [6, 2]
recvfrom(buflen[, flags]) -- receive data and sender\'s address
recvfrom_into(buffer[, nbytes, [, flags])
-- receive data and sender\'s address (into a buffer)
sendall(data[, flags]) -- send all data
send(data[, flags]) -- send data, may not send all of it
sendto(data[, flags], addr) -- send data to a given address
setblocking(0 | 1) -- set or clear the blocking I/O flag
setsockopt(level, optname, value[, optlen]) -- set socket options
settimeout(None | float) -- set or clear the timeout
shutdown(how) -- shut down traffic in one or both directions
if_nameindex() -- return all network interface indices and names
if_nametoindex(name) -- return the corresponding interface index
if_indextoname(index) -- return the corresponding interface name
[*] not available on all platforms!""",
__new__=generic_new_descr(W_Socket),
__init__=interp2app(W_Socket.descr_init),
__repr__=interp2app(W_Socket.descr_repr),
type=GetSetProperty(W_Socket.get_type_w),
proto=GetSetProperty(W_Socket.get_proto_w),
family=GetSetProperty(W_Socket.get_family_w),
**socketmethods)
@unwrap_spec(fd=int)
def close(space, fd):
from rpython.rlib import _rsocket_rffi as _c
res = _c.socketclose(fd)
if res:
converted_error(space, rsocket.last_error())
def descr_get_flags(self, space):
return space.wrap(self.event.c_flags)
def descr_get_fflags(self, space):
return space.wrap(self.event.c_fflags)
def descr_get_data(self, space):
return space.wrap(self.event.c_data)
def descr_get_udata(self, space):
return space.wrap(rffi.cast(rffi.UINTPTR_T, self.event.c_udata))
W_Kevent.typedef = TypeDef(
"select.kevent",
__new__=generic_new_descr(W_Kevent),
__init__=interp2app(W_Kevent.descr__init__),
__eq__=interp2app(W_Kevent.descr__eq__),
__ne__=interp2app(W_Kevent.descr__ne__),
__le__=interp2app(W_Kevent.descr__le__),
__lt__=interp2app(W_Kevent.descr__lt__),
__ge__=interp2app(W_Kevent.descr__ge__),
__gt__=interp2app(W_Kevent.descr__gt__),
ident=GetSetProperty(W_Kevent.descr_get_ident),
filter=GetSetProperty(W_Kevent.descr_get_filter),
flags=GetSetProperty(W_Kevent.descr_get_flags),
fflags=GetSetProperty(W_Kevent.descr_get_fflags),
data=GetSetProperty(W_Kevent.descr_get_data),
udata=GetSetProperty(W_Kevent.descr_get_udata),
)
W_Kevent.typedef.acceptable_as_base_class = False
return space.call_function(w_type, w_getter, w_setter, w_deleter, w_doc)
W_Property.typedef = TypeDef(
"property",
__doc__="""property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for deleting, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "I am the 'x' property.")""",
__new__=generic_new_descr(W_Property),
__init__=interp2app(W_Property.init),
__get__=interp2app(W_Property.get),
__set__=interp2app(W_Property.set),
__delete__=interp2app(W_Property.delete),
fdel=interp_attrproperty_w("w_fdel", W_Property),
fget=interp_attrproperty_w("w_fget", W_Property),
fset=interp_attrproperty_w("w_fset", W_Property),
getter=interp2app(W_Property.getter),
setter=interp2app(W_Property.setter),
deleter=interp2app(W_Property.deleter),
)
# This allows there to be a __doc__ of the property type and a __doc__
# descriptor for the instances.
W_Property.typedef.rawdict["__doc__"] = interp_attrproperty_w("w_doc", W_Property)
def readinto_w(self, space, w_buffer):
rwbuffer = space.rwbuffer_w(w_buffer)
length = rwbuffer.getlength()
w_data = space.call_method(self, "read", space.wrap(length))
if not space.isinstance_w(w_data, space.w_str):
raise OperationError(space.w_TypeError, space.wrap(
"read() should return bytes"))
data = space.str_w(w_data)
rwbuffer.setslice(0, data)
return space.wrap(len(data))
W_BufferedIOBase.typedef = TypeDef(
'_io._BufferedIOBase', W_IOBase.typedef,
__new__ = generic_new_descr(W_BufferedIOBase),
read = interp2app(W_BufferedIOBase.read_w),
read1 = interp2app(W_BufferedIOBase.read1_w),
write = interp2app(W_BufferedIOBase.write_w),
detach = interp2app(W_BufferedIOBase.detach_w),
readinto = interp2app(W_BufferedIOBase.readinto_w),
)
class RawBuffer(RWBuffer):
def __init__(self, buf, start, length):
self.buf = buf
self.start = start
self.length = length
def getlength(self):
return self.length
def descr_get_flags(self, space):
return space.wrap(self.flags)
def descr_get_fflags(self, space):
return space.wrap(self.fflags)
def descr_get_data(self, space):
return space.wrap(self.data)
def descr_get_udata(self, space):
return space.wrap(rffi.cast(rffi.UINTPTR_T, self.udata))
W_Kevent.typedef = TypeDef("select.kevent",
__new__ = generic_new_descr(W_Kevent),
__init__ = interp2app(W_Kevent.descr__init__),
__eq__ = interp2app(W_Kevent.descr__eq__),
__ne__ = interp2app(W_Kevent.descr__ne__),
__le__ = interp2app(W_Kevent.descr__le__),
__lt__ = interp2app(W_Kevent.descr__lt__),
__ge__ = interp2app(W_Kevent.descr__ge__),
__gt__ = interp2app(W_Kevent.descr__gt__),
ident = GetSetProperty(W_Kevent.descr_get_ident),
filter = GetSetProperty(W_Kevent.descr_get_filter),
flags = GetSetProperty(W_Kevent.descr_get_flags),
fflags = GetSetProperty(W_Kevent.descr_get_fflags),
data = GetSetProperty(W_Kevent.descr_get_data),
udata = GetSetProperty(W_Kevent.descr_get_udata),
)
rffi.ptradd(dataptr, offset * 2)),
wlen - offset, n, rffi.cast(rwin32.LPVOID, 0))
if not res:
err = rwin32.GetLastError_saved()
raise OperationError(space.w_WindowsError,
space.newint(err))
nwrote = intmask(n[0])
offset += nwrote
return space.newint(offset - 1)
def get_blksize(self, space):
return space.newint(self.blksize)
W_WinConsoleIO.typedef = TypeDef(
'_io.WinConsoleIO',
W_RawIOBase.typedef,
__new__=generic_new_descr(W_WinConsoleIO),
__init__=interp2app(W_WinConsoleIO.descr_init),
__repr__=interp2app(W_WinConsoleIO.repr_w),
readable=interp2app(W_WinConsoleIO.readable_w),
writable=interp2app(W_WinConsoleIO.writable_w),
isatty=interp2app(W_WinConsoleIO.isatty_w),
read=interp2app(W_WinConsoleIO.read_w),
readall=interp2app(W_WinConsoleIO.readall_w),
readinto=interp2app(W_WinConsoleIO.readinto_w),
fileno=interp2app(W_WinConsoleIO.fileno_w),
write=interp2app(W_WinConsoleIO.write_w),
_blksize=GetSetProperty(W_WinConsoleIO.get_blksize),
)
return space.newtuple([w_buffer, space.newint(flag)])
def setstate_w(self, space, w_state):
w_buffer, w_flag = space.unpackiterable(w_state, 2)
flag = space.r_longlong_w(w_flag)
self.pendingcr = bool(flag & 1)
flag >>= 1
if self.w_decoder and not space.is_w(self.w_decoder, space.w_None):
w_state = space.newtuple([w_buffer, space.newint(flag)])
space.call_method(self.w_decoder, "setstate", w_state)
W_IncrementalNewlineDecoder.typedef = TypeDef(
'_io.IncrementalNewlineDecoder',
__new__=generic_new_descr(W_IncrementalNewlineDecoder),
__init__=interp2app(W_IncrementalNewlineDecoder.descr_init),
decode=interp2app(W_IncrementalNewlineDecoder.decode_w),
reset=interp2app(W_IncrementalNewlineDecoder.reset_w),
getstate=interp2app(W_IncrementalNewlineDecoder.getstate_w),
setstate=interp2app(W_IncrementalNewlineDecoder.setstate_w),
newlines=GetSetProperty(W_IncrementalNewlineDecoder.newlines_get_w),
)
class W_TextIOBase(W_IOBase):
w_encoding = None
def __init__(self, space):
W_IOBase.__init__(self, space)
class W_BlockingIOError(W_IOError):
def __init__(self, space):
W_IOError.__init__(self, space)
self.written = 0
@unwrap_spec(written=int)
def descr_init(self, space, w_errno, w_strerror, written=0):
W_IOError.descr_init(self, space, [w_errno, w_strerror])
self.written = written
W_BlockingIOError.typedef = TypeDef(
'BlockingIOError', W_IOError.typedef,
__doc__ = ("Exception raised when I/O would block on a non-blocking "
"I/O stream"),
__new__ = generic_new_descr(W_BlockingIOError),
__init__ = interp2app(W_BlockingIOError.descr_init),
characters_written = interp_attrproperty('written', W_BlockingIOError),
)
DEFAULT_BUFFER_SIZE = 8 * 1024
@unwrap_spec(mode=str, buffering=int,
encoding="str_or_None", errors="str_or_None",
newline="str_or_None", closefd=bool)
def open(space, w_file, mode="r", buffering=-1, encoding=None, errors=None,
newline=None, closefd=True):
from pypy.module._io.interp_bufferedio import (W_BufferedRandom,
W_BufferedWriter, W_BufferedReader)
if not (space.isinstance_w(w_file, space.w_basestring) or
def test_destructor(self):
space = self.space
class W_Level1(W_Root):
def __init__(self, space1):
assert space1 is space
def __del__(self):
space.call_method(w_seen, 'append', space.wrap(1))
class W_Level2(W_Root):
def __init__(self, space1):
assert space1 is space
def __del__(self):
self.enqueue_for_destruction(space, W_Level2.destructormeth,
'FOO ')
def destructormeth(self):
space.call_method(w_seen, 'append', space.wrap(2))
W_Level1.typedef = typedef.TypeDef(
'level1',
__new__ = typedef.generic_new_descr(W_Level1))
W_Level2.typedef = typedef.TypeDef(
'level2',
__new__ = typedef.generic_new_descr(W_Level2))
#
w_seen = space.newlist([])
W_Level1(space)
gc.collect(); gc.collect()
assert space.unwrap(w_seen) == [1]
#
w_seen = space.newlist([])
W_Level2(space)
gc.collect(); gc.collect()
assert space.str_w(space.repr(w_seen)) == "[]" # not called yet
ec = space.getexecutioncontext()
self.space.user_del_action.perform(ec, None)
assert space.unwrap(w_seen) == [2]
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef)],
"""(level1):
class A3(level1):
pass
A3()
""")
gc.collect(); gc.collect()
assert space.unwrap(w_seen) == [1]
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef),
w_seen],
"""(level1, seen):
class A4(level1):
def __del__(self):
seen.append(4)
A4()
""")
gc.collect(); gc.collect()
assert space.unwrap(w_seen) == [4, 1]
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level2.typedef)],
"""(level2):
class A5(level2):
pass
A5()
""")
gc.collect(); gc.collect()
assert space.unwrap(w_seen) == [2]
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level2.typedef),
w_seen],
"""(level2, seen):
class A6(level2):
def __del__(self):
seen.append(6)
A6()
""")
gc.collect(); gc.collect()
assert space.unwrap(w_seen) == [6, 2]
def closed_get_w(self, space):
return space.newbool(self.buf is None)
def line_buffering_get_w(self, space):
return space.w_False
def newlines_get_w(self, space):
if self.w_decoder is None:
return space.w_None
return space.getattr(self.w_decoder, space.newtext("newlines"))
W_StringIO.typedef = TypeDef(
'_io.StringIO',
W_TextIOBase.typedef,
__new__=generic_new_descr(W_StringIO),
__init__=interp2app(W_StringIO.descr_init),
__getstate__=interp2app(W_StringIO.descr_getstate),
__setstate__=interp2app(W_StringIO.descr_setstate),
write=interp2app(W_StringIO.write_w),
read=interp2app(W_StringIO.read_w),
readline=interp2app(W_StringIO.readline_w),
seek=interp2app(W_StringIO.seek_w),
truncate=interp2app(W_StringIO.truncate_w),
getvalue=interp2app(W_StringIO.getvalue_w),
readable=interp2app(W_StringIO.readable_w),
writable=interp2app(W_StringIO.writable_w),
seekable=interp2app(W_StringIO.seekable_w),
close=interp2app(W_StringIO.close_w),
closed=GetSetProperty(W_StringIO.closed_get_w),
line_buffering=GetSetProperty(W_StringIO.line_buffering_get_w),
class W_BlockingIOError(W_IOError):
def __init__(self, space):
W_IOError.__init__(self, space)
self.written = 0
@unwrap_spec(written=int)
def descr_init(self, space, w_errno, w_strerror, written=0):
W_IOError.descr_init(self, space, [w_errno, w_strerror])
self.written = written
W_BlockingIOError.typedef = TypeDef(
'BlockingIOError', W_IOError.typedef,
__doc__ = ("Exception raised when I/O would block on a non-blocking "
"I/O stream"),
__new__ = generic_new_descr(W_BlockingIOError),
__init__ = interp2app(W_BlockingIOError.descr_init),
characters_written = interp_attrproperty('written', W_BlockingIOError,
wrapfn="newint"),
)
DEFAULT_BUFFER_SIZE = 8 * 1024
@unwrap_spec(mode='text', buffering=int,
encoding="text_or_none", errors="text_or_none",
newline="text_or_none", closefd=bool)
def open(space, w_file, mode="r", buffering=-1, encoding=None, errors=None,
newline=None, closefd=True):
from pypy.module._io.interp_bufferedio import (W_BufferedRandom,
W_BufferedWriter, W_BufferedReader)
w_content, w_pos, w_dict = space.unpackiterable(w_state, 3)
self.truncate(0)
self.write_w(space, w_content)
pos = space.int_w(w_pos)
if pos < 0:
raise oefmt(space.w_ValueError,
"position value cannot be negative")
self.seek(pos)
if not space.is_w(w_dict, space.w_None):
space.call_method(self.getdict(space), "update", w_dict)
W_BytesIO.typedef = TypeDef(
'_io.BytesIO',
W_BufferedIOBase.typedef,
__new__=generic_new_descr(W_BytesIO),
__init__=interp2app(W_BytesIO.descr_init),
read=interp2app(W_BytesIO.read_w),
read1=interp2app(W_BytesIO.read1_w),
readline=interp2app(W_BytesIO.readline_w),
readinto=interp2app(W_BytesIO.readinto_w),
write=interp2app(W_BytesIO.write_w),
truncate=interp2app(W_BytesIO.truncate_w),
getvalue=interp2app(W_BytesIO.getvalue_w),
seek=interp2app(W_BytesIO.seek_w),
tell=interp2app(W_BytesIO.tell_w),
readable=interp2app(W_BytesIO.readable_w),
writable=interp2app(W_BytesIO.writable_w),
seekable=interp2app(W_BytesIO.seekable_w),
close=interp2app(W_BytesIO.close_w),
closed=GetSetProperty(W_BytesIO.closed_get_w),
flag |= 1
return space.newtuple([w_buffer, space.wrap(flag)])
def setstate_w(self, space, w_state):
w_buffer, w_flag = space.unpackiterable(w_state, 2)
flag = space.r_longlong_w(w_flag)
self.pendingcr = bool(flag & 1)
flag >>= 1
if self.w_decoder and not space.is_w(self.w_decoder, space.w_None):
w_state = space.newtuple([w_buffer, space.wrap(flag)])
space.call_method(self.w_decoder, "setstate", w_state)
W_IncrementalNewlineDecoder.typedef = TypeDef(
'_io.IncrementalNewlineDecoder',
__new__ = generic_new_descr(W_IncrementalNewlineDecoder),
__init__ = interp2app(W_IncrementalNewlineDecoder.descr_init),
decode = interp2app(W_IncrementalNewlineDecoder.decode_w),
reset = interp2app(W_IncrementalNewlineDecoder.reset_w),
getstate = interp2app(W_IncrementalNewlineDecoder.getstate_w),
setstate = interp2app(W_IncrementalNewlineDecoder.setstate_w),
newlines = GetSetProperty(W_IncrementalNewlineDecoder.newlines_get_w),
)
class W_TextIOBase(W_IOBase):
w_encoding = None
def __init__(self, space):
W_IOBase.__init__(self, space)
