doc="count(obj) -> number of times obj appears in the tuple")
tuple_index = SMM("index", 4, defaults=(0, sys.maxint),
doc="index(obj, [start, [stop]]) -> first index that obj "
"appears in the tuple")
def descr__new__(space, w_tupletype, w_sequence=gateway.NoneNotWrapped):
from pypy.objspace.std.tupleobject import W_TupleObject
if w_sequence is None:
tuple_w = []
elif (space.is_w(w_tupletype, space.w_tuple) and
space.is_w(space.type(w_sequence), space.w_tuple)):
return w_sequence
else:
tuple_w = space.fixedview(w_sequence)
w_obj = space.allocate_instance(W_TupleObject, w_tupletype)
W_TupleObject.__init__(w_obj, tuple_w)
return w_obj
# ____________________________________________________________
tuple_typedef = StdTypeDef("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__ = gateway.interp2app(descr__new__),
)
tuple_typedef.registermethods(globals())
space.newtuple([w_self.w_start,
w_self.w_stop,
w_self.w_step]),
])
# ____________________________________________________________
def slicewprop(name):
def fget(space, w_obj):
from pypy.objspace.std.sliceobject import W_SliceObject
if not isinstance(w_obj, W_SliceObject):
raise OperationError(space.w_TypeError,
space.wrap("descriptor is for 'slice'"))
return getattr(w_obj, name)
return GetSetProperty(fget)
slice_typedef = StdTypeDef("slice",
__doc__ = '''slice([start,] stop[, step])
Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).''',
__new__ = gateway.interp2app(descr__new__),
__hash__ = None,
__reduce__ = gateway.interp2app(descr__reduce__),
start = slicewprop('w_start'),
stop = slicewprop('w_stop'),
step = slicewprop('w_step'),
)
slice_typedef.acceptable_as_base_class = False
slice_typedef.registermethods(globals())
defaults=(0, sys.maxint),
doc="index(obj, [start, [stop]]) -> first index that obj "
"appears in the tuple")
def descr__new__(space, w_tupletype, w_sequence=gateway.NoneNotWrapped):
from pypy.objspace.std.tupleobject import W_TupleObject
if w_sequence is None:
tuple_w = []
elif (space.is_w(w_tupletype, space.w_tuple)
and space.is_w(space.type(w_sequence), space.w_tuple)):
return w_sequence
else:
tuple_w = space.fixedview(w_sequence)
w_obj = space.allocate_instance(W_TupleObject, w_tupletype)
W_TupleObject.__init__(w_obj, tuple_w)
return w_obj
# ____________________________________________________________
tuple_typedef = StdTypeDef(
"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__=gateway.interp2app(descr__new__),
)
tuple_typedef.registermethods(globals())
encoding, errors)
if space.is_w(w_unicodetype, space.w_unicode):
return w_value
if space.config.objspace.std.withropeunicode:
assert isinstance(w_value, W_RopeUnicodeObject)
w_newobj = space.allocate_instance(W_RopeUnicodeObject, w_unicodetype)
W_RopeUnicodeObject.__init__(w_newobj, w_value._node)
return w_newobj
assert isinstance(w_value, W_UnicodeObject)
w_newobj = space.allocate_instance(W_UnicodeObject, w_unicodetype)
W_UnicodeObject.__init__(w_newobj, w_value._value)
return w_newobj
# ____________________________________________________________
unicode_typedef = StdTypeDef("unicode", basestring_typedef,
__new__ = gateway.interp2app(descr_new_),
__doc__ = '''unicode(string [, encoding[, errors]]) -> object
Create a new Unicode object from the given encoded string.
encoding defaults to the current default string encoding.
errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.'''
)
unicode_typedef.registermethods(globals())
unitypedef = unicode_typedef
register_all(vars(), globals())
' one of the sets.)')
frozenset_union = SMM('union', 2,
doc='Return the union of two sets as a'
' new set.\n\n(i.e. all elements'
' that are in either set.)')
frozenset_reduce = SMM('__reduce__',1,
doc='Return state information for'
' pickling.')
register_all(vars(), globals())
def descr__frozenset__new__(space, w_frozensettype, w_iterable=NoneNotWrapped):
from pypy.objspace.std.setobject import W_FrozensetObject
from pypy.objspace.std.setobject import _is_frozenset_exact
if (space.is_w(w_frozensettype, space.w_frozenset) and
_is_frozenset_exact(w_iterable)):
return w_iterable
w_obj = space.allocate_instance(W_FrozensetObject, w_frozensettype)
W_FrozensetObject.__init__(w_obj, space, None)
return w_obj
frozenset_typedef = StdTypeDef("frozenset",
__doc__ = """frozenset(iterable) --> frozenset object
Build an immutable unordered collection.""",
__new__ = newmethod(descr__frozenset__new__),
)
frozenset_typedef.registermethods(globals())
# ____________________________________________________________
def slicewprop(name):
def fget(space, w_obj):
from pypy.objspace.std.sliceobject import W_SliceObject
if not isinstance(w_obj, W_SliceObject):
raise OperationError(space.w_TypeError,
space.wrap("descriptor is for 'slice'"))
return getattr(w_obj, name)
return GetSetProperty(fget)
slice_typedef = StdTypeDef(
"slice",
__doc__='''slice([start,] stop[, step])
Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).''',
__new__=gateway.interp2app(descr__new__),
__hash__=None,
__reduce__=gateway.interp2app(descr__reduce__),
start=slicewprop('w_start'),
stop=slicewprop('w_stop'),
step=slicewprop('w_step'),
)
slice_typedef.acceptable_as_base_class = False
slice_typedef.registermethods(globals())
while i < length and s[i].isspace():
i += 1
if i != length:
raise OperationError(space.w_ValueError,
space.wrap("invalid hex string"))
w_float = space.wrap(sign * value)
return space.call_function(w_cls, w_float)
def descr_get_real(space, w_obj):
return space.float(w_obj)
def descr_get_imag(space, w_obj):
return space.wrap(0.0)
# ____________________________________________________________
float_typedef = StdTypeDef("float",
__doc__ = '''float(x) -> floating point number
Convert a string or number to a floating point number, if possible.''',
__new__ = gateway.interp2app(descr__new__),
__getformat__ = gateway.interp2app(descr___getformat__,
as_classmethod=True),
fromhex = gateway.interp2app(descr_fromhex,
as_classmethod=True),
conjugate = gateway.interp2app(descr_conjugate),
real = typedef.GetSetProperty(descr_get_real),
imag = typedef.GetSetProperty(descr_get_imag),
)
float_typedef.registermethods(globals())
' the list')
def list_reversed__ANY(space, w_list):
from pypy.objspace.std.iterobject import W_ReverseSeqIterObject
return W_ReverseSeqIterObject(space, w_list, -1)
register_all(vars(), globals())
# ____________________________________________________________
def descr__new__(space, w_listtype, __args__):
from pypy.objspace.std.listobject import W_ListObject
w_obj = space.allocate_instance(W_ListObject, w_listtype)
w_obj.clear(space)
return w_obj
# ____________________________________________________________
list_typedef = StdTypeDef("list",
__doc__ = '''list() -> new list
list(sequence) -> new list initialized from sequence's items''',
__new__ = gateway.interp2app(descr__new__),
__hash__ = None,
)
list_typedef.registermethods(globals())
# ____________________________________________________________
def get_list_index(space, w_index):
return space.getindex_w(w_index, space.w_IndexError, "list index")
return (space.float_w(space.float(w_complex)), 0.0)
def complexwprop(name):
def fget(space, w_obj):
from pypy.objspace.std.complexobject import W_ComplexObject
if not isinstance(w_obj, W_ComplexObject):
raise OperationError(space.w_TypeError,
space.wrap("descriptor is for 'complex'"))
return space.newfloat(getattr(w_obj, name))
return GetSetProperty(fget)
def descr___getnewargs__(space, w_self):
from pypy.objspace.std.complexobject import W_ComplexObject
assert isinstance(w_self, W_ComplexObject)
return space.newtuple([space.newfloat(w_self.realval),
space.newfloat(w_self.imagval)])
complex_typedef = StdTypeDef("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(descr__new__),
__getnewargs__ = interp2app(descr___getnewargs__),
real = complexwprop('realval'),
imag = complexwprop('imagval'),
)
complex_typedef.registermethods(globals())
"dict",
__doc__='''dict() -> new empty dictionary.
dict(mapping) -> new dictionary initialized from a mapping object\'s
(key, value) pairs.
dict(seq) -> new dictionary initialized as if via:
d = {}
for k, v in seq:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)''',
__new__=gateway.interp2app(descr__new__),
__hash__=None,
__repr__=gateway.interp2app(descr_repr),
fromkeys=gateway.interp2app(descr_fromkeys, as_classmethod=True),
)
dict_typedef.registermethods(globals())
# ____________________________________________________________
def descr_dictiter__reduce__(w_self, space):
"""
This is a slightly special case of pickling.
Since iteration over a dict is a bit hairy,
we do the following:
- create a clone of the dict iterator
- run it to the original position
- collect all remaining elements into a list
At unpickling time, we just use that list
and create an iterator on it.
This is of course not the standard way.
space.wrap(
"non-hexadecimal number found in fromhex() arg at position %d"
% i))
bot = _hex_digit_to_int(hexstring[i + 1])
if bot == -1:
raise OperationError(
space.w_ValueError,
space.wrap(
"non-hexadecimal number found in fromhex() arg at position %d"
% (i + 1, )))
data.append(chr(top * 16 + bot))
# in CPython bytearray.fromhex is a staticmethod, so
# we ignore w_type and always return a bytearray
return new_bytearray(space, space.w_bytearray, data)
# ____________________________________________________________
bytearray_typedef = StdTypeDef(
"bytearray",
__doc__='''bytearray() -> an empty bytearray
bytearray(sequence) -> bytearray initialized from sequence\'s items
If the argument is a bytearray, the return value is the same object.''',
__new__=gateway.interp2app(descr__new__),
__hash__=None,
__reduce__=gateway.interp2app(descr_bytearray__reduce__),
fromhex=gateway.interp2app(descr_fromhex, as_classmethod=True))
bytearray_typedef.registermethods(globals())
raise OperationError(space.w_ValueError, space.wrap(
"non-hexadecimal number found in fromhex() arg at position %d" % i))
top = _hex_digit_to_int(hexstring[i])
if top == -1:
raise OperationError(space.w_ValueError, space.wrap(
"non-hexadecimal number found in fromhex() arg at position %d" % i))
bot = _hex_digit_to_int(hexstring[i+1])
if bot == -1:
raise OperationError(space.w_ValueError, space.wrap(
"non-hexadecimal number found in fromhex() arg at position %d" % (i+1,)))
data.append(chr(top*16 + bot))
# in CPython bytearray.fromhex is a staticmethod, so
# we ignore w_type and always return a bytearray
return new_bytearray(space, space.w_bytearray, data)
# ____________________________________________________________
bytearray_typedef = StdTypeDef("bytearray",
__doc__ = '''bytearray() -> an empty bytearray
bytearray(sequence) -> bytearray initialized from sequence\'s items
If the argument is a bytearray, the return value is the same object.''',
__new__ = gateway.interp2app(descr__new__),
__hash__ = None,
__reduce__ = gateway.interp2app(descr_bytearray__reduce__),
fromhex = gateway.interp2app(descr_fromhex, as_classmethod=True)
)
bytearray_typedef.registermethods(globals())
def bit_length(space, w_obj):
bigint = space.bigint_w(w_obj)
try:
return space.wrap(bigint.bit_length())
except OverflowError:
raise OperationError(space.w_OverflowError,
space.wrap("too many digits in integer"))
# ____________________________________________________________
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__=gateway.interp2app(descr__new__),
conjugate=gateway.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=gateway.interp2app(bit_length),
)
long_typedef.registermethods(globals())
dict_typedef = StdTypeDef("dict",
__doc__ = '''dict() -> new empty dictionary.
dict(mapping) -> new dictionary initialized from a mapping object\'s
(key, value) pairs.
dict(seq) -> new dictionary initialized as if via:
d = {}
for k, v in seq:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)''',
__new__ = gateway.interp2app(descr__new__),
__hash__ = None,
__repr__ = gateway.interp2app(descr_repr),
fromkeys = gateway.interp2app(descr_fromkeys, as_classmethod=True),
)
dict_typedef.registermethods(globals())
# ____________________________________________________________
def descr_dictiter__reduce__(w_self, space):
"""
This is a slightly special case of pickling.
Since iteration over a dict is a bit hairy,
we do the following:
- create a clone of the dict iterator
- run it to the original position
- collect all remaining elements into a list
At unpickling time, we just use that list
and create an iterator on it.
This is of course not the standard way.
return one == two
def immutable_unique_id(self, space):
if self.user_overridden_class:
return None
from rpython.rlib.longlong2float import float2longlong
from pypy.objspace.std.model import IDTAG_FLOAT as tag
val = float2longlong(space.float_w(self))
b = rbigint.fromrarith_int(val)
b = b.lshift(3).or_(rbigint.fromint(tag))
return space.newlong_from_rbigint(b)
def int(self, space):
raise NotImplementedError
float_typedef = StdTypeDef(
"float",
__doc__='''float(x) -> floating point number
Convert a string or number to a floating point number, if possible.''',
__new__=interp2app(descr__new__),
__getformat__=interp2app(descr___getformat__, as_classmethod=True),
fromhex=interp2app(descr_fromhex, as_classmethod=True),
conjugate=interp2app(descr_conjugate),
real=typedef.GetSetProperty(descr_get_real),
imag=typedef.GetSetProperty(descr_get_imag),
__int__=interpindirect2app(W_AbstractFloatObject.int),
)
float_typedef.registermethods(globals())
register_all(vars(), globals())
# ____________________________________________________________
@unwrap_spec(w_object=WrappedDefault(""))
def descr__new__(space, w_stringtype, w_object):
# NB. the default value of w_object is really a *wrapped* empty string:
# there is gateway magic at work
from pypy.objspace.std.stringobject import W_StringObject
w_obj = space.str(w_object)
if space.is_w(w_stringtype, space.w_str):
return w_obj # XXX might be reworked when space.str() typechecks
value = space.str_w(w_obj)
w_obj = space.allocate_instance(W_StringObject, w_stringtype)
W_StringObject.__init__(w_obj, value)
return w_obj
# ____________________________________________________________
str_typedef = StdTypeDef("str",
basestring_typedef,
__new__=interp2app(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.''')
str_typedef.registermethods(globals())
return w_obj
# ____________________________________________________________
str_typedef = StdTypeDef(
"str",
basestring_typedef,
__new__=gateway.interp2app(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.""",
)
str_typedef.registermethods(globals())
# ____________________________________________________________
# Helpers for several string implementations
@specialize.argtype(0)
def stringendswith(u_self, suffix, start, end):
begin = end - len(suffix)
if begin < start:
return False
for i in range(len(suffix)):
if u_self[begin + i] != suffix[i]:
return False
return True
' one of the sets.)')
frozenset_union = SMM('union', 2,
doc='Return the union of two sets as a'
' new set.\n\n(i.e. all elements'
' that are in either set.)')
frozenset_reduce = SMM('__reduce__',1,
doc='Return state information for'
' pickling.')
register_all(vars(), globals())
def descr__frozenset__new__(space, w_frozensettype, w_iterable=NoneNotWrapped):
from pypy.objspace.std.setobject import W_FrozensetObject
from pypy.objspace.std.setobject import _is_frozenset_exact
if _is_frozenset_exact(w_iterable):
return w_iterable
w_obj = space.allocate_instance(W_FrozensetObject, w_frozensettype)
W_FrozensetObject.__init__(w_obj, space, None)
return w_obj
frozenset_typedef = StdTypeDef("frozenset",
__doc__ = """frozenset(iterable) --> frozenset object
Build an immutable unordered collection.""",
__new__ = newmethod(descr__frozenset__new__),
)
frozenset_typedef.custom_hash = True
frozenset_typedef.registermethods(globals())
def complexwprop(name):
def fget(space, w_obj):
from pypy.objspace.std.complexobject import W_ComplexObject
if not isinstance(w_obj, W_ComplexObject):
raise OperationError(space.w_TypeError,
space.wrap("descriptor is for 'complex'"))
return space.newfloat(getattr(w_obj, name))
return GetSetProperty(fget)
def descr___getnewargs__(space, w_self):
from pypy.objspace.std.complexobject import W_ComplexObject
assert isinstance(w_self, W_ComplexObject)
return space.newtuple([space.newcomplex(w_self.realval, w_self.imagval)])
complex_typedef = StdTypeDef(
"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__=newmethod(descr__new__),
__getnewargs__=newmethod(descr___getnewargs__),
real=complexwprop('realval'),
imag=complexwprop('imagval'),
)
complex_typedef.registermethods(globals())
def descr_get_imag(space, w_obj):
return space.newlong(0)
def bit_length(space, w_obj):
bigint = space.bigint_w(w_obj)
try:
return space.wrap(bigint.bit_length())
except OverflowError:
raise OperationError(space.w_OverflowError,
space.wrap("too many digits in integer"))
# ____________________________________________________________
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__ = gateway.interp2app(descr__new__),
conjugate = gateway.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 = gateway.interp2app(bit_length),
)
long_typedef.registermethods(globals())
encoding, errors)
if space.is_w(w_unicodetype, space.w_unicode):
return w_value
if space.config.objspace.std.withropeunicode:
assert isinstance(w_value, W_RopeUnicodeObject)
w_newobj = space.allocate_instance(W_RopeUnicodeObject, w_unicodetype)
W_RopeUnicodeObject.__init__(w_newobj, w_value._node)
return w_newobj
assert isinstance(w_value, W_UnicodeObject)
w_newobj = space.allocate_instance(W_UnicodeObject, w_unicodetype)
W_UnicodeObject.__init__(w_newobj, w_value._value)
return w_newobj
# ____________________________________________________________
unicode_typedef = StdTypeDef("unicode", basestring_typedef,
__new__ = gateway.interp2app(descr_new_),
__doc__ = '''unicode(string [, encoding[, errors]]) -> object
Create a new Unicode object from the given encoded string.
encoding defaults to the current default string encoding.
errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.'''
)
unicode_typedef.registermethods(globals())
unitypedef = unicode_typedef
register_all(vars(), globals())
