W_ComplexObject.typedef = TypeDef(
"complex",
__doc__="""complex(real[, imag]) -> complex number
Create a complex number from a real part and an optional imaginary part.
This is equivalent to (real + imag*1j) where imag defaults to 0.""",
__new__=interp2app(W_ComplexObject.descr__new__),
__getnewargs__=interp2app(W_ComplexObject.descr___getnewargs__),
real=complexwprop('realval'),
imag=complexwprop('imagval'),
__repr__=interp2app(W_ComplexObject.descr_repr),
__str__=interp2app(W_ComplexObject.descr_str),
__hash__=interp2app(W_ComplexObject.descr_hash),
__coerce__=interp2app(W_ComplexObject.descr_coerce),
__format__=interp2app(W_ComplexObject.descr_format),
__nonzero__=interp2app(W_ComplexObject.descr_nonzero),
__int__=interp2app(W_ComplexObject.int),
__float__=interp2app(W_ComplexObject.descr_float),
__neg__=interp2app(W_ComplexObject.descr_neg),
__pos__=interp2app(W_ComplexObject.descr_pos),
__abs__=interp2app(W_ComplexObject.descr_abs),
__eq__=interp2app(W_ComplexObject.descr_eq),
__ne__=interp2app(W_ComplexObject.descr_ne),
__lt__=interp2app(W_ComplexObject._fail_cmp),
__le__=interp2app(W_ComplexObject._fail_cmp),
__gt__=interp2app(W_ComplexObject._fail_cmp),
__ge__=interp2app(W_ComplexObject._fail_cmp),
__add__=interp2app(W_ComplexObject.descr_add),
__radd__=interp2app(W_ComplexObject.descr_radd),
__sub__=interp2app(W_ComplexObject.descr_sub),
__rsub__=interp2app(W_ComplexObject.descr_rsub),
__mul__=interp2app(W_ComplexObject.descr_mul),
__rmul__=interp2app(W_ComplexObject.descr_rmul),
__div__=interp2app(W_ComplexObject.descr_truediv),
__rdiv__=interp2app(W_ComplexObject.descr_rtruediv),
__truediv__=interp2app(W_ComplexObject.descr_truediv),
__rtruediv__=interp2app(W_ComplexObject.descr_rtruediv),
__floordiv__=interp2app(W_ComplexObject.descr_floordiv),
__rfloordiv__=interp2app(W_ComplexObject.descr_rfloordiv),
__mod__=interp2app(W_ComplexObject.descr_mod),
__rmod__=interp2app(W_ComplexObject.descr_rmod),
__divmod__=interp2app(W_ComplexObject.descr_divmod),
__rdivmod__=interp2app(W_ComplexObject.descr_rdivmod),
__pow__=interp2app(W_ComplexObject.descr_pow),
__rpow__=interp2app(W_ComplexObject.descr_rpow),
conjugate=interp2app(W_ComplexObject.descr_conjugate),
)
W_BytesObject.typedef = TypeDef(
"str", basestring_typedef, None, "read",
__new__ = interp2app(W_BytesObject.descr_new),
__doc__ = """str(object='') -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
""",
__repr__ = interpindirect2app(W_AbstractBytesObject.descr_repr),
__str__ = interpindirect2app(W_AbstractBytesObject.descr_str),
__hash__ = interpindirect2app(W_AbstractBytesObject.descr_hash),
__eq__ = interpindirect2app(W_AbstractBytesObject.descr_eq),
__ne__ = interpindirect2app(W_AbstractBytesObject.descr_ne),
__lt__ = interpindirect2app(W_AbstractBytesObject.descr_lt),
__le__ = interpindirect2app(W_AbstractBytesObject.descr_le),
__gt__ = interpindirect2app(W_AbstractBytesObject.descr_gt),
__ge__ = interpindirect2app(W_AbstractBytesObject.descr_ge),
__len__ = interpindirect2app(W_AbstractBytesObject.descr_len),
__contains__ = interpindirect2app(W_AbstractBytesObject.descr_contains),
__add__ = interpindirect2app(W_AbstractBytesObject.descr_add),
__mul__ = interpindirect2app(W_AbstractBytesObject.descr_mul),
__rmul__ = interpindirect2app(W_AbstractBytesObject.descr_rmul),
__getitem__ = interpindirect2app(W_AbstractBytesObject.descr_getitem),
__getslice__ = interpindirect2app(W_AbstractBytesObject.descr_getslice),
capitalize = interpindirect2app(W_AbstractBytesObject.descr_capitalize),
center = interpindirect2app(W_AbstractBytesObject.descr_center),
count = interpindirect2app(W_AbstractBytesObject.descr_count),
decode = interpindirect2app(W_AbstractBytesObject.descr_decode),
encode = interpindirect2app(W_AbstractBytesObject.descr_encode),
expandtabs = interpindirect2app(W_AbstractBytesObject.descr_expandtabs),
find = interpindirect2app(W_AbstractBytesObject.descr_find),
rfind = interpindirect2app(W_AbstractBytesObject.descr_rfind),
index = interpindirect2app(W_AbstractBytesObject.descr_index),
rindex = interpindirect2app(W_AbstractBytesObject.descr_rindex),
isalnum = interpindirect2app(W_AbstractBytesObject.descr_isalnum),
isalpha = interpindirect2app(W_AbstractBytesObject.descr_isalpha),
isdigit = interpindirect2app(W_AbstractBytesObject.descr_isdigit),
islower = interpindirect2app(W_AbstractBytesObject.descr_islower),
isspace = interpindirect2app(W_AbstractBytesObject.descr_isspace),
istitle = interpindirect2app(W_AbstractBytesObject.descr_istitle),
isupper = interpindirect2app(W_AbstractBytesObject.descr_isupper),
join = interpindirect2app(W_AbstractBytesObject.descr_join),
ljust = interpindirect2app(W_AbstractBytesObject.descr_ljust),
rjust = interpindirect2app(W_AbstractBytesObject.descr_rjust),
lower = interpindirect2app(W_AbstractBytesObject.descr_lower),
partition = interpindirect2app(W_AbstractBytesObject.descr_partition),
rpartition = interpindirect2app(W_AbstractBytesObject.descr_rpartition),
replace = interpindirect2app(W_AbstractBytesObject.descr_replace),
split = interpindirect2app(W_AbstractBytesObject.descr_split),
rsplit = interpindirect2app(W_AbstractBytesObject.descr_rsplit),
splitlines = interpindirect2app(W_AbstractBytesObject.descr_splitlines),
startswith = interpindirect2app(W_AbstractBytesObject.descr_startswith),
endswith = interpindirect2app(W_AbstractBytesObject.descr_endswith),
strip = interpindirect2app(W_AbstractBytesObject.descr_strip),
lstrip = interpindirect2app(W_AbstractBytesObject.descr_lstrip),
rstrip = interpindirect2app(W_AbstractBytesObject.descr_rstrip),
swapcase = interpindirect2app(W_AbstractBytesObject.descr_swapcase),
title = interpindirect2app(W_AbstractBytesObject.descr_title),
translate = interpindirect2app(W_AbstractBytesObject.descr_translate),
upper = interpindirect2app(W_AbstractBytesObject.descr_upper),
zfill = interpindirect2app(W_AbstractBytesObject.descr_zfill),
__buffer__ = interp2app(W_BytesObject.descr_getbuffer),
format = interpindirect2app(W_BytesObject.descr_format),
__format__ = interpindirect2app(W_BytesObject.descr__format__),
__mod__ = interpindirect2app(W_BytesObject.descr_mod),
__rmod__ = interpindirect2app(W_BytesObject.descr_rmod),
__getnewargs__ = interpindirect2app(
W_AbstractBytesObject.descr_getnewargs),
_formatter_parser = interp2app(W_BytesObject.descr_formatter_parser),
_formatter_field_name_split =
interp2app(W_BytesObject.descr_formatter_field_name_split),
)
W_ArrayBase.typedef = TypeDef(
'array.array',
__new__=interp2app(w_array),
__len__=interp2app(W_ArrayBase.descr_len),
__eq__=interp2app(W_ArrayBase.descr_eq),
__ne__=interp2app(W_ArrayBase.descr_ne),
__lt__=interp2app(W_ArrayBase.descr_lt),
__le__=interp2app(W_ArrayBase.descr_le),
__gt__=interp2app(W_ArrayBase.descr_gt),
__ge__=interp2app(W_ArrayBase.descr_ge),
__getitem__=interp2app(W_ArrayBase.descr_getitem),
__getslice__=interp2app(W_ArrayBase.descr_getslice),
__setitem__=interp2app(W_ArrayBase.descr_setitem),
__setslice__=interp2app(W_ArrayBase.descr_setslice),
__delitem__=interp2app(W_ArrayBase.descr_delitem),
__delslice__=interp2app(W_ArrayBase.descr_delslice),
__iter__=interp2app(W_ArrayBase.descr_iter),
__add__=interpindirect2app(W_ArrayBase.descr_add),
__iadd__=interpindirect2app(W_ArrayBase.descr_inplace_add),
__mul__=interpindirect2app(W_ArrayBase.descr_mul),
__imul__=interpindirect2app(W_ArrayBase.descr_inplace_mul),
__radd__=interp2app(W_ArrayBase.descr_radd),
__rmul__=interp2app(W_ArrayBase.descr_rmul),
__repr__=interp2app(W_ArrayBase.descr_repr),
itemsize=GetSetProperty(descr_itemsize),
typecode=GetSetProperty(descr_typecode),
__weakref__=make_weakref_descr(W_ArrayBase),
append=interpindirect2app(W_ArrayBase.descr_append),
extend=interp2app(W_ArrayBase.descr_extend),
count=interpindirect2app(W_ArrayBase.descr_count),
index=interpindirect2app(W_ArrayBase.descr_index),
reverse=interpindirect2app(W_ArrayBase.descr_reverse),
remove=interpindirect2app(W_ArrayBase.descr_remove),
pop=interpindirect2app(W_ArrayBase.descr_pop),
insert=interpindirect2app(W_ArrayBase.descr_insert),
tolist=interp2app(W_ArrayBase.descr_tolist),
fromlist=interp2app(W_ArrayBase.descr_fromlist),
tostring=interp2app(W_ArrayBase.descr_tostring),
fromstring=interp2app(W_ArrayBase.descr_fromstring),
tofile=interp2app(W_ArrayBase.descr_tofile),
fromfile=interp2app(W_ArrayBase.descr_fromfile),
fromunicode=interp2app(W_ArrayBase.descr_fromunicode),
tounicode=interp2app(W_ArrayBase.descr_tounicode),
buffer_info=interp2app(W_ArrayBase.descr_buffer_info),
__copy__=interp2app(W_ArrayBase.descr_copy),
__reduce__=interp2app(W_ArrayBase.descr_reduce),
byteswap=interp2app(W_ArrayBase.descr_byteswap),
)
return Method(space, w_function, w_obj, w_cls)
else:
return w_function
def cclassmethod_descr_get(space, w_function, w_obj, w_cls=None):
if not w_cls:
w_cls = space.type(w_obj)
return Method(space, w_function, w_cls, space.w_None)
W_PyCFunctionObject.typedef = TypeDef(
'builtin_function_or_method',
__call__=interp2app(W_PyCFunctionObject.descr_call),
__doc__=GetSetProperty(W_PyCFunctionObject.get_doc),
__module__=interp_attrproperty_w('w_module', cls=W_PyCFunctionObject),
__name__=interp_attrproperty('name',
cls=W_PyCFunctionObject,
wrapfn="newtext_or_none"),
)
W_PyCFunctionObject.typedef.acceptable_as_base_class = False
W_PyCMethodObject.typedef = TypeDef(
'method_descriptor',
__get__=interp2app(cmethod_descr_get),
__call__=interp2app(W_PyCMethodObject.descr_call),
__name__=interp_attrproperty('name',
cls=W_PyCMethodObject,
wrapfn="newtext_or_none"),
__objclass__=interp_attrproperty_w('w_objclass', cls=W_PyCMethodObject),
__repr__=interp2app(W_PyCMethodObject.descr_method_repr),
The returned object is an iterator. Each iteration returns a row
of the CSV file (which can span multiple input lines)"""
w_iter = space.iter(w_iterator)
dialect = _build_dialect(space, w_dialect, w_delimiter, w_doublequote,
w_escapechar, w_lineterminator, w_quotechar,
w_quoting, w_skipinitialspace, w_strict)
return W_Reader(space, dialect, w_iter)
W_Reader.typedef = TypeDef('_csv.reader',
dialect=interp_attrproperty_w('dialect', W_Reader),
line_num=interp_attrproperty('line_num',
W_Reader,
wrapfn="newint"),
__iter__=interp2app(W_Reader.iter_w),
__next__=interp2app(W_Reader.next_w),
__doc__="""CSV reader
Reader objects are responsible for reading and parsing tabular data
in CSV format.""")
W_Reader.typedef.acceptable_as_base_class = False
# ____________________________________________________________
class FieldLimit:
limit = 128 * 1024 # max parsed field size
field_limit = FieldLimit()
w_event.filter = evt.c_filter
w_event.flags = evt.c_flags
w_event.fflags = evt.c_fflags
w_event.data = evt.c_data
w_event.udata = evt.c_udata
elist_w[i] = w_event
return space.newlist(elist_w)
W_Kqueue.typedef = TypeDef(
"select.kqueue",
__new__=interp2app(W_Kqueue.descr__new__.im_func),
fromfd=interp2app(W_Kqueue.descr_fromfd.im_func, as_classmethod=True),
closed=GetSetProperty(W_Kqueue.descr_get_closed),
fileno=interp2app(W_Kqueue.descr_fileno),
close=interp2app(W_Kqueue.descr_close),
control=interp2app(W_Kqueue.descr_control),
)
W_Kqueue.typedef.acceptable_as_base_class = False
class W_Kevent(W_Root):
def __init__(self, space):
self.ident = rffi.cast(kevent.c_ident, 0)
self.filter = rffi.cast(kevent.c_filter, 0)
self.flags = rffi.cast(kevent.c_flags, 0)
self.fflags = rffi.cast(kevent.c_fflags, 0)
self.data = rffi.cast(kevent.c_data, 0)
self.udata = lltype.nullptr(rffi.VOIDP.TO)
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(
'_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),
newlines=GetSetProperty(W_StringIO.newlines_get_w),
)
W_UnicodeObject.typedef = TypeDef(
"unicode",
basestring_typedef,
__new__=interp2app(W_UnicodeObject.descr_new),
__doc__=UnicodeDocstrings.__doc__,
__repr__=interp2app(W_UnicodeObject.descr_repr,
doc=UnicodeDocstrings.__repr__.__doc__),
__str__=interp2app(W_UnicodeObject.descr_str,
doc=UnicodeDocstrings.__str__.__doc__),
__hash__=interp2app(W_UnicodeObject.descr_hash,
doc=UnicodeDocstrings.__hash__.__doc__),
__eq__=interp2app(W_UnicodeObject.descr_eq,
doc=UnicodeDocstrings.__eq__.__doc__),
__ne__=interp2app(W_UnicodeObject.descr_ne,
doc=UnicodeDocstrings.__ne__.__doc__),
__lt__=interp2app(W_UnicodeObject.descr_lt,
doc=UnicodeDocstrings.__lt__.__doc__),
__le__=interp2app(W_UnicodeObject.descr_le,
doc=UnicodeDocstrings.__le__.__doc__),
__gt__=interp2app(W_UnicodeObject.descr_gt,
doc=UnicodeDocstrings.__gt__.__doc__),
__ge__=interp2app(W_UnicodeObject.descr_ge,
doc=UnicodeDocstrings.__ge__.__doc__),
__len__=interp2app(W_UnicodeObject.descr_len,
doc=UnicodeDocstrings.__len__.__doc__),
__contains__=interp2app(W_UnicodeObject.descr_contains,
doc=UnicodeDocstrings.__contains__.__doc__),
__add__=interp2app(W_UnicodeObject.descr_add,
doc=UnicodeDocstrings.__add__.__doc__),
__mul__=interp2app(W_UnicodeObject.descr_mul,
doc=UnicodeDocstrings.__mul__.__doc__),
__rmul__=interp2app(W_UnicodeObject.descr_mul,
doc=UnicodeDocstrings.__rmul__.__doc__),
__getitem__=interp2app(W_UnicodeObject.descr_getitem,
doc=UnicodeDocstrings.__getitem__.__doc__),
__getslice__=interp2app(W_UnicodeObject.descr_getslice,
doc=UnicodeDocstrings.__getslice__.__doc__),
capitalize=interp2app(W_UnicodeObject.descr_capitalize,
doc=UnicodeDocstrings.capitalize.__doc__),
center=interp2app(W_UnicodeObject.descr_center,
doc=UnicodeDocstrings.center.__doc__),
count=interp2app(W_UnicodeObject.descr_count,
doc=UnicodeDocstrings.count.__doc__),
decode=interp2app(W_UnicodeObject.descr_decode,
doc=UnicodeDocstrings.decode.__doc__),
encode=interp2app(W_UnicodeObject.descr_encode,
doc=UnicodeDocstrings.encode.__doc__),
expandtabs=interp2app(W_UnicodeObject.descr_expandtabs,
doc=UnicodeDocstrings.expandtabs.__doc__),
find=interp2app(W_UnicodeObject.descr_find,
doc=UnicodeDocstrings.find.__doc__),
rfind=interp2app(W_UnicodeObject.descr_rfind,
doc=UnicodeDocstrings.rfind.__doc__),
index=interp2app(W_UnicodeObject.descr_index,
doc=UnicodeDocstrings.index.__doc__),
rindex=interp2app(W_UnicodeObject.descr_rindex,
doc=UnicodeDocstrings.rindex.__doc__),
isalnum=interp2app(W_UnicodeObject.descr_isalnum,
doc=UnicodeDocstrings.isalnum.__doc__),
isalpha=interp2app(W_UnicodeObject.descr_isalpha,
doc=UnicodeDocstrings.isalpha.__doc__),
isdecimal=interp2app(W_UnicodeObject.descr_isdecimal,
doc=UnicodeDocstrings.isdecimal.__doc__),
isdigit=interp2app(W_UnicodeObject.descr_isdigit,
doc=UnicodeDocstrings.isdigit.__doc__),
islower=interp2app(W_UnicodeObject.descr_islower,
doc=UnicodeDocstrings.islower.__doc__),
isnumeric=interp2app(W_UnicodeObject.descr_isnumeric,
doc=UnicodeDocstrings.isnumeric.__doc__),
isspace=interp2app(W_UnicodeObject.descr_isspace,
doc=UnicodeDocstrings.isspace.__doc__),
istitle=interp2app(W_UnicodeObject.descr_istitle,
doc=UnicodeDocstrings.istitle.__doc__),
isupper=interp2app(W_UnicodeObject.descr_isupper,
doc=UnicodeDocstrings.isupper.__doc__),
join=interp2app(W_UnicodeObject.descr_join,
doc=UnicodeDocstrings.join.__doc__),
ljust=interp2app(W_UnicodeObject.descr_ljust,
doc=UnicodeDocstrings.ljust.__doc__),
rjust=interp2app(W_UnicodeObject.descr_rjust,
doc=UnicodeDocstrings.rjust.__doc__),
lower=interp2app(W_UnicodeObject.descr_lower,
doc=UnicodeDocstrings.lower.__doc__),
partition=interp2app(W_UnicodeObject.descr_partition,
doc=UnicodeDocstrings.partition.__doc__),
rpartition=interp2app(W_UnicodeObject.descr_rpartition,
doc=UnicodeDocstrings.rpartition.__doc__),
replace=interp2app(W_UnicodeObject.descr_replace,
doc=UnicodeDocstrings.replace.__doc__),
split=interp2app(W_UnicodeObject.descr_split,
doc=UnicodeDocstrings.split.__doc__),
rsplit=interp2app(W_UnicodeObject.descr_rsplit,
doc=UnicodeDocstrings.rsplit.__doc__),
splitlines=interp2app(W_UnicodeObject.descr_splitlines,
doc=UnicodeDocstrings.splitlines.__doc__),
startswith=interp2app(W_UnicodeObject.descr_startswith,
doc=UnicodeDocstrings.startswith.__doc__),
endswith=interp2app(W_UnicodeObject.descr_endswith,
doc=UnicodeDocstrings.endswith.__doc__),
strip=interp2app(W_UnicodeObject.descr_strip,
doc=UnicodeDocstrings.strip.__doc__),
lstrip=interp2app(W_UnicodeObject.descr_lstrip,
doc=UnicodeDocstrings.lstrip.__doc__),
rstrip=interp2app(W_UnicodeObject.descr_rstrip,
doc=UnicodeDocstrings.rstrip.__doc__),
swapcase=interp2app(W_UnicodeObject.descr_swapcase,
doc=UnicodeDocstrings.swapcase.__doc__),
title=interp2app(W_UnicodeObject.descr_title,
doc=UnicodeDocstrings.title.__doc__),
translate=interp2app(W_UnicodeObject.descr_translate,
doc=UnicodeDocstrings.translate.__doc__),
upper=interp2app(W_UnicodeObject.descr_upper,
doc=UnicodeDocstrings.upper.__doc__),
zfill=interp2app(W_UnicodeObject.descr_zfill,
doc=UnicodeDocstrings.zfill.__doc__),
format=interp2app(W_UnicodeObject.descr_format,
doc=UnicodeDocstrings.format.__doc__),
__format__=interp2app(W_UnicodeObject.descr__format__,
doc=UnicodeDocstrings.__format__.__doc__),
__mod__=interp2app(W_UnicodeObject.descr_mod,
doc=UnicodeDocstrings.__mod__.__doc__),
__getnewargs__=interp2app(W_UnicodeObject.descr_getnewargs,
doc=UnicodeDocstrings.__getnewargs__.__doc__),
_formatter_parser=interp2app(W_UnicodeObject.descr_formatter_parser),
_formatter_field_name_split=interp2app(
W_UnicodeObject.descr_formatter_field_name_split),
)
from pypy.interpreter.typedef import TypeDef
basestring_typedef = TypeDef("basestring",
__doc__=("basepalabra no se puede instanciar; "
"es el base para pal y unicod."))
finally:
self.running = False
break
retval_w = []
for fd, revents in retval:
retval_w.append(
space.newtuple([space.newint(fd),
space.newint(revents)]))
return space.newlist(retval_w)
pollmethods = {}
for methodname in 'register modify unregister poll'.split():
pollmethods[methodname] = interp2app(getattr(Poll, methodname))
Poll.typedef = TypeDef('select.poll', **pollmethods)
# ____________________________________________________________
@objectmodel.always_inline # get rid of the tuple result
def _build_fd_set(space, list_w, ll_list, nfds):
_c.FD_ZERO(ll_list)
fdlist = []
for w_f in list_w:
fd = space.c_filedescriptor_w(w_f)
if fd > nfds:
if _c.MAX_FD_SIZE is not None and fd >= _c.MAX_FD_SIZE:
raise oefmt(space.w_ValueError,
"file descriptor out of range in select()")
nfds = fd
except OperationError, e:
if not e.match(space, space.w_AttributeError):
raise
return "?"
if space.is_true(space.isinstance(w_mod, space.w_str)):
return space.str_w(w_mod)
return "?"
W_ClassObject.typedef = TypeDef("classobj",
__new__ = interp2app(descr_classobj_new),
__repr__ = interp2app(W_ClassObject.descr_repr,
unwrap_spec=['self', ObjSpace]),
__str__ = interp2app(W_ClassObject.descr_str,
unwrap_spec=['self', ObjSpace]),
__call__ = interp2app(W_ClassObject.descr_call,
unwrap_spec=['self', ObjSpace, Arguments]),
__getattribute__ = interp2app(W_ClassObject.descr_getattribute,
unwrap_spec=['self', ObjSpace, W_Root]),
__setattr__ = interp2app(W_ClassObject.descr_setattr,
unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
__delattr__ = interp2app(W_ClassObject.descr_delattr,
unwrap_spec=['self', ObjSpace, W_Root]),
)
W_ClassObject.typedef.acceptable_as_base_class = False
def make_unary_instance_method(name):
def unaryop(self, space):
w_meth = self.getattr(space, space.wrap(name), True)
return space.call_function(w_meth)
return unaryop
r.__init__(space)
return space.wrap(r)
def unpickle(space, w_subtype):
"""Pickle support."""
r = space.allocate_instance(W_Continulet, w_subtype)
r.__init__(space)
return space.wrap(r)
W_Continulet.typedef = TypeDef(
'_continuation.continulet',
__new__=interp2app(W_Continulet___new__),
__init__=interp2app(W_Continulet.descr_init),
switch=interp2app(W_Continulet.descr_switch),
throw=interp2app(W_Continulet.descr_throw),
is_pending=interp2app(W_Continulet.descr_is_pending),
__reduce__=interp2app(W_Continulet.descr__reduce__),
__setstate__=interp2app(W_Continulet.descr__setstate__),
)
# ____________________________________________________________
# Continulet objects maintain a dummy frame object in order to ensure
# that the 'f_back' chain is consistent. We hide this dummy frame
# object by giving it a dummy code object with hidden_applevel=True.
class State:
def __init__(self, space):
self.space = space
clear.unwrap_spec = ['self', ObjSpace]
def delitem(self, space, name):
del self.cache[name]
delitem.unwrap_spec = ['self', ObjSpace, str]
W_ZipCache.typedef = TypeDef(
'zip_dict',
__getitem__=interp2app(W_ZipCache.getitem),
__contains__=interp2app(W_ZipCache.contains),
__iter__=interp2app(W_ZipCache.iterkeys),
items=interp2app(W_ZipCache.items),
iteritems=interp2app(W_ZipCache.iteritems),
keys=interp2app(W_ZipCache.keys),
iterkeys=interp2app(W_ZipCache.iterkeys),
values=interp2app(W_ZipCache.values),
itervalues=interp2app(W_ZipCache.itervalues),
clear=interp2app(W_ZipCache.clear),
__delitem__=interp2app(W_ZipCache.delitem),
)
zip_cache = W_ZipCache()
class W_ZipImporter(Wrappable):
def __init__(self, space, name, filename, dir, prefix):
self.space = space
self.name = name
self.filename = filename
w_mod = space.getbuiltinmodule('_pickle_support')
mod = space.interp_w(MixedModule, w_mod)
new_inst = mod.get('seqiter_new')
tup = [self.w_seq, space.wrap(self.index)]
return space.newtuple([new_inst, space.newtuple(tup)])
def descr_length_hint(self, space):
return self.getlength(space)
W_AbstractSeqIterObject.typedef = TypeDef(
"sequenceiterator",
__doc__ = '''iter(collection) -> iterator
iter(callable, sentinel) -> iterator
Get an iterator from an object. In the first form, the argument must
supply its own iterator, or be a sequence.
In the second form, the callable is called until it returns the sentinel.''',
__iter__ = interp2app(W_AbstractSeqIterObject.descr_iter),
next = interpindirect2app(W_AbstractSeqIterObject.descr_next),
__reduce__ = interp2app(W_AbstractSeqIterObject.descr_reduce),
__length_hint__ = interp2app(W_AbstractSeqIterObject.descr_length_hint),
)
W_AbstractSeqIterObject.typedef.acceptable_as_base_class = False
class W_SeqIterObject(W_AbstractSeqIterObject):
"""Sequence iterator implementation for general sequences."""
def descr_next(self, space):
if self.w_seq is None:
raise OperationError(space.w_StopIteration, space.w_None)
space.wrap("super(type, obj): "
"obj must be an instance or subtype of type"))
# XXX the details of how allocate_instance() should be used are not
# really well defined
w_result = space.allocate_instance(W_Super, w_subtype)
W_Super.__init__(w_result, space, w_starttype, w_type, w_obj_or_type)
return w_result
W_Super.typedef = TypeDef('super',
__new__=interp2app(descr_new_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):
def meth(self, arg):
super(C, self).meth(arg)""")
class W_Property(W_Root):
_immutable_fields_ = ["w_fget", "w_fset", "w_fdel"]
def __init__(self, space):
pass
@unwrap_spec(w_fget=WrappedDefault(None),
else:
res = cdataobj.W_CDataNewNonStdFree(space, ptr, ctype, length)
res.w_free = self.w_free
res.w_raw_cdata = w_raw_cdata
return res
@unwrap_spec(w_init=WrappedDefault(None))
def descr_call(self, space, w_arg, w_init):
ffi = self.ffi
assert ffi is not None
w_ctype = ffi.ffi_type(w_arg, ffi.ACCEPT_STRING | ffi.ACCEPT_CTYPE)
return w_ctype.newp(w_init, self)
W_Allocator.typedef = TypeDef(
'FFIAllocator',
__call__=interp2app(W_Allocator.descr_call),
)
W_Allocator.typedef.acceptable_as_base_class = False
def new_allocator(ffi, w_alloc, w_free, should_clear_after_alloc):
space = ffi.space
if space.is_none(w_alloc):
w_alloc = None
if space.is_none(w_free):
w_free = None
if w_alloc is None and w_free is not None:
raise oefmt(space.w_TypeError, "cannot pass 'free' without 'alloc'")
alloc = W_Allocator(ffi, w_alloc, w_free, bool(should_clear_after_alloc))
return space.wrap(alloc)
def fget_elements(self, space):
return self._fget('e')
def fget_relements(self, space):
return self._fget('R')
W_CType.typedef = TypeDef(
'_cffi_backend.CTypeDescr',
__repr__=interp2app(W_CType.repr),
__weakref__=make_weakref_descr(W_CType),
kind=GetSetProperty(W_CType.fget_kind, doc="kind"),
cname=GetSetProperty(W_CType.fget_cname, doc="C name"),
item=GetSetProperty(W_CType.fget_item, doc="pointer to, or array of"),
length=GetSetProperty(W_CType.fget_length, doc="array length or None"),
fields=GetSetProperty(W_CType.fget_fields, doc="struct or union fields"),
args=GetSetProperty(W_CType.fget_args, doc="function argument types"),
result=GetSetProperty(W_CType.fget_result, doc="function result type"),
ellipsis=GetSetProperty(W_CType.fget_ellipsis, doc="function has '...'"),
abi=GetSetProperty(W_CType.fget_abi, doc="function ABI"),
elements=GetSetProperty(W_CType.fget_elements, doc="enum elements"),
relements=GetSetProperty(W_CType.fget_relements,
doc="enum elements, reversed"),
__dir__=interp2app(W_CType.dir),
)
W_CType.typedef.acceptable_as_base_class = False
_name_of_attributes = [
name for name in W_CType.typedef.rawdict if not name.startswith('_')
]
_name_of_attributes.sort()
return space.wrap(memoryview)
W_MemoryView.typedef = TypeDef(
"memoryview",
__doc__="""\
Create a new memoryview object which references the given object.
""",
__new__=interp2app(descr_new),
__buffer__=interp2app(W_MemoryView.descr_buffer),
__eq__=interp2app(W_MemoryView.descr_eq),
__ge__=interp2app(W_MemoryView.descr_ge),
__getitem__=interp2app(W_MemoryView.descr_getitem),
__gt__=interp2app(W_MemoryView.descr_gt),
__le__=interp2app(W_MemoryView.descr_le),
__len__=interp2app(W_MemoryView.descr_len),
__lt__=interp2app(W_MemoryView.descr_lt),
__ne__=interp2app(W_MemoryView.descr_ne),
__setitem__=interp2app(W_MemoryView.descr_setitem),
tobytes=interp2app(W_MemoryView.descr_tobytes),
tolist=interp2app(W_MemoryView.descr_tolist),
format=GetSetProperty(W_MemoryView.w_get_format),
itemsize=GetSetProperty(W_MemoryView.w_get_itemsize),
ndim=GetSetProperty(W_MemoryView.w_get_ndim),
readonly=GetSetProperty(W_MemoryView.w_is_readonly),
shape=GetSetProperty(W_MemoryView.w_get_shape),
strides=GetSetProperty(W_MemoryView.w_get_strides),
suboffsets=GetSetProperty(W_MemoryView.w_get_suboffsets),
)
W_MemoryView.typedef.acceptable_as_base_class = False
W_GenericBox.typedef = TypeDef(
"numpy.generic",
__new__=interp2app(W_GenericBox.descr__new__.im_func),
__getitem__=interp2app(W_GenericBox.descr_getitem),
__iter__=interp2app(W_GenericBox.descr_iter),
__str__=interp2app(W_GenericBox.descr_str),
__repr__=interp2app(W_GenericBox.descr_repr),
__format__=interp2app(W_GenericBox.descr_format),
__int__=interp2app(W_GenericBox.descr_int),
__long__=interp2app(W_GenericBox.descr_long),
__float__=interp2app(W_GenericBox.descr_float),
__nonzero__=interp2app(W_GenericBox.descr_nonzero),
__oct__=interp2app(W_GenericBox.descr_oct),
__hex__=interp2app(W_GenericBox.descr_hex),
__add__=interp2app(W_GenericBox.descr_add),
__sub__=interp2app(W_GenericBox.descr_sub),
__mul__=interp2app(W_GenericBox.descr_mul),
__div__=interp2app(W_GenericBox.descr_div),
__truediv__=interp2app(W_GenericBox.descr_truediv),
__floordiv__=interp2app(W_GenericBox.descr_floordiv),
__mod__=interp2app(W_GenericBox.descr_mod),
__divmod__=interp2app(W_GenericBox.descr_divmod),
__pow__=interp2app(W_GenericBox.descr_pow),
__lshift__=interp2app(W_GenericBox.descr_lshift),
__rshift__=interp2app(W_GenericBox.descr_rshift),
__and__=interp2app(W_GenericBox.descr_and),
__or__=interp2app(W_GenericBox.descr_or),
__xor__=interp2app(W_GenericBox.descr_xor),
__radd__=interp2app(W_GenericBox.descr_radd),
__rsub__=interp2app(W_GenericBox.descr_rsub),
__rmul__=interp2app(W_GenericBox.descr_rmul),
__rdiv__=interp2app(W_GenericBox.descr_rdiv),
__rtruediv__=interp2app(W_GenericBox.descr_rtruediv),
__rfloordiv__=interp2app(W_GenericBox.descr_rfloordiv),
__rmod__=interp2app(W_GenericBox.descr_rmod),
__rdivmod__=interp2app(W_GenericBox.descr_rdivmod),
__rpow__=interp2app(W_GenericBox.descr_rpow),
__rlshift__=interp2app(W_GenericBox.descr_rlshift),
__rrshift__=interp2app(W_GenericBox.descr_rrshift),
__rand__=interp2app(W_GenericBox.descr_rand),
__ror__=interp2app(W_GenericBox.descr_ror),
__rxor__=interp2app(W_GenericBox.descr_rxor),
__eq__=interp2app(W_GenericBox.descr_eq),
__ne__=interp2app(W_GenericBox.descr_ne),
__lt__=interp2app(W_GenericBox.descr_lt),
__le__=interp2app(W_GenericBox.descr_le),
__gt__=interp2app(W_GenericBox.descr_gt),
__ge__=interp2app(W_GenericBox.descr_ge),
__pos__=interp2app(W_GenericBox.descr_pos),
__neg__=interp2app(W_GenericBox.descr_neg),
__abs__=interp2app(W_GenericBox.descr_abs),
__invert__=interp2app(W_GenericBox.descr_invert),
__hash__=interp2app(W_GenericBox.descr_hash),
__array_priority__=GetSetProperty(W_GenericBox.descr___array_priority__),
tolist=interp2app(W_GenericBox.item),
item=interp2app(W_GenericBox.descr_item),
transpose=interp2app(W_GenericBox.descr_transpose),
min=interp2app(W_GenericBox.descr_self),
max=interp2app(W_GenericBox.descr_self),
argmin=interp2app(W_GenericBox.descr_zero),
argmax=interp2app(W_GenericBox.descr_zero),
sum=interp2app(W_GenericBox.descr_self),
prod=interp2app(W_GenericBox.descr_self),
any=interp2app(W_GenericBox.descr_any),
all=interp2app(W_GenericBox.descr_all),
ravel=interp2app(W_GenericBox.descr_ravel),
round=interp2app(W_GenericBox.descr_round),
conjugate=interp2app(W_GenericBox.descr_conjugate),
conj=interp2app(W_GenericBox.descr_conjugate),
astype=interp2app(W_GenericBox.descr_astype),
view=interp2app(W_GenericBox.descr_view),
squeeze=interp2app(W_GenericBox.descr_self),
copy=interp2app(W_GenericBox.descr_copy),
byteswap=interp2app(W_GenericBox.descr_byteswap),
tostring=interp2app(W_GenericBox.descr_tostring),
tobytes=interp2app(W_GenericBox.descr_tostring),
reshape=interp2app(W_GenericBox.descr_reshape),
swapaxes=interp2app(W_GenericBox.descr_swapaxes),
nonzero=interp2app(W_GenericBox.descr_nd_nonzero),
fill=interp2app(W_GenericBox.descr_fill),
dtype=GetSetProperty(W_GenericBox.descr_get_dtype),
size=GetSetProperty(W_GenericBox.descr_get_size),
itemsize=GetSetProperty(W_GenericBox.descr_get_itemsize),
nbytes=GetSetProperty(W_GenericBox.descr_get_itemsize),
shape=GetSetProperty(W_GenericBox.descr_get_shape),
strides=GetSetProperty(W_GenericBox.descr_get_shape),
ndim=GetSetProperty(W_GenericBox.descr_get_ndim),
T=GetSetProperty(W_GenericBox.descr_self),
real=GetSetProperty(W_GenericBox.descr_get_real),
imag=GetSetProperty(W_GenericBox.descr_get_imag),
flags=GetSetProperty(W_GenericBox.descr_get_flags),
)
name = descr.name
obj = space.unwrap(w_obj)
try:
delattr(obj, name)
except:
wrap_exception(space)
W_FakeDescriptor.typedef = TypeDef(
"FakeDescriptor",
__get__=gateway.interp2app(W_FakeDescriptor.descr_descriptor_get.im_func,
unwrap_spec=[
baseobjspace.ObjSpace, W_FakeDescriptor,
baseobjspace.W_Root, baseobjspace.W_Root
]),
__set__=gateway.interp2app(W_FakeDescriptor.descr_descriptor_set.im_func,
unwrap_spec=[
baseobjspace.ObjSpace, W_FakeDescriptor,
baseobjspace.W_Root, baseobjspace.W_Root
]),
__delete__=gateway.interp2app(
W_FakeDescriptor.descr_descriptor_del.im_func,
unwrap_spec=[
baseobjspace.ObjSpace, W_FakeDescriptor, baseobjspace.W_Root
]),
)
if hasattr(file, 'softspace'): # CPython only
_fake_type_cache[type(file.softspace)] = W_FakeDescriptor
_fake_type_cache[type(type.__dict__['__dict__'])] = W_FakeDescriptor
self.offset = -1
def __repr__(self):
return '<Field %s %s>' % (self.name, self.w_ffitype.name)
@unwrap_spec(name='text')
def descr_new_field(space, w_type, name, w_ffitype):
w_ffitype = space.interp_w(W_FFIType, w_ffitype)
return W_Field(name, w_ffitype)
W_Field.typedef = TypeDef(
'Field',
__new__=interp2app(descr_new_field),
name=interp_attrproperty('name', W_Field, wrapfn="newtext_or_none"),
ffitype=interp_attrproperty_w('w_ffitype', W_Field),
offset=interp_attrproperty('offset', W_Field, wrapfn="newint"),
)
# ==============================================================================
class FFIStructOwner(object):
"""
The only job of this class is to stay outside of the reference cycle
W__StructDescr -> W_FFIType -> W__StructDescr and free the ffistruct
"""
def __init__(self, ffistruct):
self.ffistruct = ffistruct
# space.appexec("""() :
# maybe use __spacebind__ for postprocessing
AppCoroutine.typedef = TypeDef(
"coroutine",
__new__=interp2app(AppCoroutine.descr_method__new__.im_func),
bind=interp2app(AppCoroutine.w_bind,
unwrap_spec=['self', W_Root, Arguments]),
switch=interp2app(AppCoroutine.w_switch),
kill=interp2app(AppCoroutine.w_kill),
finished=interp2app(AppCoroutine.w_finished),
is_alive=GetSetProperty(AppCoroutine.w_get_is_alive),
is_zombie=GetSetProperty(AppCoroutine.w_get_is_zombie,
doc=AppCoroutine.get_is_zombie.__doc__
), #--- this flag is a bit obscure
# and not useful (it's totally different from Coroutine.is_zombie(), too)
# but lib/stackless.py uses it
_framestack=GetSetProperty(w_descr__framestack),
getcurrent=interp2app(AppCoroutine.w_getcurrent),
getmain=interp2app(AppCoroutine.w_getmain),
__reduce__=interp2app(AppCoroutine.descr__reduce__,
unwrap_spec=['self', ObjSpace]),
__setstate__=interp2app(AppCoroutine.descr__setstate__,
unwrap_spec=['self', ObjSpace, W_Root]),
__module__='_stackless',
)
class AppCoState(BaseCoState):
def __init__(self, space):
W_AbstractLongObject.typedef = TypeDef(
"long",
__doc__="""long(x=0) -> long
long(x, base=10) -> long
Convert a number or string to a long integer, or return 0L if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4L""",
__new__=interp2app(descr__new__),
numerator=typedef.GetSetProperty(
W_AbstractLongObject.descr_get_numerator,
doc="the numerator of a rational number in lowest terms"),
denominator=typedef.GetSetProperty(
W_AbstractLongObject.descr_get_denominator,
doc="the denominator of a rational number in lowest terms"),
real=typedef.GetSetProperty(W_AbstractLongObject.descr_get_real,
doc="the real part of a complex number"),
imag=typedef.GetSetProperty(W_AbstractLongObject.descr_get_imag,
doc="the imaginary part of a complex number"),
__repr__=interp2app(W_AbstractLongObject.descr_repr),
__str__=interp2app(W_AbstractLongObject.descr_str),
conjugate=interpindirect2app(W_AbstractLongObject.descr_conjugate),
bit_length=interpindirect2app(W_AbstractLongObject.descr_bit_length),
__format__=interpindirect2app(W_AbstractLongObject.descr_format),
__hash__=interpindirect2app(W_AbstractLongObject.descr_hash),
__coerce__=interpindirect2app(W_AbstractLongObject.descr_coerce),
__oct__=interpindirect2app(W_AbstractLongObject.descr_oct),
__hex__=interpindirect2app(W_AbstractLongObject.descr_hex),
__getnewargs__=interpindirect2app(W_AbstractLongObject.descr_getnewargs),
__int__=interpindirect2app(W_AbstractLongObject.int),
__long__=interpindirect2app(W_AbstractLongObject.descr_long),
__index__=interpindirect2app(W_AbstractLongObject.descr_index),
__trunc__=interpindirect2app(W_AbstractLongObject.descr_trunc),
__float__=interpindirect2app(W_AbstractLongObject.descr_float),
__pos__=interpindirect2app(W_AbstractLongObject.descr_pos),
__neg__=interpindirect2app(W_AbstractLongObject.descr_neg),
__abs__=interpindirect2app(W_AbstractLongObject.descr_abs),
__nonzero__=interpindirect2app(W_AbstractLongObject.descr_nonzero),
__invert__=interpindirect2app(W_AbstractLongObject.descr_invert),
__lt__=interpindirect2app(W_AbstractLongObject.descr_lt),
__le__=interpindirect2app(W_AbstractLongObject.descr_le),
__eq__=interpindirect2app(W_AbstractLongObject.descr_eq),
__ne__=interpindirect2app(W_AbstractLongObject.descr_ne),
__gt__=interpindirect2app(W_AbstractLongObject.descr_gt),
__ge__=interpindirect2app(W_AbstractLongObject.descr_ge),
__add__=interpindirect2app(W_AbstractLongObject.descr_add),
__radd__=interpindirect2app(W_AbstractLongObject.descr_radd),
__sub__=interpindirect2app(W_AbstractLongObject.descr_sub),
__rsub__=interpindirect2app(W_AbstractLongObject.descr_rsub),
__mul__=interpindirect2app(W_AbstractLongObject.descr_mul),
__rmul__=interpindirect2app(W_AbstractLongObject.descr_rmul),
__and__=interpindirect2app(W_AbstractLongObject.descr_and),
__rand__=interpindirect2app(W_AbstractLongObject.descr_rand),
__or__=interpindirect2app(W_AbstractLongObject.descr_or),
__ror__=interpindirect2app(W_AbstractLongObject.descr_ror),
__xor__=interpindirect2app(W_AbstractLongObject.descr_xor),
__rxor__=interpindirect2app(W_AbstractLongObject.descr_rxor),
__lshift__=interpindirect2app(W_AbstractLongObject.descr_lshift),
__rlshift__=interpindirect2app(W_AbstractLongObject.descr_rlshift),
__rshift__=interpindirect2app(W_AbstractLongObject.descr_rshift),
__rrshift__=interpindirect2app(W_AbstractLongObject.descr_rrshift),
__floordiv__=interpindirect2app(W_AbstractLongObject.descr_floordiv),
__rfloordiv__=interpindirect2app(W_AbstractLongObject.descr_rfloordiv),
__div__=interpindirect2app(W_AbstractLongObject.descr_div),
__rdiv__=interpindirect2app(W_AbstractLongObject.descr_rdiv),
__truediv__=interpindirect2app(W_AbstractLongObject.descr_truediv),
__rtruediv__=interpindirect2app(W_AbstractLongObject.descr_rtruediv),
__mod__=interpindirect2app(W_AbstractLongObject.descr_mod),
__rmod__=interpindirect2app(W_AbstractLongObject.descr_rmod),
__divmod__=interpindirect2app(W_AbstractLongObject.descr_divmod),
__rdivmod__=interpindirect2app(W_AbstractLongObject.descr_rdivmod),
__pow__=interpindirect2app(W_AbstractLongObject.descr_pow),
__rpow__=interpindirect2app(W_AbstractLongObject.descr_rpow),
)
if fmax == 0:
fmax = 1 # special case to let "int x:1" receive "1"
else:
is_signed = False
fmin = r_longlong(0)
fmax = r_longlong((r_ulonglong(1) << self.bitsize) - 1)
if value < fmin or value > fmax:
raise oefmt(
space.w_OverflowError,
"value %d outside the range allowed by the bit field "
"width: %d <= x <= %d", value, fmin, fmax)
rawmask = ((r_ulonglong(1) << self.bitsize) - 1) << self.bitshift
rawvalue = r_ulonglong(value) << self.bitshift
rawfielddata = misc.read_raw_unsigned_data(cdata, ctype.size)
rawfielddata = (rawfielddata & ~rawmask) | (rawvalue & rawmask)
if is_signed:
misc.write_raw_signed_data(cdata, rawfielddata, ctype.size)
else:
misc.write_raw_unsigned_data(cdata, rawfielddata, ctype.size)
W_CField.typedef = TypeDef(
'_cffi_backend.CField',
type=interp_attrproperty_w('ctype', W_CField),
offset=interp_attrproperty('offset', W_CField, wrapfn="newint"),
bitshift=interp_attrproperty('bitshift', W_CField, wrapfn="newint"),
bitsize=interp_attrproperty('bitsize', W_CField, wrapfn="newint"),
flags=interp_attrproperty('flags', W_CField, wrapfn="newint"),
)
W_CField.typedef.acceptable_as_base_class = False
"""A class that exposes the raw stream interface to app-level."""
# this exists for historical reasons, and kept around in case we want
# to re-expose the raw stream interface to app-level.
for name, argtypes in streamio.STREAM_METHODS.iteritems():
numargs = len(argtypes)
args = ", ".join(["v%s" % i for i in range(numargs)])
exec py.code.Source("""
def %(name)s(self, space, %(args)s):
acquired = self.try_acquire_lock()
try:
try:
result = self.stream.%(name)s(%(args)s)
except streamio.StreamError, e:
raise OperationError(space.w_ValueError,
space.wrap(e.message))
except OSError, e:
raise wrap_oserror_as_ioerror(space, e)
finally:
if acquired:
self.release_lock()
return space.wrap(result)
%(name)s.unwrap_spec = [W_Stream, ObjSpace] + argtypes
""" % locals()).compile() in globals()
W_Stream.typedef = TypeDef("Stream",
lock = interp2app(W_Stream.lock),
unlock = interp2app(W_Stream.unlock),
**dict([(name, interp2app(globals()[name]))
for name, _ in streamio.STREAM_METHODS.iteritems()]))
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),
_checkWritable = interp2app(check_writable_w),
_checkSeekable = interp2app(check_seekable_w),
_checkClosed = interp2app(W_IOBase.check_closed_w),
closed = GetSetProperty(W_IOBase.closed_get_w),
__dict__ = GetSetProperty(descr_get_dict, descr_set_dict, cls=W_IOBase),
__weakref__ = make_weakref_descr(W_IOBase),
readline = interp2app(W_IOBase.readline_w),
readlines = interp2app(W_IOBase.readlines_w),
writelines = interp2app(W_IOBase.writelines_w),
)
W_AbstractIntObject.typedef = TypeDef("int",
__doc__ = """int(x=0) -> integer
int(x, base=10) -> integer
Convert a number or string to an integer, or return 0 if no arguments
are given. If x is a number, return x.__int__(). For floating point
numbers, this truncates towards zero.
If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance representing an integer literal in the
given base. The literal can be preceded by '+' or '-' and be surrounded
by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
Base 0 means to interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4""",
__new__ = interp2app(W_IntObject.descr_new),
numerator = typedef.GetSetProperty(
W_AbstractIntObject.descr_get_numerator,
doc="the numerator of a rational number in lowest terms"),
denominator = typedef.GetSetProperty(
W_AbstractIntObject.descr_get_denominator,
doc="the denominator of a rational number in lowest terms"),
real = typedef.GetSetProperty(
W_AbstractIntObject.descr_get_real,
doc="the real part of a complex number"),
imag = typedef.GetSetProperty(
W_AbstractIntObject.descr_get_imag,
doc="the imaginary part of a complex number"),
from_bytes = interp2app(W_AbstractIntObject.descr_from_bytes,
as_classmethod=True),
to_bytes = interpindirect2app(W_AbstractIntObject.descr_to_bytes),
__repr__ = interpindirect2app(W_AbstractIntObject.descr_repr),
__str__ = interpindirect2app(W_AbstractIntObject.descr_str),
conjugate = interpindirect2app(W_AbstractIntObject.descr_conjugate),
bit_length = interpindirect2app(W_AbstractIntObject.descr_bit_length),
__format__ = interpindirect2app(W_AbstractIntObject.descr_format),
__hash__ = interpindirect2app(W_AbstractIntObject.descr_hash),
__getnewargs__ = interpindirect2app(W_AbstractIntObject.descr_getnewargs),
__int__ = interpindirect2app(W_AbstractIntObject.int),
__index__ = interpindirect2app(W_AbstractIntObject.descr_index),
__trunc__ = interpindirect2app(W_AbstractIntObject.descr_trunc),
__float__ = interpindirect2app(W_AbstractIntObject.descr_float),
__round__ = interpindirect2app(W_AbstractIntObject.descr_round),
__pos__ = interpindirect2app(W_AbstractIntObject.descr_pos),
__neg__ = interpindirect2app(W_AbstractIntObject.descr_neg),
__abs__ = interpindirect2app(W_AbstractIntObject.descr_abs),
__bool__ = interpindirect2app(W_AbstractIntObject.descr_bool),
__invert__ = interpindirect2app(W_AbstractIntObject.descr_invert),
__floor__ = interpindirect2app(W_AbstractIntObject.descr_floor),
__ceil__ = interpindirect2app(W_AbstractIntObject.descr_ceil),
__lt__ = interpindirect2app(W_AbstractIntObject.descr_lt),
__le__ = interpindirect2app(W_AbstractIntObject.descr_le),
__eq__ = interpindirect2app(W_AbstractIntObject.descr_eq),
__ne__ = interpindirect2app(W_AbstractIntObject.descr_ne),
__gt__ = interpindirect2app(W_AbstractIntObject.descr_gt),
__ge__ = interpindirect2app(W_AbstractIntObject.descr_ge),
__add__ = interpindirect2app(W_AbstractIntObject.descr_add),
__radd__ = interpindirect2app(W_AbstractIntObject.descr_radd),
__sub__ = interpindirect2app(W_AbstractIntObject.descr_sub),
__rsub__ = interpindirect2app(W_AbstractIntObject.descr_rsub),
__mul__ = interpindirect2app(W_AbstractIntObject.descr_mul),
__rmul__ = interpindirect2app(W_AbstractIntObject.descr_rmul),
__and__ = interpindirect2app(W_AbstractIntObject.descr_and),
__rand__ = interpindirect2app(W_AbstractIntObject.descr_rand),
__or__ = interpindirect2app(W_AbstractIntObject.descr_or),
__ror__ = interpindirect2app(W_AbstractIntObject.descr_ror),
__xor__ = interpindirect2app(W_AbstractIntObject.descr_xor),
__rxor__ = interpindirect2app(W_AbstractIntObject.descr_rxor),
__lshift__ = interpindirect2app(W_AbstractIntObject.descr_lshift),
__rlshift__ = interpindirect2app(W_AbstractIntObject.descr_rlshift),
__rshift__ = interpindirect2app(W_AbstractIntObject.descr_rshift),
__rrshift__ = interpindirect2app(W_AbstractIntObject.descr_rrshift),
__floordiv__ = interpindirect2app(W_AbstractIntObject.descr_floordiv),
__rfloordiv__ = interpindirect2app(W_AbstractIntObject.descr_rfloordiv),
__truediv__ = interpindirect2app(W_AbstractIntObject.descr_truediv),
__rtruediv__ = interpindirect2app(W_AbstractIntObject.descr_rtruediv),
__mod__ = interpindirect2app(W_AbstractIntObject.descr_mod),
__rmod__ = interpindirect2app(W_AbstractIntObject.descr_rmod),
__divmod__ = interpindirect2app(W_AbstractIntObject.descr_divmod),
__rdivmod__ = interpindirect2app(W_AbstractIntObject.descr_rdivmod),
__pow__ = interpindirect2app(W_AbstractIntObject.descr_pow),
__rpow__ = interpindirect2app(W_AbstractIntObject.descr_rpow),
)
def descr_richcompare(space, w_self, w_other):
return space.w_NotImplemented
W_ObjectObject.typedef = TypeDef(
"object",
__doc__="The most base type",
__new__=interp2app(descr__new__),
__subclasshook__=interp2app(descr___subclasshook__, as_classmethod=True),
# these are actually implemented in pypy.objspace.descroperation
__getattribute__=interp2app(Object.descr__getattribute__.im_func),
__setattr__=interp2app(Object.descr__setattr__.im_func),
__delattr__=interp2app(Object.descr__delattr__.im_func),
__init__=interp2app(descr__init__),
__class__=GetSetProperty(descr_get___class__, descr_set___class__),
__repr__=interp2app(descr__repr__),
__str__=interp2app(descr__str__),
__hash__=interp2app(default_identity_hash),
__reduce__=interp2app(descr__reduce__),
__reduce_ex__=interp2app(descr__reduce_ex__),
__format__=interp2app(descr___format__),
__eq__=interp2app(descr__eq__),
__ne__=interp2app(descr__ne__),
__le__=interp2app(descr_richcompare),
__lt__=interp2app(descr_richcompare),
__ge__=interp2app(descr_richcompare),
__gt__=interp2app(descr_richcompare),
)
W_CData.typedef = TypeDef(
'_cffi_backend.CData',
__module__ = '_cffi_backend',
__name__ = '<cdata>',
__repr__ = interp2app(W_CData.repr),
__bool__ = interp2app(W_CData.bool),
__int__ = interp2app(W_CData.int),
__long__ = interp2app(W_CData.long),
__float__ = interp2app(W_CData.float),
__complex__ = interp2app(W_CData.complex),
__len__ = interp2app(W_CData.len),
__lt__ = interp2app(W_CData.lt),
__le__ = interp2app(W_CData.le),
__eq__ = interp2app(W_CData.eq),
__ne__ = interp2app(W_CData.ne),
__gt__ = interp2app(W_CData.gt),
__ge__ = interp2app(W_CData.ge),
__hash__ = interp2app(W_CData.hash),
__getitem__ = interp2app(W_CData.getitem),
__setitem__ = interp2app(W_CData.setitem),
__add__ = interp2app(W_CData.add),
__radd__ = interp2app(W_CData.add),
__sub__ = interp2app(W_CData.sub),
__getattr__ = interp2app(W_CData.getattr),
__setattr__ = interp2app(W_CData.setattr),
__call__ = interp2app(W_CData.call),
__iter__ = interp2app(W_CData.iter),
__weakref__ = make_weakref_descr(W_CData),
__dir__ = interp2app(W_CData.dir),
)
W_CData.typedef.acceptable_as_base_class = False
def __init__(self, __name, __base=None, **rawdict):
"NOT_RPYTHON: initialization-time only."
TypeDef.__init__(self, __name, __base, **rawdict)
self.any = type("W_Any"+__name.title(), (baseobjspace.W_Root,), {'typedef': self})
self.local_multimethods = []
def type_isinstance(w_obj, space, w_inst):
return space.newbool(space.type(w_inst).issubtype(w_obj))
W_TypeObject.typedef = TypeDef("type",
__new__ = gateway.interp2app(descr__new__),
__name__ = GetSetProperty(descr_get__name__, descr_set__name__),
__bases__ = GetSetProperty(descr_get__bases__, descr_set__bases__),
__base__ = GetSetProperty(descr__base),
__mro__ = GetSetProperty(descr_get__mro__),
__dict__ = GetSetProperty(descr_get_dict),
__doc__ = GetSetProperty(descr__doc),
mro = gateway.interp2app(descr_mro),
__flags__ = GetSetProperty(descr__flags),
__module__ = GetSetProperty(descr_get__module, descr_set__module),
__abstractmethods__ = GetSetProperty(descr_get___abstractmethods__,
descr_set___abstractmethods__,
descr_del___abstractmethods__),
__subclasses__ = gateway.interp2app(descr___subclasses__),
__weakref__ = weakref_descr,
__instancecheck__ = gateway.interp2app(type_isinstance),
__subclasscheck__ = gateway.interp2app(type_issubtype),
__call__ = gateway.interp2app(W_TypeObject.descr_call),
__repr__ = gateway.interp2app(W_TypeObject.descr_repr),
__getattribute__ = gateway.interp2app(W_TypeObject.descr_getattribute),
__eq__ = gateway.interp2app(W_TypeObject.descr_eq),
__ne__ = gateway.interp2app(W_TypeObject.descr_ne),
)
# ____________________________________________________________
