__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),
if space.config.objspace.std.withprebuiltchar and not we_are_jitted():
return W_BytesObject.PREBUILT[ord(c)]
else:
return W_BytesObject(c)
W_BytesObject.typedef = StdTypeDef(
"str", basestring_typedef,
__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),
def test_interpindirect2app(self):
space = self.space
class BaseA(W_Root):
def method(self, space, x):
"This is a method"
pass
def method_with_default(self, space, x=5):
pass
@gateway.unwrap_spec(x=int)
def method_with_unwrap_spec(self, space, x):
pass
class A(BaseA):
def method(self, space, x):
return space.wrap(x + 2)
def method_with_default(self, space, x):
return space.wrap(x + 2)
def method_with_unwrap_spec(self, space, x):
return space.wrap(x + 2)
class B(BaseA):
def method(self, space, x):
return space.wrap(x + 1)
def method_with_default(self, space, x):
return space.wrap(x + 1)
def method_with_unwrap_spec(self, space, x):
return space.wrap(x + 1)
class FakeTypeDef(object):
rawdict = {}
bases = {}
applevel_subclasses_base = None
name = 'foo'
hasdict = False
weakrefable = False
doc = 'xyz'
meth = gateway.interpindirect2app(BaseA.method, {'x': int})
w_c = space.wrap(meth)
w_a = A()
w_b = B()
assert space.int_w(space.call_function(w_c, w_a,
space.wrap(1))) == 1 + 2
assert space.int_w(space.call_function(w_c, w_b,
space.wrap(-10))) == -10 + 1
doc = space.str_w(space.getattr(w_c, space.wrap('__doc__')))
assert doc == "This is a method"
meth_with_default = gateway.interpindirect2app(
BaseA.method_with_default, {'x': int})
w_d = space.wrap(meth_with_default)
assert space.int_w(space.call_function(w_d, w_a,
space.wrap(4))) == 4 + 2
assert space.int_w(space.call_function(w_d, w_b,
space.wrap(-10))) == -10 + 1
assert space.int_w(space.call_function(w_d, w_a)) == 5 + 2
assert space.int_w(space.call_function(w_d, w_b)) == 5 + 1
meth_with_unwrap_spec = gateway.interpindirect2app(
BaseA.method_with_unwrap_spec)
w_e = space.wrap(meth_with_unwrap_spec)
assert space.int_w(space.call_function(w_e, w_a,
space.wrap(4))) == 4 + 2
b = space.bigint_w(self)
b = b.lshift(3).or_(rbigint.fromint(tag))
return space.newlong_from_rbigint(b)
def unwrap(w_self, space): #YYYYYY
return w_self.longval()
def int(self, space):
raise NotImplementedError
long_typedef = StdTypeDef(
"long",
__doc__='''long(x[, base]) -> integer
Convert a string or number to a long integer, if possible. A floating
point argument will be truncated towards zero (this does not include a
string representation of a floating point number!) When converting a
string, use the optional base. It is an error to supply a base when
converting a non-string.''',
__new__=interp2app(descr__new__),
conjugate=interp2app(descr_conjugate),
numerator=typedef.GetSetProperty(descr_get_numerator),
denominator=typedef.GetSetProperty(descr_get_denominator),
real=typedef.GetSetProperty(descr_get_real),
imag=typedef.GetSetProperty(descr_get_imag),
bit_length=interp2app(bit_length),
__int__=interpindirect2app(W_AbstractLongObject.int),
)
long_typedef.registermethods(globals())
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),
for i in range(start, min(stop, length)):
w_item = self.tolist()[i]
if space.eq_w(w_item, w_obj):
return space.wrap(i)
raise OperationError(space.w_ValueError,
space.wrap("tuple.index(x): x not in tuple"))
W_AbstractTupleObject.typedef = TypeDef(
"tuple",
__doc__ = """tuple() -> an empty tuple
tuple(sequence) -> tuple initialized from sequence's items
If the argument is a tuple, the return value is the same object.""",
__new__ = interp2app(W_AbstractTupleObject.descr_new),
__repr__ = interp2app(W_AbstractTupleObject.descr_repr),
__hash__ = interpindirect2app(W_AbstractTupleObject.descr_hash),
__eq__ = interpindirect2app(W_AbstractTupleObject.descr_eq),
__ne__ = interpindirect2app(W_AbstractTupleObject.descr_ne),
__lt__ = interp2app(W_AbstractTupleObject.descr_lt),
__le__ = interp2app(W_AbstractTupleObject.descr_le),
__gt__ = interp2app(W_AbstractTupleObject.descr_gt),
__ge__ = interp2app(W_AbstractTupleObject.descr_ge),
__len__ = interp2app(W_AbstractTupleObject.descr_len),
__iter__ = interp2app(W_AbstractTupleObject.descr_iter),
__contains__ = interp2app(W_AbstractTupleObject.descr_contains),
__add__ = interp2app(W_AbstractTupleObject.descr_add),
__mul__ = interp2app(W_AbstractTupleObject.descr_mul),
__rmul__ = interp2app(W_AbstractTupleObject.descr_mul),
self.step = 1
def next(self, space):
if self.current < self.stop:
item = self.current
self.current = item + 1
return space.wrap(item)
raise OperationError(space.w_StopIteration, space.w_None)
def get_remaining(self, space):
return space.wrap(self.stop - self.current)
W_AbstractRangeIterator.typedef = TypeDef("rangeiterator",
__iter__ = interp2app(W_AbstractRangeIterator.descr_iter),
__length_hint__ = interpindirect2app(W_AbstractRangeIterator.descr_len),
__next__ = interpindirect2app(W_AbstractRangeIterator.descr_next),
__reduce__ = interpindirect2app(W_AbstractRangeIterator.descr_reduce),
)
W_AbstractRangeIterator.typedef.acceptable_as_base_class = False
class W_Map(W_Root):
_error_name = "map"
_immutable_fields_ = ["w_fun", "iterators_w"]
def __init__(self, space, w_fun, args_w):
self.space = space
self.w_fun = w_fun
iterators_w = []
for i in range(start, min(stop, length)):
w_item = self.tolist()[i]
if space.eq_w(w_item, w_obj):
return space.newint(i)
raise oefmt(space.w_ValueError, "tuple.index(x): x not in tuple")
W_AbstractTupleObject.typedef = TypeDef(
"tuple",
__doc__="""tuple() -> an empty tuple
tuple(sequence) -> tuple initialized from sequence's items
If the argument is a tuple, the return value is the same object.""",
__new__=interp2app(W_AbstractTupleObject.descr_new),
__repr__=interp2app(W_AbstractTupleObject.descr_repr),
__hash__=interpindirect2app(W_AbstractTupleObject.descr_hash),
__eq__=interpindirect2app(W_AbstractTupleObject.descr_eq),
__ne__=interpindirect2app(W_AbstractTupleObject.descr_ne),
__lt__=interp2app(W_AbstractTupleObject.descr_lt),
__le__=interp2app(W_AbstractTupleObject.descr_le),
__gt__=interp2app(W_AbstractTupleObject.descr_gt),
__ge__=interp2app(W_AbstractTupleObject.descr_ge),
__len__=interp2app(W_AbstractTupleObject.descr_len),
__iter__=interp2app(W_AbstractTupleObject.descr_iter),
__contains__=interp2app(W_AbstractTupleObject.descr_contains),
__add__=interp2app(W_AbstractTupleObject.descr_add),
__mul__=interp2app(W_AbstractTupleObject.descr_mul),
__rmul__=interp2app(W_AbstractTupleObject.descr_mul),
__getitem__=interp2app(W_AbstractTupleObject.descr_getitem),
__getnewargs__=interp2app(W_AbstractTupleObject.descr_getnewargs),
count=interp2app(W_AbstractTupleObject.descr_count),
return None
from pypy.objspace.std.model import IDTAG_LONG as tag
b = space.bigint_w(self)
b = b.lshift(3).or_(rbigint.fromint(tag))
return space.newlong_from_rbigint(b)
def unwrap(w_self, space): #YYYYYY
return w_self.longval()
def int(self, space):
raise NotImplementedError
long_typedef = StdTypeDef("long",
__doc__ = '''long(x[, base]) -> integer
Convert a string or number to a long integer, if possible. A floating
point argument will be truncated towards zero (this does not include a
string representation of a floating point number!) When converting a
string, use the optional base. It is an error to supply a base when
converting a non-string.''',
__new__ = interp2app(descr__new__),
conjugate = interp2app(descr_conjugate),
numerator = typedef.GetSetProperty(descr_get_numerator),
denominator = typedef.GetSetProperty(descr_get_denominator),
real = typedef.GetSetProperty(descr_get_real),
imag = typedef.GetSetProperty(descr_get_imag),
bit_length = interp2app(bit_length),
__int__ = interpindirect2app(W_AbstractLongObject.int),
)
long_typedef.registermethods(globals())
# listview_bytes
return [s for s in value]
W_BytesObject.EMPTY = W_BytesObject('')
W_BytesObject.typedef = TypeDef(
"pal", basestring_typedef, None, "read",
__new__ = interp2app(W_BytesObject.descr_new),
__doc__ = """pal(objeto='') -> palabra
Vuelve una representación palabra del objeto. Si el argumento es
una palabra, lo que vuelve es el objeto mismo.
""",
__repr__ = interpindirect2app(W_AbstractBytesObject.descr_repr),
__pal__ = interpindirect2app(W_AbstractBytesObject.descr_str),
__str__ = interpindirect2app(W_AbstractBytesObject.descr_str),
__hash__ = interpindirect2app(W_AbstractBytesObject.descr_hash),
__ig__ = interpindirect2app(W_AbstractBytesObject.descr_eq),
__eq__ = interpindirect2app(W_AbstractBytesObject.descr_eq),
__ni__ = interpindirect2app(W_AbstractBytesObject.descr_ne),
__ne__ = interpindirect2app(W_AbstractBytesObject.descr_ne),
__meq__ = interpindirect2app(W_AbstractBytesObject.descr_lt),
__lt__ = interpindirect2app(W_AbstractBytesObject.descr_lt),
__mei__ = interpindirect2app(W_AbstractBytesObject.descr_le),
__le__ = interpindirect2app(W_AbstractBytesObject.descr_le),
__maq__ = interpindirect2app(W_AbstractBytesObject.descr_gt),
__gt__ = interpindirect2app(W_AbstractBytesObject.descr_gt),
__mai__ = interpindirect2app(W_AbstractBytesObject.descr_ge),
def test_interpindirect2app(self):
space = self.space
class BaseA(W_Root):
def method(self, space, x):
"This is a method"
pass
def method_with_default(self, space, x=5):
pass
@gateway.unwrap_spec(x=int)
def method_with_unwrap_spec(self, space, x):
pass
def method_with_args(self, space, __args__):
pass
class A(BaseA):
def method(self, space, x):
return space.wrap(x + 2)
def method_with_default(self, space, x):
return space.wrap(x + 2)
def method_with_unwrap_spec(self, space, x):
return space.wrap(x + 2)
def method_with_args(self, space, __args__):
return space.wrap(42)
class B(BaseA):
def method(self, space, x):
return space.wrap(x + 1)
def method_with_default(self, space, x):
return space.wrap(x + 1)
def method_with_unwrap_spec(self, space, x):
return space.wrap(x + 1)
def method_with_args(self, space, __args__):
return space.wrap(43)
class FakeTypeDef(object):
rawdict = {}
bases = {}
applevel_subclasses_base = None
name = 'foo'
hasdict = False
weakrefable = False
doc = 'xyz'
meth = gateway.interpindirect2app(BaseA.method, {'x': int})
w_c = space.wrap(meth)
w_a = A()
w_b = B()
assert space.int_w(space.call_function(w_c, w_a, space.wrap(1))) == 1 + 2
assert space.int_w(space.call_function(w_c, w_b, space.wrap(-10))) == -10 + 1
doc = space.str_w(space.getattr(w_c, space.wrap('__doc__')))
assert doc == "This is a method"
meth_with_default = gateway.interpindirect2app(
BaseA.method_with_default, {'x': int})
w_d = space.wrap(meth_with_default)
assert space.int_w(space.call_function(w_d, w_a, space.wrap(4))) == 4 + 2
assert space.int_w(space.call_function(w_d, w_b, space.wrap(-10))) == -10 + 1
assert space.int_w(space.call_function(w_d, w_a)) == 5 + 2
assert space.int_w(space.call_function(w_d, w_b)) == 5 + 1
meth_with_unwrap_spec = gateway.interpindirect2app(
BaseA.method_with_unwrap_spec)
w_e = space.wrap(meth_with_unwrap_spec)
assert space.int_w(space.call_function(w_e, w_a, space.wrap(4))) == 4 + 2
meth_with_args = gateway.interpindirect2app(
BaseA.method_with_args)
w_f = space.wrap(meth_with_args)
assert space.int_w(space.call_function(w_f, w_a)) == 42
assert space.int_w(space.call_function(w_f, w_b,
space.wrap("ignored"))) == 43
# check that the optimization works even though we are using
# interpindirect2app:
assert isinstance(meth_with_args._code,
gateway.BuiltinCodePassThroughArguments1)
index = 0
self.index = index
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),
__setstate__ = interpindirect2app(W_AbstractSeqIterObject.descr_setstate),
)
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)
try:
w_item = space.getitem(self.w_seq, space.newint(self.index))
doc="el numerador de un número racional en términos bajos"),
denominador=typedef.GetSetProperty(
W_AbstractLongObject.descr_get_denominator,
doc="el denominador de un número racional en términos bajos"),
denominator=typedef.GetSetProperty(
W_AbstractLongObject.descr_get_denominator,
doc="el denominador de un número racional en términos bajos"),
real=typedef.GetSetProperty(W_AbstractLongObject.descr_get_real,
doc="el parte real de un número complejo"),
imag=typedef.GetSetProperty(
W_AbstractLongObject.descr_get_imag,
doc="el parte imaginario de un número complejo"),
__repr__=interp2app(W_AbstractLongObject.descr_repr),
__pal__=interp2app(W_AbstractLongObject.descr_str),
__str__=interp2app(W_AbstractLongObject.descr_str),
conjugar=interpindirect2app(W_AbstractLongObject.descr_conjugate),
conjugate=interpindirect2app(W_AbstractLongObject.descr_conjugate),
tamano_bit=interpindirect2app(W_AbstractLongObject.descr_bit_length),
bit_length=interpindirect2app(W_AbstractLongObject.descr_bit_length),
__formato__=interpindirect2app(W_AbstractLongObject.descr_format),
__format__=interpindirect2app(W_AbstractLongObject.descr_format),
__hash__=interpindirect2app(W_AbstractLongObject.descr_hash),
__forzar__=interpindirect2app(W_AbstractLongObject.descr_coerce),
__coerce__=interpindirect2app(W_AbstractLongObject.descr_coerce),
__oct__=interpindirect2app(W_AbstractLongObject.descr_oct),
__hex__=interpindirect2app(W_AbstractLongObject.descr_hex),
__sacanuevosargs__=interpindirect2app(
W_AbstractLongObject.descr_getnewargs),
__getnewargs__=interpindirect2app(W_AbstractLongObject.descr_getnewargs),
__dnt__=interpindirect2app(W_AbstractLongObject.int),
__int__=interpindirect2app(W_AbstractLongObject.int),
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)
try:
w_item = space.getitem(self.w_seq, space.wrap(self.index))
except OperationError as e:
def immutable_unique_id(self, space):
if self.user_overridden_class:
return None
from pypy.objspace.std.model import IDTAG_INT as tag
b = space.bigint_w(self)
b = b.lshift(3).or_(rbigint.fromint(tag))
return space.newlong_from_rbigint(b)
def int(self, space):
raise NotImplementedError
int_typedef = StdTypeDef("int",
__doc__ = '''int(x[, base]) -> integer
Convert a string or number to an integer, if possible. A floating point
argument will be truncated towards zero (this does not include a string
representation of a floating point number!) When converting a string, use
the optional base. It is an error to supply a base when converting a
non-string. If the argument is outside the integer range a long object
will be returned instead.''',
__new__ = interp2app(descr__new__),
conjugate = interp2app(descr_conjugate),
bit_length = interp2app(descr_bit_length),
numerator = typedef.GetSetProperty(descr_get_numerator),
denominator = typedef.GetSetProperty(descr_get_denominator),
real = typedef.GetSetProperty(descr_get_real),
imag = typedef.GetSetProperty(descr_get_imag),
__int__ = interpindirect2app(W_AbstractIntObject.int),
)
int_typedef.registermethods(globals())
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),
def test_interpindirect2app(self):
space = self.space
class BaseA(W_Root):
def method(self, space, x):
"This is a method"
pass
def method_with_default(self, space, x=5):
pass
@gateway.unwrap_spec(x=int)
def method_with_unwrap_spec(self, space, x):
pass
class A(BaseA):
def method(self, space, x):
return space.wrap(x + 2)
def method_with_default(self, space, x):
return space.wrap(x + 2)
def method_with_unwrap_spec(self, space, x):
return space.wrap(x + 2)
class B(BaseA):
def method(self, space, x):
return space.wrap(x + 1)
def method_with_default(self, space, x):
return space.wrap(x + 1)
def method_with_unwrap_spec(self, space, x):
return space.wrap(x + 1)
class FakeTypeDef(object):
rawdict = {}
bases = {}
applevel_subclasses_base = None
name = 'foo'
hasdict = False
weakrefable = False
doc = 'xyz'
meth = gateway.interpindirect2app(BaseA.method, {'x': int})
w_c = space.wrap(meth)
w_a = A()
w_b = B()
assert space.int_w(space.call_function(w_c, w_a, space.wrap(1))) == 1 + 2
assert space.int_w(space.call_function(w_c, w_b, space.wrap(-10))) == -10 + 1
doc = space.str_w(space.getattr(w_c, space.wrap('__doc__')))
assert doc == "This is a method"
meth_with_default = gateway.interpindirect2app(
BaseA.method_with_default, {'x': int})
w_d = space.wrap(meth_with_default)
assert space.int_w(space.call_function(w_d, w_a, space.wrap(4))) == 4 + 2
assert space.int_w(space.call_function(w_d, w_b, space.wrap(-10))) == -10 + 1
assert space.int_w(space.call_function(w_d, w_a)) == 5 + 2
assert space.int_w(space.call_function(w_d, w_b)) == 5 + 1
meth_with_unwrap_spec = gateway.interpindirect2app(
BaseA.method_with_unwrap_spec)
w_e = space.wrap(meth_with_unwrap_spec)
assert space.int_w(space.call_function(w_e, w_a, space.wrap(4))) == 4 + 2
@unwrap_spec(w_timeout=WrappedDefault(0.0))
def poll(self, space, w_timeout):
self._check_readable(space)
if space.is_w(w_timeout, space.w_None):
timeout = -1.0 # block forever
else:
timeout = space.float_w(w_timeout)
if timeout < 0.0:
timeout = 0.0
return space.newbool(self.do_poll(space, timeout))
W_BaseConnection.typedef = TypeDef(
'BaseConnection',
__repr__=interpindirect2app(W_BaseConnection.descr_repr),
closed=GetSetProperty(W_BaseConnection.closed_get),
readable=GetSetProperty(W_BaseConnection.readable_get),
writable=GetSetProperty(W_BaseConnection.writable_get),
send_bytes=interp2app(W_BaseConnection.send_bytes),
recv_bytes=interp2app(W_BaseConnection.recv_bytes),
recv_bytes_into=interp2app(W_BaseConnection.recv_bytes_into),
send=interp2app(W_BaseConnection.send),
recv=interp2app(W_BaseConnection.recv),
poll=interp2app(W_BaseConnection.poll),
close=interp2app(W_BaseConnection.close),
)
class W_FileConnection(W_BaseConnection):
INVALID_HANDLE_VALUE = -1
return w_unpickled
@unwrap_spec(w_timeout=WrappedDefault(0.0))
def poll(self, space, w_timeout):
self._check_readable(space)
if space.is_w(w_timeout, space.w_None):
timeout = -1.0 # block forever
else:
timeout = space.float_w(w_timeout)
if timeout < 0.0:
timeout = 0.0
return space.newbool(self.do_poll(space, timeout))
W_BaseConnection.typedef = TypeDef(
'BaseConnection',
__repr__ = interpindirect2app(W_BaseConnection.descr_repr),
closed = GetSetProperty(W_BaseConnection.closed_get),
readable = GetSetProperty(W_BaseConnection.readable_get),
writable = GetSetProperty(W_BaseConnection.writable_get),
send_bytes = interp2app(W_BaseConnection.send_bytes),
recv_bytes = interp2app(W_BaseConnection.recv_bytes),
recv_bytes_into = interp2app(W_BaseConnection.recv_bytes_into),
send = interp2app(W_BaseConnection.send),
recv = interp2app(W_BaseConnection.recv),
poll = interp2app(W_BaseConnection.poll),
close = interp2app(W_BaseConnection.close),
)
class W_FileConnection(W_BaseConnection):
INVALID_HANDLE_VALUE = -1
__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),
W_BytesObject.EMPTY = W_BytesObject('')
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),
>>> 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),
return None
from pypy.objspace.std.model import IDTAG_INT as tag
b = space.bigint_w(self)
b = b.lshift(3).or_(rbigint.fromint(tag))
return space.newlong_from_rbigint(b)
def int(self, space):
raise NotImplementedError
int_typedef = StdTypeDef(
"int",
__doc__='''int(x[, base]) -> integer
Convert a string or number to an integer, if possible. A floating point
argument will be truncated towards zero (this does not include a string
representation of a floating point number!) When converting a string, use
the optional base. It is an error to supply a base when converting a
non-string. If the argument is outside the integer range a long object
will be returned instead.''',
__new__=interp2app(descr__new__),
conjugate=interp2app(descr_conjugate),
bit_length=interp2app(descr_bit_length),
numerator=typedef.GetSetProperty(descr_get_numerator),
denominator=typedef.GetSetProperty(descr_get_denominator),
real=typedef.GetSetProperty(descr_get_real),
imag=typedef.GetSetProperty(descr_get_imag),
__int__=interpindirect2app(W_AbstractIntObject.int),
)
int_typedef.registermethods(globals())
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)
try:
w_item = space.getitem(self.w_seq, space.wrap(self.index))
except OperationError, e:
self.w_seq = None
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),
