[pypy-commit] pypy refactor-buffer-api: Split pypy.interpreter.buffer.Buffer into an interp-level part and an app-level wrapper.
Manuel Jacob
noreply at buildbot.pypy.org
Wed Aug 28 16:59:44 CEST 2013
Author: Manuel Jacob
Branch: refactor-buffer-api
Changeset: r66399:072e215b9c7b
Date: 2013-08-28 16:00 +0100
http://bitbucket.org/pypy/pypy/changeset/072e215b9c7b/
Log: Split pypy.interpreter.buffer.Buffer into an interp-level part and
an app-level wrapper.
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -196,6 +196,9 @@
def immutable_unique_id(self, space):
return None
+ def buffer_w(self, space):
+ self._typed_unwrap_error(space, "buffer")
+
def str_w(self, space):
self._typed_unwrap_error(space, "string")
@@ -1256,10 +1259,7 @@
'to unsigned int'))
def buffer_w(self, w_obj):
- # returns a Buffer instance
- from pypy.interpreter.buffer import Buffer
- w_buffer = self.buffer(w_obj)
- return self.interp_w(Buffer, w_buffer)
+ return w_obj.buffer_w(self)
def rwbuffer_w(self, w_obj):
# returns a RWBuffer instance
@@ -1598,7 +1598,6 @@
('set', 'set', 3, ['__set__']),
('delete', 'delete', 2, ['__delete__']),
('userdel', 'del', 1, ['__del__']),
- ('buffer', 'buffer', 1, ['__buffer__']), # see buffer.py
]
ObjSpace.BuiltinModuleTable = [
diff --git a/pypy/interpreter/buffer.py b/pypy/interpreter/buffer.py
--- a/pypy/interpreter/buffer.py
+++ b/pypy/interpreter/buffer.py
@@ -1,30 +1,12 @@
"""
Buffer protocol support.
"""
+from pypy.interpreter.error import OperationError
+from rpython.rlib.objectmodel import import_from_mixin
-# The implementation of the buffer protocol. The basic idea is that we
-# can ask any app-level object for a 'buffer' view on it, by calling its
-# __buffer__() special method. It should return a wrapped instance of a
-# subclass of the Buffer class defined below. Note that __buffer__() is
-# a PyPy-only extension to the Python language, made necessary by the
-# fact that it's not natural in PyPy to hack an interp-level-only
-# interface.
-# In normal usage, the convenience method space.buffer_w() should be
-# used to get directly a Buffer instance. Doing so also gives you for
-# free the typecheck that __buffer__() really returned a wrapped Buffer.
-
-import operator
-from pypy.interpreter.baseobjspace import W_Root
-from pypy.interpreter.typedef import TypeDef
-from pypy.interpreter.gateway import interp2app, unwrap_spec
-from pypy.interpreter.error import OperationError
-from rpython.rlib.objectmodel import compute_hash, import_from_mixin
-from rpython.rlib.rstring import StringBuilder
-
-
-class Buffer(W_Root):
- """Abstract base class for memory views."""
+class Buffer(object):
+ """Abstract base class for buffers."""
__slots__ = () # no extra slot here
@@ -47,91 +29,9 @@
def get_raw_address(self):
raise ValueError("no raw buffer")
- # __________ app-level support __________
-
- def descr_len(self, space):
- return space.wrap(self.getlength())
-
- def descr_getitem(self, space, w_index):
- start, stop, step, size = space.decode_index4(w_index, self.getlength())
- if step == 0: # index only
- return space.wrap(self.getitem(start))
- res = self.getslice(start, stop, step, size)
- return space.wrap(res)
-
- @unwrap_spec(newstring='bufferstr')
- def descr_setitem(self, space, w_index, newstring):
- if not isinstance(self, RWBuffer):
- raise OperationError(space.w_TypeError,
- space.wrap("buffer is read-only"))
- start, stop, step, size = space.decode_index4(w_index, self.getlength())
- if step == 0: # index only
- if len(newstring) != 1:
- msg = 'buffer[index]=x: x must be a single character'
- raise OperationError(space.w_TypeError, space.wrap(msg))
- char = newstring[0] # annotator hint
- self.setitem(start, char)
- elif step == 1:
- if len(newstring) != size:
- msg = "right operand length must match slice length"
- raise OperationError(space.w_ValueError, space.wrap(msg))
- self.setslice(start, newstring)
- else:
- raise OperationError(space.w_ValueError,
- space.wrap("buffer object does not support"
- " slicing with a step"))
-
- def descr__buffer__(self, space):
- return space.wrap(self)
-
- def descr_str(self, space):
- return space.wrap(self.as_str())
-
- @unwrap_spec(other='bufferstr')
- def descr_add(self, space, other):
- return space.wrap(self.as_str() + other)
-
- def _make_descr__cmp(name):
- def descr__cmp(self, space, w_other):
- if not isinstance(w_other, Buffer):
- return space.w_NotImplemented
- # xxx not the most efficient implementation
- str1 = self.as_str()
- str2 = w_other.as_str()
- return space.wrap(getattr(operator, name)(str1, str2))
- descr__cmp.func_name = name
- return descr__cmp
-
- descr_eq = _make_descr__cmp('eq')
- descr_ne = _make_descr__cmp('ne')
- descr_lt = _make_descr__cmp('lt')
- descr_le = _make_descr__cmp('le')
- descr_gt = _make_descr__cmp('gt')
- descr_ge = _make_descr__cmp('ge')
-
- def descr_hash(self, space):
- return space.wrap(compute_hash(self.as_str()))
-
- def descr_mul(self, space, w_times):
- # xxx not the most efficient implementation
- w_string = space.wrap(self.as_str())
- # use the __mul__ method instead of space.mul() so that we
- # return NotImplemented instead of raising a TypeError
- return space.call_method(w_string, '__mul__', w_times)
-
- def descr_repr(self, space):
- if isinstance(self, RWBuffer):
- info = 'read-write buffer'
- else:
- info = 'read-only buffer'
- addrstring = self.getaddrstring(space)
-
- return space.wrap("<%s for 0x%s, size %d>" %
- (info, addrstring, self.getlength()))
-
class RWBuffer(Buffer):
- """Abstract base class for read-write memory views."""
+ """Abstract base class for read-write buffers."""
__slots__ = () # no extra slot here
@@ -145,72 +45,6 @@
self.setitem(start + i, string[i])
- at unwrap_spec(offset=int, size=int)
-def descr_buffer__new__(space, w_subtype, w_object, offset=0, size=-1):
- # w_subtype can only be exactly 'buffer' for now
- if not space.is_w(w_subtype, space.gettypefor(Buffer)):
- raise OperationError(space.w_TypeError,
- space.wrap("argument 1 must be 'buffer'"))
-
- if space.isinstance_w(w_object, space.w_unicode):
- # unicode objects support the old buffer interface
- # but not the new buffer interface (change in python 2.7)
- from rpython.rlib.rstruct.unichar import pack_unichar, UNICODE_SIZE
- unistr = space.unicode_w(w_object)
- builder = StringBuilder(len(unistr) * UNICODE_SIZE)
- for unich in unistr:
- pack_unichar(unich, builder)
- from pypy.interpreter.buffer import StringBuffer
- w_buffer = space.wrap(StringBuffer(builder.build()))
- else:
- w_buffer = space.buffer(w_object)
-
- buffer = space.interp_w(Buffer, w_buffer) # type-check
- if offset == 0 and size == -1:
- return w_buffer
- # handle buffer slices
- if offset < 0:
- raise OperationError(space.w_ValueError,
- space.wrap("offset must be zero or positive"))
- if size < -1:
- raise OperationError(space.w_ValueError,
- space.wrap("size must be zero or positive"))
- if isinstance(buffer, RWBuffer):
- buffer = RWSubBuffer(buffer, offset, size)
- else:
- buffer = SubBuffer(buffer, offset, size)
- return space.wrap(buffer)
-
-
-Buffer.typedef = TypeDef(
- "buffer",
- __doc__ = """\
-buffer(object [, offset[, size]])
-
-Create a new buffer object which references the given object.
-The buffer will reference a slice of the target object from the
-start of the object (or at the specified offset). The slice will
-extend to the end of the target object (or with the specified size).
-""",
- __new__ = interp2app(descr_buffer__new__),
- __len__ = interp2app(Buffer.descr_len),
- __getitem__ = interp2app(Buffer.descr_getitem),
- __setitem__ = interp2app(Buffer.descr_setitem),
- __buffer__ = interp2app(Buffer.descr__buffer__),
- __str__ = interp2app(Buffer.descr_str),
- __add__ = interp2app(Buffer.descr_add),
- __eq__ = interp2app(Buffer.descr_eq),
- __ne__ = interp2app(Buffer.descr_ne),
- __lt__ = interp2app(Buffer.descr_lt),
- __le__ = interp2app(Buffer.descr_le),
- __gt__ = interp2app(Buffer.descr_gt),
- __ge__ = interp2app(Buffer.descr_ge),
- __hash__ = interp2app(Buffer.descr_hash),
- __mul__ = interp2app(Buffer.descr_mul),
- __rmul__ = interp2app(Buffer.descr_mul),
- __repr__ = interp2app(Buffer.descr_repr),
-)
-Buffer.typedef.acceptable_as_base_class = False
# ____________________________________________________________
diff --git a/pypy/module/__builtin__/interp_memoryview.py b/pypy/module/__builtin__/interp_memoryview.py
--- a/pypy/module/__builtin__/interp_memoryview.py
+++ b/pypy/module/__builtin__/interp_memoryview.py
@@ -1,14 +1,168 @@
"""
Implementation of the 'buffer' and 'memoryview' types.
"""
+import operator
+
+from pypy.interpreter import buffer
from pypy.interpreter.baseobjspace import W_Root
-from pypy.interpreter import buffer
+from pypy.interpreter.error import OperationError
from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.interpreter.typedef import TypeDef, GetSetProperty
-from pypy.interpreter.error import OperationError
-import operator
+from rpython.rlib.objectmodel import compute_hash
+from rpython.rlib.rstring import StringBuilder
-W_Buffer = buffer.Buffer # actually implemented in pypy.interpreter.buffer
+
+def _buffer_setitem(space, buf, w_index, newstring):
+ start, stop, step, size = space.decode_index4(w_index, buf.getlength())
+ if step == 0: # index only
+ if len(newstring) != 1:
+ msg = 'buffer[index]=x: x must be a single character'
+ raise OperationError(space.w_TypeError, space.wrap(msg))
+ char = newstring[0] # annotator hint
+ buf.setitem(start, char)
+ elif step == 1:
+ if len(newstring) != size:
+ msg = "right operand length must match slice length"
+ raise OperationError(space.w_ValueError, space.wrap(msg))
+ buf.setslice(start, newstring)
+ else:
+ raise OperationError(space.w_ValueError,
+ space.wrap("buffer object does not support"
+ " slicing with a step"))
+
+
+class W_Buffer(W_Root):
+ """Implement the built-in 'buffer' type as a thin wrapper around
+ an interp-level buffer.
+ """
+
+ def __init__(self, buf):
+ self.buf = buf
+
+ def buffer_w(self, space):
+ return self.buf
+
+ @staticmethod
+ @unwrap_spec(offset=int, size=int)
+ def descr_new(space, w_subtype, w_object, offset=0, size=-1):
+ if space.isinstance_w(w_object, space.w_unicode):
+ # unicode objects support the old buffer interface
+ # but not the new buffer interface (change in python 2.7)
+ from rpython.rlib.rstruct.unichar import pack_unichar, UNICODE_SIZE
+ unistr = space.unicode_w(w_object)
+ builder = StringBuilder(len(unistr) * UNICODE_SIZE)
+ for unich in unistr:
+ pack_unichar(unich, builder)
+ from pypy.interpreter.buffer import StringBuffer
+ buf = StringBuffer(builder.build())
+ else:
+ buf = space.buffer_w(w_object)
+
+ if offset == 0 and size == -1:
+ return W_Buffer(buf)
+ # handle buffer slices
+ if offset < 0:
+ raise OperationError(space.w_ValueError,
+ space.wrap("offset must be zero or positive"))
+ if size < -1:
+ raise OperationError(space.w_ValueError,
+ space.wrap("size must be zero or positive"))
+ if isinstance(buf, buffer.RWBuffer):
+ buf = buffer.RWSubBuffer(buf, offset, size)
+ else:
+ buf = buffer.SubBuffer(buf, offset, size)
+ return W_Buffer(buf)
+
+ def descr_len(self, space):
+ return space.wrap(self.buf.getlength())
+
+ def descr_getitem(self, space, w_index):
+ start, stop, step, size = space.decode_index4(w_index, self.buf.getlength())
+ if step == 0: # index only
+ return space.wrap(self.buf.getitem(start))
+ res = self.buf.getslice(start, stop, step, size)
+ return space.wrap(res)
+
+ @unwrap_spec(newstring='bufferstr')
+ def descr_setitem(self, space, w_index, newstring):
+ if not isinstance(self.buf, buffer.RWBuffer):
+ raise OperationError(space.w_TypeError,
+ space.wrap("buffer is read-only"))
+ _buffer_setitem(space, self.buf, w_index, newstring)
+
+ def descr_str(self, space):
+ return space.wrap(self.buf.as_str())
+
+ @unwrap_spec(other='bufferstr')
+ def descr_add(self, space, other):
+ return space.wrap(self.buf.as_str() + other)
+
+ def _make_descr__cmp(name):
+ def descr__cmp(self, space, w_other):
+ if not isinstance(w_other, W_Buffer):
+ return space.w_NotImplemented
+ # xxx not the most efficient implementation
+ str1 = self.buf.as_str()
+ str2 = w_other.buf.as_str()
+ return space.wrap(getattr(operator, name)(str1, str2))
+ descr__cmp.func_name = name
+ return descr__cmp
+
+ descr_eq = _make_descr__cmp('eq')
+ descr_ne = _make_descr__cmp('ne')
+ descr_lt = _make_descr__cmp('lt')
+ descr_le = _make_descr__cmp('le')
+ descr_gt = _make_descr__cmp('gt')
+ descr_ge = _make_descr__cmp('ge')
+
+ def descr_hash(self, space):
+ return space.wrap(compute_hash(self.buf.as_str()))
+
+ def descr_mul(self, space, w_times):
+ # xxx not the most efficient implementation
+ w_string = space.wrap(self.buf.as_str())
+ # use the __mul__ method instead of space.mul() so that we
+ # return NotImplemented instead of raising a TypeError
+ return space.call_method(w_string, '__mul__', w_times)
+
+ def descr_repr(self, space):
+ if isinstance(self.buf, buffer.RWBuffer):
+ info = 'read-write buffer'
+ else:
+ info = 'read-only buffer'
+ addrstring = self.getaddrstring(space)
+
+ return space.wrap("<%s for 0x%s, size %d>" %
+ (info, addrstring, self.buf.getlength()))
+
+W_Buffer.typedef = TypeDef(
+ "buffer",
+ __doc__ = """\
+buffer(object [, offset[, size]])
+
+Create a new buffer object which references the given object.
+The buffer will reference a slice of the target object from the
+start of the object (or at the specified offset). The slice will
+extend to the end of the target object (or with the specified size).
+""",
+ __new__ = interp2app(W_Buffer.descr_new),
+ __len__ = interp2app(W_Buffer.descr_len),
+ __getitem__ = interp2app(W_Buffer.descr_getitem),
+ __setitem__ = interp2app(W_Buffer.descr_setitem),
+ __str__ = interp2app(W_Buffer.descr_str),
+ __add__ = interp2app(W_Buffer.descr_add),
+ __eq__ = interp2app(W_Buffer.descr_eq),
+ __ne__ = interp2app(W_Buffer.descr_ne),
+ __lt__ = interp2app(W_Buffer.descr_lt),
+ __le__ = interp2app(W_Buffer.descr_le),
+ __gt__ = interp2app(W_Buffer.descr_gt),
+ __ge__ = interp2app(W_Buffer.descr_ge),
+ __hash__ = interp2app(W_Buffer.descr_hash),
+ __mul__ = interp2app(W_Buffer.descr_mul),
+ __rmul__ = interp2app(W_Buffer.descr_mul),
+ __repr__ = interp2app(W_Buffer.descr_repr),
+)
+W_Buffer.typedef.acceptable_as_base_class = False
class W_MemoryView(W_Root):
@@ -17,9 +171,13 @@
"""
def __init__(self, buf):
- assert isinstance(buf, buffer.Buffer)
self.buf = buf
+ @staticmethod
+ def descr_new(space, w_subtype, w_object):
+ w_memoryview = W_MemoryView(space.buffer_w(w_object))
+ return w_memoryview
+
def _make_descr__cmp(name):
def descr__cmp(self, space, w_other):
if isinstance(w_other, W_MemoryView):
@@ -29,14 +187,14 @@
return space.wrap(getattr(operator, name)(str1, str2))
try:
- w_buf = space.buffer(w_other)
+ buf = space.buffer_w(w_other)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
return space.w_NotImplemented
else:
str1 = self.as_str()
- str2 = space.buffer_w(w_buf).as_str()
+ str2 = buf.as_str()
return space.wrap(getattr(operator, name)(str1, str2))
descr__cmp.func_name = name
return descr__cmp
@@ -98,15 +256,13 @@
@unwrap_spec(newstring='bufferstr')
def descr_setitem(self, space, w_index, newstring):
- buf = self.buf
- if isinstance(buf, buffer.RWBuffer):
- buf.descr_setitem(space, w_index, newstring)
- else:
+ if not isinstance(self.buf, buffer.RWBuffer):
raise OperationError(space.w_TypeError,
space.wrap("cannot modify read-only memory"))
+ _buffer_setitem(space, self.buf, w_index, newstring)
def descr_len(self, space):
- return self.buf.descr_len(space)
+ return space.wrap(self.buf.getlength())
def w_get_format(self, space):
return space.wrap("B")
@@ -130,18 +286,12 @@
# I've never seen anyone filling this field
return space.w_None
-
-def descr_new(space, w_subtype, w_object):
- memoryview = W_MemoryView(space.buffer(w_object))
- 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),
+ __new__ = interp2app(W_MemoryView.descr_new),
__eq__ = interp2app(W_MemoryView.descr_eq),
__ge__ = interp2app(W_MemoryView.descr_ge),
__getitem__ = interp2app(W_MemoryView.descr_getitem),
diff --git a/pypy/module/_cffi_backend/cbuffer.py b/pypy/module/_cffi_backend/cbuffer.py
--- a/pypy/module/_cffi_backend/cbuffer.py
+++ b/pypy/module/_cffi_backend/cbuffer.py
@@ -4,6 +4,7 @@
from pypy.interpreter.gateway import unwrap_spec, interp2app
from pypy.interpreter.typedef import TypeDef, make_weakref_descr
from pypy.module._cffi_backend import cdataobj, ctypeptr, ctypearray
+from pypy.module.__builtin__.interp_memoryview import W_Buffer
from rpython.rtyper.lltypesystem import rffi
@@ -38,35 +39,19 @@
raw_cdata[i] = string[i]
-class MiniBuffer(W_Root):
- # a different subclass of W_Root for the MiniBuffer, because we
- # want a slightly different (simplified) API at the level of Python.
+# Override the typedef to narrow down the interface that's exposed to app-level
+class MiniBuffer(W_Buffer):
def __init__(self, buffer, keepalive=None):
- self.buffer = buffer
+ W_Buffer. __init__(self, buffer)
self.keepalive = keepalive
- def descr_len(self, space):
- return self.buffer.descr_len(space)
-
- def descr_getitem(self, space, w_index):
- return self.buffer.descr_getitem(space, w_index)
-
- @unwrap_spec(newstring='bufferstr')
- def descr_setitem(self, space, w_index, newstring):
- self.buffer.descr_setitem(space, w_index, newstring)
-
- def descr__buffer__(self, space):
- return self.buffer.descr__buffer__(space)
-
-
MiniBuffer.typedef = TypeDef(
"buffer",
__module__ = "_cffi_backend",
__len__ = interp2app(MiniBuffer.descr_len),
__getitem__ = interp2app(MiniBuffer.descr_getitem),
__setitem__ = interp2app(MiniBuffer.descr_setitem),
- __buffer__ = interp2app(MiniBuffer.descr__buffer__),
__weakref__ = make_weakref_descr(MiniBuffer),
)
MiniBuffer.typedef.acceptable_as_base_class = False
diff --git a/pypy/module/_rawffi/array.py b/pypy/module/_rawffi/array.py
--- a/pypy/module/_rawffi/array.py
+++ b/pypy/module/_rawffi/array.py
@@ -206,7 +206,6 @@
__setitem__ = interp2app(W_ArrayInstance.descr_setitem),
__getitem__ = interp2app(W_ArrayInstance.descr_getitem),
__len__ = interp2app(W_ArrayInstance.getlength),
- __buffer__ = interp2app(W_ArrayInstance.descr_buffer),
buffer = GetSetProperty(W_ArrayInstance.getbuffer),
shape = interp_attrproperty('shape', W_ArrayInstance),
free = interp2app(W_ArrayInstance.free),
@@ -230,7 +229,6 @@
__setitem__ = interp2app(W_ArrayInstance.descr_setitem),
__getitem__ = interp2app(W_ArrayInstance.descr_getitem),
__len__ = interp2app(W_ArrayInstance.getlength),
- __buffer__ = interp2app(W_ArrayInstance.descr_buffer),
buffer = GetSetProperty(W_ArrayInstance.getbuffer),
shape = interp_attrproperty('shape', W_ArrayInstance),
byptr = interp2app(W_ArrayInstance.byptr),
diff --git a/pypy/module/_rawffi/interp_rawffi.py b/pypy/module/_rawffi/interp_rawffi.py
--- a/pypy/module/_rawffi/interp_rawffi.py
+++ b/pypy/module/_rawffi/interp_rawffi.py
@@ -355,9 +355,9 @@
lltype.free(self.ll_buffer, flavor='raw')
self.ll_buffer = lltype.nullptr(rffi.VOIDP.TO)
- def descr_buffer(self, space):
+ def buffer_w(self, space):
from pypy.module._rawffi.buffer import RawFFIBuffer
- return space.wrap(RawFFIBuffer(self))
+ return RawFFIBuffer(self)
def getrawsize(self):
raise NotImplementedError("abstract base class")
diff --git a/pypy/module/_rawffi/structure.py b/pypy/module/_rawffi/structure.py
--- a/pypy/module/_rawffi/structure.py
+++ b/pypy/module/_rawffi/structure.py
@@ -367,7 +367,6 @@
__repr__ = interp2app(W_StructureInstance.descr_repr),
__getattr__ = interp2app(W_StructureInstance.getattr),
__setattr__ = interp2app(W_StructureInstance.setattr),
- __buffer__ = interp2app(W_StructureInstance.descr_buffer),
buffer = GetSetProperty(W_StructureInstance.getbuffer),
free = interp2app(W_StructureInstance.free),
shape = interp_attrproperty('shape', W_StructureInstance),
@@ -389,7 +388,6 @@
__repr__ = interp2app(W_StructureInstance.descr_repr),
__getattr__ = interp2app(W_StructureInstance.getattr),
__setattr__ = interp2app(W_StructureInstance.setattr),
- __buffer__ = interp2app(W_StructureInstance.descr_buffer),
buffer = GetSetProperty(W_StructureInstance.getbuffer),
shape = interp_attrproperty('shape', W_StructureInstance),
byptr = interp2app(W_StructureInstance.byptr),
diff --git a/pypy/module/array/interp_array.py b/pypy/module/array/interp_array.py
--- a/pypy/module/array/interp_array.py
+++ b/pypy/module/array/interp_array.py
@@ -126,6 +126,9 @@
self.len = 0
self.allocated = 0
+ def buffer_w(self, space):
+ return ArrayBuffer(self)
+
def descr_append(self, space, w_x):
""" append(x)
@@ -454,9 +457,6 @@
# Misc methods
- def descr_buffer(self, space):
- return space.wrap(ArrayBuffer(self))
-
def descr_repr(self, space):
if self.len == 0:
return space.wrap("array('%s')" % self.typecode)
@@ -500,7 +500,6 @@
__radd__ = interp2app(W_ArrayBase.descr_radd),
__rmul__ = interp2app(W_ArrayBase.descr_rmul),
- __buffer__ = interp2app(W_ArrayBase.descr_buffer),
__repr__ = interp2app(W_ArrayBase.descr_repr),
itemsize = GetSetProperty(descr_itemsize),
diff --git a/pypy/module/mmap/interp_mmap.py b/pypy/module/mmap/interp_mmap.py
--- a/pypy/module/mmap/interp_mmap.py
+++ b/pypy/module/mmap/interp_mmap.py
@@ -17,6 +17,10 @@
self.space = space
self.mmap = mmap_obj
+ def buffer_w(self, space):
+ self.check_valid()
+ return MMapBuffer(self.space, self.mmap)
+
def close(self):
self.mmap.close()
@@ -194,10 +198,6 @@
self.mmap.setitem(start, value[i])
start += step
- def descr_buffer(self):
- self.check_valid()
- return self.space.wrap(MMapBuffer(self.space, self.mmap))
-
if rmmap._POSIX:
@unwrap_spec(fileno=int, length=int, flags=int,
@@ -254,7 +254,6 @@
__len__ = interp2app(W_MMap.__len__),
__getitem__ = interp2app(W_MMap.descr_getitem),
__setitem__ = interp2app(W_MMap.descr_setitem),
- __buffer__ = interp2app(W_MMap.descr_buffer),
)
constants = rmmap.constants
diff --git a/pypy/objspace/std/bytearrayobject.py b/pypy/objspace/std/bytearrayobject.py
--- a/pypy/objspace/std/bytearrayobject.py
+++ b/pypy/objspace/std/bytearrayobject.py
@@ -28,6 +28,9 @@
""" representation for debugging purposes """
return "%s(%s)" % (w_self.__class__.__name__, ''.join(w_self.data))
+ def buffer_w(w_self, space):
+ return BytearrayBuffer(w_self.data)
+
registerimplementation(W_BytearrayObject)
init_signature = Signature(['source', 'encoding', 'errors'], None, None)
@@ -708,9 +711,5 @@
def setitem(self, index, char):
self.data[index] = char
-def buffer__Bytearray(space, self):
- b = BytearrayBuffer(self.data)
- return space.wrap(b)
-
from pypy.objspace.std import bytearraytype
register_all(vars(), bytearraytype)
diff --git a/pypy/objspace/std/inttype.py b/pypy/objspace/std/inttype.py
--- a/pypy/objspace/std/inttype.py
+++ b/pypy/objspace/std/inttype.py
@@ -107,12 +107,11 @@
else:
# If object supports the buffer interface
try:
- w_buffer = space.buffer(w_value)
+ buf = space.buffer_w(w_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
else:
- buf = space.interp_w(Buffer, w_buffer)
value, w_longval = string_to_int_or_long(space, buf.as_str())
ok = True
diff --git a/pypy/objspace/std/stringobject.py b/pypy/objspace/std/stringobject.py
--- a/pypy/objspace/std/stringobject.py
+++ b/pypy/objspace/std/stringobject.py
@@ -66,6 +66,9 @@
def str_w(w_self, space):
return w_self._value
+ def buffer_w(w_self, space):
+ return StringBuffer(w_self._value)
+
def listview_str(w_self):
return _create_list_from_string(w_self._value)
@@ -958,9 +961,6 @@
formatter = newformat.str_formatter(space, spec)
return formatter.format_string(w_string._value)
-def buffer__String(space, w_string):
- return space.wrap(StringBuffer(w_string._value))
-
# register all methods
from pypy.objspace.std import stringtype
register_all(vars(), stringtype)
More information about the pypy-commit
mailing list