PageRenderTime 24ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/pypy/module/_io/interp_bytesio.py

https://bitbucket.org/pypy/pypy/
Python | 174 lines | 144 code | 30 blank | 0 comment | 19 complexity | 18fb5e573b57cc94ea0b568805fedb12 MD5 | raw file
Possible License(s): AGPL-3.0, BSD-3-Clause, Apache-2.0
  1. from pypy.interpreter.error import OperationError, oefmt
  2. from pypy.interpreter.typedef import (
  3. TypeDef, generic_new_descr, GetSetProperty)
  4. from pypy.interpreter.gateway import interp2app, unwrap_spec
  5. from rpython.rlib.rStringIO import RStringIO
  6. from rpython.rlib.rarithmetic import r_longlong
  7. from rpython.rlib.objectmodel import import_from_mixin
  8. from pypy.module._io.interp_bufferedio import W_BufferedIOBase
  9. from pypy.module._io.interp_iobase import convert_size
  10. import sys
  11. class W_BytesIO(W_BufferedIOBase):
  12. import_from_mixin(RStringIO)
  13. def __init__(self, space):
  14. W_BufferedIOBase.__init__(self, space, add_to_autoflusher=False)
  15. self.init()
  16. def descr_init(self, space, w_initial_bytes=None):
  17. self.init()
  18. if not space.is_none(w_initial_bytes):
  19. self.write_w(space, w_initial_bytes)
  20. self.seek(0)
  21. def _check_closed(self, space, message=None):
  22. if self.is_closed():
  23. if message is None:
  24. message = "I/O operation on closed file"
  25. raise OperationError(space.w_ValueError, space.wrap(message))
  26. def read_w(self, space, w_size=None):
  27. self._check_closed(space)
  28. size = convert_size(space, w_size)
  29. return space.newbytes(self.read(size))
  30. def readline_w(self, space, w_limit=None):
  31. self._check_closed(space)
  32. limit = convert_size(space, w_limit)
  33. return space.newbytes(self.readline(limit))
  34. def read1_w(self, space, w_size):
  35. return self.read_w(space, w_size)
  36. def readinto_w(self, space, w_buffer):
  37. self._check_closed(space)
  38. rwbuffer = space.getarg_w('w*', w_buffer)
  39. size = rwbuffer.getlength()
  40. output = self.read(size)
  41. rwbuffer.setslice(0, output)
  42. return space.wrap(len(output))
  43. def write_w(self, space, w_data):
  44. self._check_closed(space)
  45. buf = space.buffer_w(w_data, space.BUF_CONTIG_RO).as_str()
  46. length = len(buf)
  47. if length <= 0:
  48. return space.wrap(0)
  49. self.write(buf)
  50. return space.wrap(length)
  51. def truncate_w(self, space, w_size=None):
  52. self._check_closed(space)
  53. pos = self.tell()
  54. if space.is_none(w_size):
  55. size = pos
  56. else:
  57. size = space.r_longlong_w(w_size)
  58. if size < 0:
  59. raise oefmt(space.w_ValueError, "negative size value")
  60. self.truncate(size)
  61. if size == pos:
  62. self.seek(0, 2)
  63. else:
  64. self.seek(pos)
  65. return space.wrap(size)
  66. def getvalue_w(self, space):
  67. self._check_closed(space)
  68. return space.newbytes(self.getvalue())
  69. def tell_w(self, space):
  70. self._check_closed(space)
  71. return space.wrap(self.tell())
  72. @unwrap_spec(pos=r_longlong, whence=int)
  73. def seek_w(self, space, pos, whence=0):
  74. self._check_closed(space)
  75. if whence == 0:
  76. if pos < 0:
  77. raise oefmt(space.w_ValueError, "negative seek value")
  78. elif whence == 1:
  79. if pos > sys.maxint - self.tell():
  80. raise oefmt(space.w_OverflowError, "new position too large")
  81. elif whence == 2:
  82. if pos > sys.maxint - self.getsize():
  83. raise oefmt(space.w_OverflowError, "new position too large")
  84. else:
  85. raise oefmt(space.w_ValueError,
  86. "whence must be between 0 and 2, not %d", whence)
  87. self.seek(pos, whence)
  88. return space.wrap(self.tell())
  89. def readable_w(self, space):
  90. self._check_closed(space)
  91. return space.w_True
  92. def writable_w(self, space):
  93. self._check_closed(space)
  94. return space.w_True
  95. def seekable_w(self, space):
  96. self._check_closed(space)
  97. return space.w_True
  98. def close_w(self, space):
  99. self.close()
  100. def closed_get_w(self, space):
  101. return space.wrap(self.is_closed())
  102. def getstate_w(self, space):
  103. self._check_closed(space)
  104. return space.newtuple([
  105. space.newbytes(self.getvalue()),
  106. space.wrap(self.tell()),
  107. self.getdict(space)])
  108. def setstate_w(self, space, w_state):
  109. self._check_closed(space)
  110. if space.len_w(w_state) != 3:
  111. raise oefmt(space.w_TypeError,
  112. "%T.__setstate__ argument should be 3-tuple, got %T",
  113. self, w_state)
  114. w_content, w_pos, w_dict = space.unpackiterable(w_state, 3)
  115. self.truncate(0)
  116. self.write_w(space, w_content)
  117. pos = space.int_w(w_pos)
  118. if pos < 0:
  119. raise oefmt(space.w_ValueError,
  120. "position value cannot be negative")
  121. self.seek(pos)
  122. if not space.is_w(w_dict, space.w_None):
  123. space.call_method(self.getdict(space), "update", w_dict)
  124. W_BytesIO.typedef = TypeDef(
  125. '_io.BytesIO', W_BufferedIOBase.typedef,
  126. __new__ = generic_new_descr(W_BytesIO),
  127. __init__ = interp2app(W_BytesIO.descr_init),
  128. read = interp2app(W_BytesIO.read_w),
  129. read1 = interp2app(W_BytesIO.read1_w),
  130. readline = interp2app(W_BytesIO.readline_w),
  131. readinto = interp2app(W_BytesIO.readinto_w),
  132. write = interp2app(W_BytesIO.write_w),
  133. truncate = interp2app(W_BytesIO.truncate_w),
  134. getvalue = interp2app(W_BytesIO.getvalue_w),
  135. seek = interp2app(W_BytesIO.seek_w),
  136. tell = interp2app(W_BytesIO.tell_w),
  137. readable = interp2app(W_BytesIO.readable_w),
  138. writable = interp2app(W_BytesIO.writable_w),
  139. seekable = interp2app(W_BytesIO.seekable_w),
  140. close = interp2app(W_BytesIO.close_w),
  141. closed = GetSetProperty(W_BytesIO.closed_get_w),
  142. __getstate__ = interp2app(W_BytesIO.getstate_w),
  143. __setstate__ = interp2app(W_BytesIO.setstate_w),
  144. )