def test_multiple_inheritance(self): class W_A(W_Root): a = 1 b = 2 class W_C(W_A): b = 3 W_A.typedef = typedef.TypeDef( "A", a=typedef.interp_attrproperty("a", cls=W_A), b=typedef.interp_attrproperty("b", cls=W_A), ) class W_B(W_Root): pass def standalone_method(space, w_obj): if isinstance(w_obj, W_A): return space.w_True else: return space.w_False W_B.typedef = typedef.TypeDef("B", c=interp2app(standalone_method)) W_C.typedef = typedef.TypeDef("C", ( W_A.typedef, W_B.typedef, )) w_o1 = self.space.wrap(W_C()) w_o2 = self.space.wrap(W_B()) w_c = self.space.gettypefor(W_C) w_b = self.space.gettypefor(W_B) w_a = self.space.gettypefor(W_A) assert w_c.mro_w == [ w_c, w_a, w_b, self.space.w_object, ] for w_tp in w_c.mro_w: assert self.space.isinstance_w(w_o1, w_tp) def assert_attr(w_obj, name, value): assert self.space.unwrap( self.space.getattr(w_obj, self.space.wrap(name))) == value def assert_method(w_obj, name, value): assert self.space.unwrap(self.space.call_method(w_obj, name)) == value assert_attr(w_o1, "a", 1) assert_attr(w_o1, "b", 3) assert_method(w_o1, "c", True) assert_method(w_o2, "c", False)
def test_with_new_with_allocate_instance_subclass(): py.test.skip("dealloction for now segfaults") def mytype_new(space, w_subtype, x): w_obj = space.allocate_instance(W_MyType, w_subtype) W_MyType.__init__(space.interp_w(W_MyType, w_obj), space, x) return w_obj mytype_new.unwrap_spec = [ObjSpace, W_Root, int] W_MyType.typedef = TypeDef("MyType", __new__ = interp2app(mytype_new), x = interp_attrproperty("x", W_MyType)) space = CPyObjSpace() def build(): w_type = space.gettypefor(W_MyType) return space.call_function(w_type, space.wrap(42)) fn = compile(build, [], annotatorpolicy = CPyAnnotatorPolicy(space)) res = fn(expected_extra_mallocs=1) assert type(res).__name__ == 'MyType' assert res.x == 42 class MyType2(type(res)): pass res2 = MyType2(42) assert type(res2) is MyType2 assert res2.x == 42 del res2 import gc gc.collect()
def test_with_new_with_allocate_instance(): def mytype_new(space, w_subtype, x): w_obj = space.allocate_instance(W_MyType, w_subtype) W_MyType.__init__(space.interp_w(W_MyType, w_obj), space, x) return w_obj mytype_new.unwrap_spec = [ObjSpace, W_Root, int] W_MyType.typedef = TypeDef("MyType", __new__ = interp2app(mytype_new), x = interp_attrproperty("x", W_MyType)) space = CPyObjSpace() def build(): w_type = space.gettypefor(W_MyType) return space.call_function(w_type, space.wrap(42)) w_obj = build() w_name = space.getattr(space.type(w_obj), space.wrap('__name__')) assert space.unwrap(w_name) == 'MyType' assert space.int_w(space.getattr(w_obj, space.wrap('x'))) == 42 fn = compile(build, [], annotatorpolicy = CPyAnnotatorPolicy(space)) res = fn(expected_extra_mallocs=1) assert type(res).__name__ == 'MyType' assert res.x == 42
def test_interp_attrproperty(): W_MyType.typedef = TypeDef("MyType", x = interp_attrproperty("x", W_MyType)) space = CPyObjSpace() def mytest(w_myobj): myobj = space.interp_w(W_MyType, w_myobj, can_be_None=True) if myobj is None: myobj = W_MyType(space) myobj.x = 1 myobj.x *= 2 w_myobj = space.wrap(myobj) w_x = space.wrap(myobj.x) return space.newtuple([w_myobj, w_x]) def fn(obj): w_obj = W_Object(obj) w_res = mytest(w_obj) return w_res.value fn.allow_someobjects = True fn = compile(fn, [object], annotatorpolicy = CPyAnnotatorPolicy(space)) res, x = fn(None, expected_extra_mallocs=1) assert type(res).__name__ == 'MyType' assert x == 2 assert res.x == 2 res2, x = fn(res, expected_extra_mallocs=1) assert res2 is res assert x == 4 assert res.x == 4
def patch_pypy(): # Patch-out virtualizables from PyPy so that translation works try: # TODO: what if first delattr fails? delattr(PyFrame, '_virtualizable_') delattr(PyPyJitDriver, 'virtualizables') except AttributeError: pass PyStdObjSpace.current_python_process = QuasiConstant(None, W_PythonProcess) PyStdObjSpace.getexecutioncontext = new_getexecutioncontext PyFrame.__init__ = __init__frame PyFrame.execute_frame = new_execute_frame PyFrame.block_handles_exception = block_handles_exception PyFrame.has_exception_handler = has_exception_handler PyFrame.handle_operation_error = new_handle_operation_error PyCode.__init__ = __init__pycode PyCode._immutable_fields_.extend(['_co_names[*]', 'co_source']) # Add app-level `co_source` to PyCode (this is hacky) w_code_type = py_space.fromcache(TypeCache).getorbuild(PyCode.typedef) w_code_type.dict_w['co_source'] = interp_attrproperty( 'co_source', cls=PyCode, wrapfn="newtext_or_none") PythonAstCompiler.compile = new_compile
def patch_unicodedb(): from pypy.module.unicodedata import unicodedb_4_1_0 from pypy.module.unicodedata.interp_ucd import UCD, methods, \ unichr_to_code_w from pypy.interpreter.gateway import W_Root, ObjSpace, NoneNotWrapped from unicodedb import _casefold from pypy.interpreter.typedef import TypeDef, interp_attrproperty from pypy.interpreter.gateway import interp2app def casefold(code): try: return _casefold[code] except KeyError: return [code] unicodedb_4_1_0.casefold = casefold # patch the app-level, so it's exposed def interp_casefold(self, space, w_unichr): code = unichr_to_code_w(space, w_unichr) return space.newlist([space.wrap(c) for c in casefold(code)]) unwrap_spec = ['self', ObjSpace, W_Root] UCD.casefold = interp_casefold methods['casefold'] = interp2app(UCD.casefold, unwrap_spec=unwrap_spec) UCD.typedef = TypeDef("unicodedata.UCD", __doc__ = "", unidata_version = interp_attrproperty('version', UCD), **methods)
def patch_unicodedb(): from pypy.module.unicodedata import unicodedb_4_1_0 from pypy.module.unicodedata.interp_ucd import UCD, methods, \ unichr_to_code_w from pypy.interpreter.gateway import W_Root, ObjSpace, NoneNotWrapped from unicodedb import _casefold from pypy.interpreter.typedef import TypeDef, interp_attrproperty from pypy.interpreter.gateway import interp2app def casefold(code): try: return _casefold[code] except KeyError: return [code] unicodedb_4_1_0.casefold = casefold # patch the app-level, so it's exposed def interp_casefold(self, space, w_unichr): code = unichr_to_code_w(space, w_unichr) return space.newlist([space.wrap(c) for c in casefold(code)]) unwrap_spec = ['self', ObjSpace, W_Root] UCD.casefold = interp_casefold methods['casefold'] = interp2app(UCD.casefold, unwrap_spec=unwrap_spec) UCD.typedef = TypeDef("unicodedata.UCD", __doc__="", unidata_version=interp_attrproperty('version', UCD), **methods)
def wrap_many(cls, names): d = {} for name in names: if "duration" in name: wrapfn = "newfloat" else: wrapfn = "newint" d[name] = interp_attrproperty(name, cls=cls, wrapfn=wrapfn) return d
def test_multiple_inheritance(self): class W_A(W_Root): a = 1 b = 2 class W_C(W_A): b = 3 W_A.typedef = typedef.TypeDef("A", a = typedef.interp_attrproperty("a", cls=W_A), b = typedef.interp_attrproperty("b", cls=W_A), ) class W_B(W_Root): pass def standalone_method(space, w_obj): if isinstance(w_obj, W_A): return space.w_True else: return space.w_False W_B.typedef = typedef.TypeDef("B", c = interp2app(standalone_method) ) W_C.typedef = typedef.TypeDef("C", (W_A.typedef, W_B.typedef,)) w_o1 = self.space.wrap(W_C()) w_o2 = self.space.wrap(W_B()) w_c = self.space.gettypefor(W_C) w_b = self.space.gettypefor(W_B) w_a = self.space.gettypefor(W_A) assert w_c.mro_w == [ w_c, w_a, w_b, self.space.w_object, ] for w_tp in w_c.mro_w: assert self.space.isinstance_w(w_o1, w_tp) def assert_attr(w_obj, name, value): assert self.space.unwrap(self.space.getattr(w_obj, self.space.wrap(name))) == value def assert_method(w_obj, name, value): assert self.space.unwrap(self.space.call_method(w_obj, name)) == value assert_attr(w_o1, "a", 1) assert_attr(w_o1, "b", 3) assert_method(w_o1, "c", True) assert_method(w_o2, "c", False)
set, del_, doc, cls=None, use_closure=True, tag="cpyext_2") # change the typedef name W_MemberDescr.typedef = TypeDef( "member_descriptor", __get__=interp2app(GetSetProperty.descr_property_get), __set__=interp2app(GetSetProperty.descr_property_set), __delete__=interp2app(GetSetProperty.descr_property_del), __name__=interp_attrproperty('name', cls=GetSetProperty, wrapfn="newtext_or_none"), __objclass__=GetSetProperty(GetSetProperty.descr_get_objclass), __doc__=interp_attrproperty('doc', cls=GetSetProperty, wrapfn="newtext_or_none"), ) assert not W_MemberDescr.typedef.acceptable_as_base_class # no __new__ @bootstrap_function def init_memberdescrobject(space): make_typedescr( W_MemberDescr.typedef, basestruct=cts.gettype('PyMemberDescrObject'), attach=memberdescr_attach,
W_SRE_Pattern.typedef = TypeDef( 'SRE_Pattern', __new__=interp2app(SRE_Pattern__new__), __copy__=interp2app(W_SRE_Pattern.cannot_copy_w), __deepcopy__=interp2app(W_SRE_Pattern.cannot_copy_w), __weakref__=make_weakref_descr(W_SRE_Pattern), findall=interp2app(W_SRE_Pattern.findall_w), finditer=interp2app(W_SRE_Pattern.finditer_w), match=interp2app(W_SRE_Pattern.match_w), scanner=interp2app(W_SRE_Pattern.finditer_w), # reuse finditer() search=interp2app(W_SRE_Pattern.search_w), split=interp2app(W_SRE_Pattern.split_w), sub=interp2app(W_SRE_Pattern.sub_w), subn=interp2app(W_SRE_Pattern.subn_w), flags=interp_attrproperty('flags', W_SRE_Pattern), groupindex=interp_attrproperty_w('w_groupindex', W_SRE_Pattern), groups=interp_attrproperty('num_groups', W_SRE_Pattern), pattern=interp_attrproperty_w('w_pattern', W_SRE_Pattern), ) # ____________________________________________________________ # # SRE_Match class class W_SRE_Match(Wrappable): flatten_cache = None def __init__(self, srepat, ctx): self.space = srepat.space
W_SRE_Pattern.typedef = TypeDef( 'SRE_Pattern', __new__=interp2app(SRE_Pattern__new__), __copy__=interp2app(W_SRE_Pattern.cannot_copy_w), __deepcopy__=interp2app(W_SRE_Pattern.cannot_copy_w), __weakref__=make_weakref_descr(W_SRE_Pattern), findall=interp2app(W_SRE_Pattern.findall_w), finditer=interp2app(W_SRE_Pattern.finditer_w), match=interp2app(W_SRE_Pattern.match_w), scanner=interp2app(W_SRE_Pattern.finditer_w), # reuse finditer() search=interp2app(W_SRE_Pattern.search_w), split=interp2app(W_SRE_Pattern.split_w), sub=interp2app(W_SRE_Pattern.sub_w), subn=interp2app(W_SRE_Pattern.subn_w), flags=interp_attrproperty('flags', W_SRE_Pattern, wrapfn="newint"), groupindex=interp_attrproperty_w('w_groupindex', W_SRE_Pattern), groups=interp_attrproperty('num_groups', W_SRE_Pattern, wrapfn="newint"), pattern=interp_attrproperty_w('w_pattern', W_SRE_Pattern), ) W_SRE_Pattern.typedef.acceptable_as_base_class = False # ____________________________________________________________ # # SRE_Match class class W_SRE_Match(W_Root): flatten_cache = None def __init__(self, srepat, ctx):
# I could not figure out a case in which flush() in CPython # doesn't simply return an empty string without complaining. return self.space.wrap("") flush.unwrap_spec = ['self', int] def Decompress___new__(space, w_subtype, wbits=rzlib.MAX_WBITS): """ Create a new Decompress and call its initializer. """ stream = space.allocate_instance(Decompress, w_subtype) stream = space.interp_w(Decompress, stream) Decompress.__init__(stream, space, wbits) return space.wrap(stream) Decompress___new__.unwrap_spec = [ObjSpace, W_Root, int] Decompress.typedef = TypeDef( 'Decompress', __new__=interp2app(Decompress___new__), decompress=interp2app(Decompress.decompress), flush=interp2app(Decompress.flush), unused_data=interp_attrproperty('unused_data', Decompress), unconsumed_tail=interp_attrproperty('unconsumed_tail', Decompress), __doc__="""decompressobj([wbits]) -- Return a decompressor object. Optional arg wbits is the window buffer size. """)
def build(self, space, r, stop): builder = Utf8StringBuilder(stop * 3) for i in range(stop): builder.append_code(r[i]) return space.newutf8(builder.build(), stop) methods = {} for methodname in """ _get_code lookup name decimal digit numeric category east_asian_width bidirectional combining mirrored decomposition normalize """.split(): methods[methodname] = interp2app(getattr(UCD, methodname)) UCD.typedef = TypeDef("unicodedata.UCD", __doc__="", unidata_version=interp_attrproperty('version', UCD, wrapfn="newtext"), **methods) ucd_3_2_0 = UCD(unicodedb_3_2_0) ucd_5_2_0 = UCD(unicodedb_5_2_0) ucd = ucd_5_2_0 # This is the default unicodedb used in various places: # - the unicode type # - the regular expression engine unicodedb = ucd._unicodedb
fmax = (r_longlong(1) << (self.bitsize - 1)) - 1 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('ctype', W_CField), offset=interp_attrproperty('offset', W_CField), bitshift=interp_attrproperty('bitshift', W_CField), bitsize=interp_attrproperty('bitsize', W_CField), ) W_CField.typedef.acceptable_as_base_class = False
self.name = name self.w_ffitype = w_ffitype self.offset = -1 def __repr__(self): return '<Field %s %s>' % (self.name, self.w_ffitype.name) @unwrap_spec(name=str) 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), ffitype = interp_attrproperty('w_ffitype', W_Field), offset = interp_attrproperty('offset', W_Field), ) # ============================================================================== 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
return space.wrap(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 space.wrap(Method(space, w_function, w_cls, space.w_None)) W_PyCFunctionObject.typedef = TypeDef( 'builtin_function_or_method', __call__ = interp2app(cfunction_descr_call), __doc__ = GetSetProperty(W_PyCFunctionObject.get_doc), __module__ = interp_attrproperty_w('w_module', cls=W_PyCFunctionObject), __name__ = interp_attrproperty('name', cls=W_PyCFunctionObject), ) W_PyCFunctionObject.typedef.acceptable_as_base_class = False W_PyCMethodObject.typedef = TypeDef( 'method', __get__ = interp2app(cmethod_descr_get), __call__ = interp2app(cmethod_descr_call), __name__ = interp_attrproperty('name', cls=W_PyCMethodObject), __objclass__ = interp_attrproperty_w('w_objclass', cls=W_PyCMethodObject), __repr__ = interp2app(W_PyCMethodObject.descr_method_repr), ) W_PyCMethodObject.typedef.acceptable_as_base_class = False W_PyCClassMethodObject.typedef = TypeDef( 'classmethod',
except rzlib.RZlibError: string = "" else: string, finished, unused_len = result self._save_unconsumed_input(data, finished, unused_len) return space.wrap(string) @unwrap_spec(wbits=int) def Decompress___new__(space, w_subtype, wbits=rzlib.MAX_WBITS): """ Create a new Decompress and call its initializer. """ stream = space.allocate_instance(Decompress, w_subtype) stream = space.interp_w(Decompress, stream) Decompress.__init__(stream, space, wbits) return space.wrap(stream) Decompress.typedef = TypeDef( 'Decompress', __new__ = interp2app(Decompress___new__), decompress = interp2app(Decompress.decompress), flush = interp2app(Decompress.flush), unused_data = interp_attrproperty('unused_data', Decompress), unconsumed_tail = interp_attrproperty('unconsumed_tail', Decompress), __doc__ = """decompressobj([wbits]) -- Return a decompressor object. Optional arg wbits is the window buffer size. """)
except OSError, e: raise wrap_oserror(space, e, exception_name='w_IOError') return w_size W_FileIO.typedef = TypeDef( 'FileIO', W_RawIOBase.typedef, __new__ = interp2app(W_FileIO.descr_new.im_func), __init__ = interp2app(W_FileIO.descr_init), __repr__ = interp2app(W_FileIO.repr_w), seek = interp2app(W_FileIO.seek_w), tell = interp2app(W_FileIO.tell_w), write = interp2app(W_FileIO.write_w), read = interp2app(W_FileIO.read_w), readinto = interp2app(W_FileIO.readinto_w), readall = interp2app(W_FileIO.readall_w), truncate = interp2app(W_FileIO.truncate_w), close = interp2app(W_FileIO.close_w), readable = interp2app(W_FileIO.readable_w), writable = interp2app(W_FileIO.writable_w), seekable = interp2app(W_FileIO.seekable_w), fileno = interp2app(W_FileIO.fileno_w), isatty = interp2app(W_FileIO.isatty_w), name = interp_member_w('w_name', cls=W_FileIO), closefd = interp_attrproperty('closefd', cls=W_FileIO), mode = GetSetProperty(W_FileIO.descr_get_mode), )
bind(addr) -- bind the socket to a local address close() -- close the socket connect(addr) -- connect the socket to a remote address connect_ex(addr) -- connect, return an error code instead of an exception dup() -- return a new socket object identical to the current one [*] fileno() -- return underlying file descriptor getpeername() -- return remote address [*] getsockname() -- return local address getsockopt(level, optname[, buflen]) -- get socket options gettimeout() -- return timeout or None listen(n) -- start listening for incoming connections makefile([mode, [bufsize]]) -- return a file object for the socket [*] recv(buflen[, flags]) -- receive data recvfrom(buflen[, flags]) -- receive data and sender's address sendall(data[, flags]) -- send all data send(data[, flags]) -- send data, may not send all of it sendto(data[, flags], addr) -- send data to a given address setblocking(0 | 1) -- set or clear the blocking I/O flag setsockopt(level, optname, value) -- set socket options settimeout(None | float) -- set or clear the timeout shutdown(how) -- shut down traffic in one or both directions [*] not available on all platforms!""", __new__ = descr_socket_new, __weakref__ = make_weakref_descr(W_RSocket), type = interp_attrproperty('type', W_RSocket), proto = interp_attrproperty('proto', W_RSocket), family = interp_attrproperty('family', W_RSocket), ** socketmethods )
if start + len(value) != stop: raise OperationError(space.w_ValueError, space.wrap("cannot resize array")) ll_buffer = self.ll_buffer for i in range(len(value)): ll_buffer[start + i] = value[i] W_ArrayInstance.typedef = TypeDef( 'ArrayInstance', __repr__=interp2app(W_ArrayInstance.descr_repr), __setitem__=interp2app(W_ArrayInstance.descr_setitem), __getitem__=interp2app(W_ArrayInstance.descr_getitem), __len__=interp2app(W_ArrayInstance.getlength), buffer=GetSetProperty(W_ArrayInstance.getbuffer), shape=interp_attrproperty('shape', W_ArrayInstance), free=interp2app(W_ArrayInstance.free), byptr=interp2app(W_ArrayInstance.byptr), itemaddress=interp2app(W_ArrayInstance.descr_itemaddress), ) W_ArrayInstance.typedef.acceptable_as_base_class = False class W_ArrayInstanceAutoFree(W_ArrayInstance): def __init__(self, space, shape, length): W_ArrayInstance.__init__(self, space, shape, length, 0) @rgc.must_be_light_finalizer def __del__(self): if self.ll_buffer: self._free()
Add a '+' to the mode to allow simultaneous reading and writing. If the buffering argument is given, 0 means unbuffered, 1 means line buffered, and larger numbers specify the buffer size. Add a 'U' to mode to open the file for input with universal newline support. Any line ending in the input file will be seen as a '\n' in Python. Also, a file so opened gains the attribute 'newlines'; the value for this attribute is one of None (no newline read yet), '\r', '\n', '\r\n' or a tuple containing all the newline types seen. Note: open() is an alias for file(). """, __new__ = interp2app(descr_file__new__), fdopen = interp2app(descr_file_fdopen, as_classmethod=True), name = interp_attrproperty_w('w_name', cls=W_File, doc="file name"), mode = interp_attrproperty('mode', cls=W_File, doc = "file mode ('r', 'U', 'w', 'a', " "possibly with 'b' or '+' added)"), encoding = interp_attrproperty('encoding', cls=W_File), errors = interp_attrproperty('errors', cls=W_File), closed = GetSetProperty(descr_file_closed, cls=W_File, doc="True if the file is closed"), newlines = GetSetProperty(descr_file_newlines, cls=W_File, doc="end-of-line convention used in this file"), softspace= GetSetProperty(descr_file_softspace, descr_file_setsoftspace, cls=W_File, doc="Support for 'print'."), __repr__ = interp2app(W_File.file__repr__), writelines = interp2app(W_File.file_writelines), __exit__ = interp2app(W_File.file__exit__), __weakref__ = make_weakref_descr(W_File),
start, stop = self.decodeslice(space, w_slice) value = space.str_w(w_value) if start + len(value) != stop: raise oefmt(space.w_ValueError, "cannot resize array") ll_buffer = self.ll_buffer for i in range(len(value)): ll_buffer[start + i] = value[i] W_ArrayInstance.typedef = TypeDef( 'ArrayInstance', __repr__ = interp2app(W_ArrayInstance.descr_repr), __setitem__ = interp2app(W_ArrayInstance.descr_setitem), __getitem__ = interp2app(W_ArrayInstance.descr_getitem), __len__ = interp2app(W_ArrayInstance.getlength), buffer = GetSetProperty(W_ArrayInstance.getbuffer), shape = interp_attrproperty('shape', W_ArrayInstance), free = interp2app(W_ArrayInstance.free), byptr = interp2app(W_ArrayInstance.byptr), itemaddress = interp2app(W_ArrayInstance.descr_itemaddress), ) W_ArrayInstance.typedef.acceptable_as_base_class = False class W_ArrayInstanceAutoFree(W_ArrayInstance): def __init__(self, space, shape, length): W_ArrayInstance.__init__(self, space, shape, length, 0) @rgc.must_be_light_finalizer def __del__(self): if self.ll_buffer: self._free()
if space.is_true(space.isinstance(w_shapeinfo, space.w_tuple)): w_size, w_alignment = space.fixedview(w_shapeinfo, expected_length=2) S = W_Structure(space, None, space.int_w(w_size), space.int_w(w_alignment)) else: fields = unpack_fields(space, w_shapeinfo) S = W_Structure(space, fields, 0, 0) return space.wrap(S) W_Structure.typedef = TypeDef( "Structure", __new__=interp2app(descr_new_structure), __call__=interp2app(W_Structure.descr_call), __repr__=interp2app(W_Structure.descr_repr), fromaddress=interp2app(W_Structure.fromaddress), size=interp_attrproperty("size", W_Structure), alignment=interp_attrproperty("alignment", W_Structure), fieldoffset=interp2app(W_Structure.descr_fieldoffset), size_alignment=interp2app(W_Structure.descr_size_alignment), ) W_Structure.typedef.acceptable_as_base_class = False def push_field(self, num, value): ptr = rffi.ptradd(self.ll_buffer, self.shape.ll_positions[num]) TP = lltype.typeOf(value) T = lltype.Ptr(rffi.CArray(TP)) rffi.cast(T, ptr)[0] = value push_field._annspecialcase_ = "specialize:argtype(2)"
W_SRE_Pattern.typedef = TypeDef( 'SRE_Pattern', __new__ = interp2app(SRE_Pattern__new__), __copy__ = interp2app(W_SRE_Pattern.cannot_copy_w), __deepcopy__ = interp2app(W_SRE_Pattern.cannot_copy_w), __weakref__ = make_weakref_descr(W_SRE_Pattern), findall = interp2app(W_SRE_Pattern.findall_w), finditer = interp2app(W_SRE_Pattern.finditer_w), match = interp2app(W_SRE_Pattern.match_w), scanner = interp2app(W_SRE_Pattern.finditer_w), # reuse finditer() search = interp2app(W_SRE_Pattern.search_w), split = interp2app(W_SRE_Pattern.split_w), sub = interp2app(W_SRE_Pattern.sub_w), subn = interp2app(W_SRE_Pattern.subn_w), flags = interp_attrproperty('flags', W_SRE_Pattern), groupindex = interp_attrproperty_w('w_groupindex', W_SRE_Pattern), groups = interp_attrproperty('num_groups', W_SRE_Pattern), pattern = interp_attrproperty_w('w_pattern', W_SRE_Pattern), ) # ____________________________________________________________ # # SRE_Match class class W_SRE_Match(Wrappable): flatten_cache = None def __init__(self, srepat, ctx): self.space = srepat.space self.srepat = srepat
def __init__(self, space): W_IOError.__init__(self, space) self.written = 0 @unwrap_spec(written=int) def descr_init(self, space, w_errno, w_strerror, written=0): W_IOError.descr_init(self, space, [w_errno, w_strerror]) self.written = written W_BlockingIOError.typedef = TypeDef( 'BlockingIOError', W_IOError.typedef, __doc__ = ("Exception raised when I/O would block on a non-blocking " "I/O stream"), __new__ = generic_new_descr(W_BlockingIOError), __init__ = interp2app(W_BlockingIOError.descr_init), characters_written = interp_attrproperty('written', W_BlockingIOError), ) DEFAULT_BUFFER_SIZE = 8 * 1024 @unwrap_spec(mode=str, buffering=int, encoding="str_or_None", errors="str_or_None", newline="str_or_None", closefd=bool) def open(space, w_file, mode="r", buffering=-1, encoding=None, errors=None, newline=None, closefd=True): from pypy.module._io.interp_bufferedio import (W_BufferedRandom, W_BufferedWriter, W_BufferedReader) if not (space.isinstance_w(w_file, space.w_basestring) or space.isinstance_w(w_file, space.w_int) or space.isinstance_w(w_file, space.w_long)):
if space.is_true(space.isinstance(w_shapeinfo, space.w_tuple)): w_size, w_alignment = space.fixedview(w_shapeinfo, expected_length=2) S = W_Structure(space, None, space.int_w(w_size), space.int_w(w_alignment), union) else: fields = unpack_fields(space, w_shapeinfo) S = W_Structure(space, fields, 0, 0, union, pack) return space.wrap(S) W_Structure.typedef = TypeDef( 'Structure', __new__ = interp2app(descr_new_structure), __call__ = interp2app(W_Structure.descr_call), __repr__ = interp2app(W_Structure.descr_repr), fromaddress = interp2app(W_Structure.fromaddress), size = interp_attrproperty('size', W_Structure), alignment = interp_attrproperty('alignment', W_Structure), fieldoffset = interp2app(W_Structure.descr_fieldoffset), fieldsize = interp2app(W_Structure.descr_fieldsize), size_alignment = interp2app(W_Structure.descr_size_alignment), get_ffi_type = interp2app(W_Structure.descr_get_ffi_type), ) W_Structure.typedef.acceptable_as_base_class = False def LOW_BIT(x): return x & 0xFFFF def NUM_BITS(x): return x >> 16 def BIT_MASK(x): return (1 << x) - 1
if bzerror != BZ_OK: _catch_bz2_error(self.space, bzerror) if rffi.getintfield(self.bzs, 'c_avail_in') == 0: break elif rffi.getintfield(self.bzs, 'c_avail_out') == 0: out.prepare_next_chunk() res = out.make_result_string() return self.space.wrap(res) W_BZ2Decompressor.typedef = TypeDef("BZ2Decompressor", __doc__ = W_BZ2Decompressor.__doc__, __new__ = interp2app(descr_decompressor__new__), unused_data = interp_attrproperty("unused_data", W_BZ2Decompressor), decompress = interp2app(W_BZ2Decompressor.decompress), ) @unwrap_spec(data='bufferstr', compresslevel=int) def compress(space, data, compresslevel=9): """compress(data [, compresslevel=9]) -> string Compress data in one shot. If you want to compress data sequentially, use an instance of BZ2Compressor instead. The compresslevel parameter, if given, must be a number between 1 and 9.""" if compresslevel < 1 or compresslevel > 9: raise OperationError(space.w_ValueError, space.wrap("compresslevel must be between 1 and 9"))
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
try: status = roci.OCIErrorGet( handle, 1, lltype.nullptr(roci.oratext.TO), codeptr, textbuf, BUFSIZE, handleType) if status != roci.OCI_SUCCESS: raise OperationError( get(space).w_InternalError, space.wrap("No Oracle error?")) self.code = codeptr[0] self.w_message = config.w_string(space, textbuf) finally: lltype.free(codeptr, flavor='raw') rffi.keep_buffer_alive_until_here(textbuf, text) if config.WITH_UNICODE: # XXX remove double zeros at the end pass def desc_str(self): return self.w_message W_Error.typedef = TypeDef( 'Error', __str__ = interp2app(W_Error.desc_str), code = interp_attrproperty('code', W_Error), message = interp_attrproperty_w('w_message', W_Error))
when opened for writing or appending; it will be truncated when opened for writing. Add a 'b' to the mode for binary files. Add a '+' to the mode to allow simultaneous reading and writing. If the buffering argument is given, 0 means unbuffered, 1 means line buffered, and larger numbers specify the buffer size. Add a 'U' to mode to open the file for input with universal newline support. Any line ending in the input file will be seen as a '\n' in Python. Also, a file so opened gains the attribute 'newlines'; the value for this attribute is one of None (no newline read yet), '\r', '\n', '\r\n' or a tuple containing all the newline types seen. Note: open() is an alias for file(). """, __new__=interp2app(descr_file__new__), fdopen=interp2app(descr_file_fdopen, as_classmethod=True), name=interp_attrproperty('name', cls=W_File, doc="file name"), mode=interp_attrproperty('mode', cls=W_File, doc="file mode ('r', 'U', 'w', 'a', " "possibly with 'b' or '+' added)"), encoding=interp_attrproperty('encoding', cls=W_File), closed=GetSetProperty(descr_file_closed, cls=W_File, doc="True if the file is closed"), newlines=GetSetProperty(descr_file_newlines, cls=W_File, doc="end-of-line convention used in this file"), softspace=GetSetProperty(descr_file_softspace, descr_file_setsoftspace, cls=W_File, doc="Support for 'print'."),
def is_void(self): return self is app_types.void def is_struct(self): return libffi.types.is_struct(self.get_ffitype()) def is_char_p(self): return self is app_types.char_p def is_unichar_p(self): return self is app_types.unichar_p W_FFIType.typedef = TypeDef( 'FFIType', name = interp_attrproperty('name', W_FFIType), __repr__ = interp2app(W_FFIType.repr), deref_pointer = interp2app(W_FFIType.descr_deref_pointer), sizeof = interp2app(W_FFIType.descr_sizeof), ) def build_ffi_types(): types = [ # note: most of the type name directly come from the C equivalent, # with the exception of bytes: in C, ubyte and char are equivalent, # but for here the first expects a number while the second a 1-length # string W_FFIType('slong', libffi.types.slong), W_FFIType('sint', libffi.types.sint), W_FFIType('sshort', libffi.types.sshort),
self.environment.checkForError( status, "ObjectType_Describe(): get attribute param descriptor") attribute = W_ObjectAttribute(connection, paramptr[0]) finally: lltype.free(paramptr, flavor='raw') self.attributes.append(attribute) self.attributesByName[attribute.name] = attribute def get_attributes(self, space): return space.newlist([space.wrap(attr) for attr in self.attributes]) W_ObjectType.typedef = TypeDef( 'ObjectType', schema = interp_attrproperty('schema', W_ObjectType), name = interp_attrproperty('name', W_ObjectType), attributes = GetSetProperty(W_ObjectType.get_attributes), ) class W_ObjectAttribute(Wrappable): def __init__(self, connection, param): self.initialize(connection, param) def initialize(self, connection, param): # determine the name of the attribute nameptr = lltype.malloc(rffi.CArrayPtr(roci.oratext).TO, 1, flavor='raw') lenptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO, 1, flavor='raw') try:
return space.wrap(self.string_position) def fset_string_position(space, self, w_value): self.start = space.int_w(w_value) def get_char_ord(self, p): raise NotImplementedError getset_start = GetSetProperty(W_State.fget_start, W_State.fset_start, cls=W_State) getset_string_position = GetSetProperty(W_State.fget_string_position, W_State.fset_string_position, cls=W_State) W_State.typedef = TypeDef("W_State", string = interp_attrproperty_w("w_string", W_State), start = getset_start, end = interp_attrproperty("end", W_State), string_position = getset_string_position, pos = interp_attrproperty("pos", W_State), lastindex = interp_attrproperty("lastindex", W_State), reset = interp2app(W_State.w_reset), create_regs = interp2app(W_State.w_create_regs), ) class W_StringState(W_State): if THREE_VERSIONS_OF_CORE: rsre.insert_sre_methods(locals(), 'str') def unwrap_object(self): self.string = self.space.str_w(self.w_string) return len(self.string)
def __init__(self, space): W_IOError.__init__(self, space) self.written = 0 @unwrap_spec(written=int) def descr_init(self, space, w_errno, w_strerror, written=0): W_IOError.descr_init(self, space, [w_errno, w_strerror]) self.written = written W_BlockingIOError.typedef = TypeDef( 'BlockingIOError', W_IOError.typedef, __doc__ = ("Exception raised when I/O would block on a non-blocking " "I/O stream"), __new__ = generic_new_descr(W_BlockingIOError), __init__ = interp2app(W_BlockingIOError.descr_init), characters_written = interp_attrproperty('written', W_BlockingIOError, wrapfn="newint"), ) DEFAULT_BUFFER_SIZE = 8 * 1024 @unwrap_spec(mode='text', buffering=int, encoding="text_or_none", errors="text_or_none", newline="text_or_none", closefd=bool) def open(space, w_file, mode="r", buffering=-1, encoding=None, errors=None, newline=None, closefd=True): from pypy.module._io.interp_bufferedio import (W_BufferedRandom, W_BufferedWriter, W_BufferedReader) if not (space.isinstance_w(w_file, space.w_basestring) or space.isinstance_w(w_file, space.w_int) or space.isinstance_w(w_file, space.w_long)):
W_Dtype.typedef = TypeDef("dtype", __module__ = "numpypy", __new__ = interp2app(descr__new__), __str__= interp2app(W_Dtype.descr_str), __repr__ = interp2app(W_Dtype.descr_repr), __eq__ = interp2app(W_Dtype.descr_eq), __ne__ = interp2app(W_Dtype.descr_ne), __getitem__ = interp2app(W_Dtype.descr_getitem), __len__ = interp2app(W_Dtype.descr_len), __reduce__ = interp2app(W_Dtype.descr_reduce), __setstate__ = interp2app(W_Dtype.descr_setstate), type = interp_attrproperty_w("w_box_type", cls=W_Dtype), kind = interp_attrproperty("kind", cls=W_Dtype), char = interp_attrproperty("char", cls=W_Dtype), num = interp_attrproperty("num", cls=W_Dtype), byteorder = interp_attrproperty("byteorder", cls=W_Dtype), itemsize = GetSetProperty(W_Dtype.descr_get_itemsize), alignment = GetSetProperty(W_Dtype.descr_get_alignment), subdtype = GetSetProperty(W_Dtype.descr_get_subdtype), str = GetSetProperty(W_Dtype.descr_get_str), name = interp_attrproperty("name", cls=W_Dtype), base = GetSetProperty(W_Dtype.descr_get_base), shape = GetSetProperty(W_Dtype.descr_get_shape), isnative = GetSetProperty(W_Dtype.descr_get_isnative), fields = GetSetProperty(W_Dtype.descr_get_fields), names = GetSetProperty(W_Dtype.descr_get_names), )
def is_namespace(self): return self.space.w_False def get_base_names(self): bases = [] num_bases = capi.c_num_bases(self) for i in range(num_bases): base_name = capi.c_base_name(self, i) bases.append(self.space.wrap(base_name)) return self.space.newlist(bases) W_CPPClass.typedef = TypeDef( "CPPClass", type_name=interp_attrproperty("name", W_CPPClass), get_base_names=interp2app(W_CPPClass.get_base_names), get_method_names=interp2app(W_CPPClass.get_method_names), get_overload=interp2app(W_CPPClass.get_overload, unwrap_spec=["self", str]), get_datamember_names=interp2app(W_CPPClass.get_datamember_names), get_datamember=interp2app(W_CPPClass.get_datamember, unwrap_spec=["self", str]), is_namespace=interp2app(W_CPPClass.is_namespace), dispatch=interp2app(W_CPPClass.dispatch, unwrap_spec=["self", str, str]), ) W_CPPClass.typedef.acceptable_as_base_class = False class W_ComplexCPPClass(W_CPPClass): _immutable_ = True def get_cppthis(self, cppinstance, calling_scope):
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 space.wrap(Method(space, w_function, w_cls, space.w_None)) W_PyCFunctionObject.typedef = TypeDef( 'builtin_function_or_method', __call__=interp2app(cfunction_descr_call), __doc__=GetSetProperty(W_PyCFunctionObject.get_doc), __module__=interp_attrproperty_w('w_module', cls=W_PyCFunctionObject), __name__=interp_attrproperty('name', cls=W_PyCFunctionObject), ) W_PyCFunctionObject.typedef.acceptable_as_base_class = False W_PyCMethodObject.typedef = TypeDef( 'method', __get__=interp2app(cmethod_descr_get), __call__=interp2app(cmethod_descr_call), __name__=interp_attrproperty('name', cls=W_PyCMethodObject), __objclass__=interp_attrproperty_w('w_objclass', cls=W_PyCMethodObject), __repr__=interp2app(W_PyCMethodObject.descr_method_repr), ) W_PyCMethodObject.typedef.acceptable_as_base_class = False W_PyCClassMethodObject.typedef = TypeDef( 'classmethod',
] dtypes_by_alias = unrolling_iterable([ (alias, dtype) for dtype in ALL_DTYPES for alias in dtype.aliases ]) dtypes_by_apptype = unrolling_iterable([ (apptype, dtype) for dtype in ALL_DTYPES for apptype in dtype.applevel_types ]) dtypes_by_num_bytes = unrolling_iterable(sorted([ (dtype.num_bytes, dtype) for dtype in ALL_DTYPES ])) W_Dtype.typedef = TypeDef("dtype", __module__ = "numpy", __new__ = interp2app(W_Dtype.descr__new__.im_func), __repr__ = interp2app(W_Dtype.descr_repr), __str__ = interp2app(W_Dtype.descr_str), num = interp_attrproperty("num", cls=W_Dtype), kind = interp_attrproperty("kind", cls=W_Dtype), itemsize = interp_attrproperty("num_bytes", cls=W_Dtype), shape = GetSetProperty(W_Dtype.descr_get_shape), ) W_Dtype.typedef.acceptable_as_base_class = False
W_FileIO.typedef = TypeDef( '_io.FileIO', W_RawIOBase.typedef, __new__ = interp2app(W_FileIO.descr_new.im_func), __init__ = interp2app(W_FileIO.descr_init), __repr__ = interp2app(W_FileIO.repr_w), __getstate__ = interp2app(W_FileIO.getstate_w), seek = interp2app(W_FileIO.seek_w), tell = interp2app(W_FileIO.tell_w), write = interp2app(W_FileIO.write_w), read = interp2app(W_FileIO.read_w), readinto = interp2app(W_FileIO.readinto_w), readall = interp2app(W_FileIO.readall_w), truncate = interp2app(W_FileIO.truncate_w), close = interp2app(W_FileIO.close_w), readable = interp2app(W_FileIO.readable_w), writable = interp2app(W_FileIO.writable_w), seekable = interp2app(W_FileIO.seekable_w), fileno = interp2app(W_FileIO.fileno_w), isatty = interp2app(W_FileIO.isatty_w), _dealloc_warn = interp2app(W_FileIO._dealloc_warn_w), name = interp_member_w('w_name', cls=W_FileIO), closefd = interp_attrproperty( 'closefd', cls=W_FileIO, doc="True if the file descriptor will be closed"), mode = GetSetProperty(W_FileIO.descr_get_mode, doc="String giving the file mode"), )
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(cfunction_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), ) W_PyCMethodObject.typedef.acceptable_as_base_class = False W_PyCClassMethodObject.typedef = TypeDef(
res_dtype, w_lhs, w_rhs, out) w_lhs.add_invalidates(w_res) w_rhs.add_invalidates(w_res) if out: w_res.get_concrete() return w_res W_Ufunc.typedef = TypeDef("ufunc", __module__ = "numpypy", __call__ = interp2app(W_Ufunc.descr_call), __repr__ = interp2app(W_Ufunc.descr_repr), identity = GetSetProperty(W_Ufunc.descr_get_identity), nin = interp_attrproperty("argcount", cls=W_Ufunc), reduce = interp2app(W_Ufunc.descr_reduce), ) def find_binop_result_dtype(space, dt1, dt2, promote_to_float=False, promote_bools=False, int_only=False): # dt1.num should be <= dt2.num if dt1.num > dt2.num: dt1, dt2 = dt2, dt1 if int_only and (not dt1.is_int_type() or not dt2.is_int_type()): raise OperationError(space.w_TypeError, space.wrap("Unsupported types")) # Some operations promote op(bool, bool) to return int8, rather than bool if promote_bools and (dt1.kind == dt2.kind == interp_dtype.BOOLLTR): return interp_dtype.get_dtype_cache(space).w_int8dtype
def is_void(self): return self is app_types.void def is_struct(self): return libffi.types.is_struct(self.get_ffitype()) def is_char_p(self): return self is app_types.char_p def is_unichar_p(self): return self is app_types.unichar_p W_FFIType.typedef = TypeDef( 'FFIType', name=interp_attrproperty('name', W_FFIType), __repr__=interp2app(W_FFIType.repr), deref_pointer=interp2app(W_FFIType.descr_deref_pointer), sizeof=interp2app(W_FFIType.descr_sizeof), ) def build_ffi_types(): types = [ # note: most of the type name directly come from the C equivalent, # with the exception of bytes: in C, ubyte and char are equivalent, # but for here the first expects a number while the second a 1-length # string W_FFIType('slong', libffi.types.slong), W_FFIType('sint', libffi.types.sint), W_FFIType('sshort', libffi.types.sshort),
if not self.w_calls: calls_repr = "None" else: calls_repr = space.text_w(space.repr(self.w_calls)) return space.newtext('("%s", %d, %d, %f, %f, %s)' % (frame_repr, self.callcount, self.reccallcount, self.tt, self.it, calls_repr)) def get_code(self, space): return returns_code(space, self.frame) W_StatsEntry.typedef = TypeDef( '_lsprof.StatsEntry', code=GetSetProperty(W_StatsEntry.get_code), callcount=interp_attrproperty('callcount', W_StatsEntry, wrapfn="newint"), reccallcount=interp_attrproperty('reccallcount', W_StatsEntry, wrapfn="newint"), inlinetime=interp_attrproperty('it', W_StatsEntry, wrapfn="newfloat"), totaltime=interp_attrproperty('tt', W_StatsEntry, wrapfn="newfloat"), calls=GetSetProperty(W_StatsEntry.get_calls), __repr__=interp2app(W_StatsEntry.repr), ) class W_StatsSubEntry(W_Root): def __init__(self, space, frame, callcount, reccallcount, tt, it): self.frame = frame self.callcount = callcount self.reccallcount = reccallcount
status = roci.OCIAttrGet( self.handle, roci.OCI_HTYPE_SPOOL, rffi.cast(roci.dvoidp, valueptr), lltype.nullptr(roci.Ptr(roci.ub4).TO), oci_attr_code, self.environment.errorHandle) return space.wrap(valueptr[0]) finally: lltype.free(valueptr, flavor='raw') return GetSetProperty(fget, cls=W_SessionPool) W_SessionPool.typedef = TypeDef( "SessionPool", __new__ = interp2app(W_SessionPool.descr_new.im_func), acquire = interp2app(W_SessionPool.acquire), release = interp2app(W_SessionPool.release), drop = interp2app(W_SessionPool.drop), username = interp_attrproperty_w('w_username', W_SessionPool), password = interp_attrproperty_w('w_password', W_SessionPool), tnsentry = interp_attrproperty_w('w_tnsentry', W_SessionPool), min = interp_attrproperty('minSessions', W_SessionPool), max = interp_attrproperty('maxSessions', W_SessionPool), increment = interp_attrproperty('sessionIncrement', W_SessionPool), homogeneous = interp_attrproperty('homogeneous', W_SessionPool), opened = computedProperty(roci.OCI_ATTR_SPOOL_OPEN_COUNT, roci.ub4), busy = computedProperty(roci.OCI_ATTR_SPOOL_BUSY_COUNT, roci.ub4), timeout = computedProperty(roci.OCI_ATTR_SPOOL_TIMEOUT, roci.ub4), getmode = computedProperty(roci.OCI_ATTR_SPOOL_GETMODE, roci.ub1), )
def repr(self, space): frame_repr = space.str_w(space.repr(self.frame)) if not self.w_calls: calls_repr = "None" else: calls_repr = space.str_w(space.repr(self.w_calls)) return space.wrap('("%s", %d, %d, %f, %f, %s)' % (frame_repr, self.callcount, self.reccallcount, self.tt, self.it, calls_repr)) repr.unwrap_spec = ['self', ObjSpace] W_StatsEntry.typedef = TypeDef( 'StatsEntry', code=interp_attrproperty('frame', W_StatsEntry), callcount=interp_attrproperty('callcount', W_StatsEntry), reccallcount=interp_attrproperty('reccallcount', W_StatsEntry), inlinetime=interp_attrproperty('it', W_StatsEntry), totaltime=interp_attrproperty('tt', W_StatsEntry), calls=GetSetProperty(W_StatsEntry.get_calls), __repr__=interp2app(W_StatsEntry.repr), ) class W_StatsSubEntry(Wrappable): def __init__(self, space, frame, callcount, reccallcount, tt, it): self.frame = frame self.callcount = callcount self.reccallcount = reccallcount self.it = it
w_size, w_alignment = space.fixedview(w_shapeinfo, expected_length=2) S = W_Structure(space, None, space.int_w(w_size), space.int_w(w_alignment), union) else: fields = unpack_fields(space, w_shapeinfo) S = W_Structure(space, fields, 0, 0, union, pack) return space.wrap(S) W_Structure.typedef = TypeDef( 'Structure', __new__=interp2app(descr_new_structure), __call__=interp2app(W_Structure.descr_call), __repr__=interp2app(W_Structure.descr_repr), fromaddress=interp2app(W_Structure.fromaddress), size=interp_attrproperty('size', W_Structure), alignment=interp_attrproperty('alignment', W_Structure), fieldoffset=interp2app(W_Structure.descr_fieldoffset), fieldsize=interp2app(W_Structure.descr_fieldsize), size_alignment=interp2app(W_Structure.descr_size_alignment), get_ffi_type=interp2app(W_Structure.descr_get_ffi_type), ) W_Structure.typedef.acceptable_as_base_class = False def LOW_BIT(x): return x & 0xFFFF def NUM_BITS(x): return x >> 16
def get_char_ord(self, p): raise NotImplementedError getset_start = GetSetProperty(W_State.fget_start, W_State.fset_start, cls=W_State) getset_string_position = GetSetProperty(W_State.fget_string_position, W_State.fset_string_position, cls=W_State) W_State.typedef = TypeDef( "W_State", string=interp_attrproperty_w("w_string", W_State), start=getset_start, end=interp_attrproperty("end", W_State), string_position=getset_string_position, pos=interp_attrproperty("pos", W_State), lastindex=interp_attrproperty("lastindex", W_State), reset=interp2app(W_State.w_reset), create_regs=interp2app(W_State.w_create_regs), ) class W_StringState(W_State): if THREE_VERSIONS_OF_CORE: rsre.insert_sre_methods(locals(), 'str') def unwrap_object(self): self.string = self.space.str_w(self.w_string) return len(self.string)
optional \"dialect\" parameter is discussed below. The function also accepts optional keyword arguments which override settings provided by the dialect. 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), __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() @unwrap_spec(new_limit=int)
'_io.FileIO', W_RawIOBase.typedef, __new__ = interp2app(W_FileIO.descr_new.im_func), __init__ = interp2app(W_FileIO.descr_init), __repr__ = interp2app(W_FileIO.repr_w), __getstate__ = interp2app(W_FileIO.getstate_w), seek = interp2app(W_FileIO.seek_w), tell = interp2app(W_FileIO.tell_w), write = interp2app(W_FileIO.write_w), read = interp2app(W_FileIO.read_w), readinto = interp2app(W_FileIO.readinto_w), readall = interp2app(W_FileIO.readall_w), truncate = interp2app(W_FileIO.truncate_w), close = interp2app(W_FileIO.close_w), readable = interp2app(W_FileIO.readable_w), writable = interp2app(W_FileIO.writable_w), seekable = interp2app(W_FileIO.seekable_w), fileno = interp2app(W_FileIO.fileno_w), isatty = interp2app(W_FileIO.isatty_w), _dealloc_warn = interp2app(W_FileIO._dealloc_warn_w), name = interp_member_w('w_name', cls=W_FileIO), closefd = interp_attrproperty( 'closefd', cls=W_FileIO, wrapfn="newbool", doc="True if the file descriptor will be closed"), mode = GetSetProperty(W_FileIO.descr_get_mode, doc="String giving the file mode"), _blksize = GetSetProperty(W_FileIO.get_blksize), )
If the buffering argument is given, 0 means unbuffered, 1 means line buffered, and larger numbers specify the buffer size. Add a 'U' to mode to open the file for input with universal newline support. Any line ending in the input file will be seen as a '\n' in Python. Also, a file so opened gains the attribute 'newlines'; the value for this attribute is one of None (no newline read yet), '\r', '\n', '\r\n' or a tuple containing all the newline types seen. Note: open() is an alias for file(). """, __new__=interp2app(descr_file__new__), fdopen=interp2app(descr_file_fdopen, as_classmethod=True), name=interp_attrproperty_w('w_name', cls=W_File, doc="file name"), mode=interp_attrproperty('mode', cls=W_File, doc="file mode ('r', 'U', 'w', 'a', " "possibly with 'b' or '+' added)", wrapfn="newtext"), encoding=interp_attrproperty('encoding', cls=W_File, wrapfn="newtext_or_none"), errors=interp_attrproperty('errors', cls=W_File, wrapfn="newtext_or_none"), closed=GetSetProperty(descr_file_closed, cls=W_File, doc="True if the file is closed"), newlines=GetSetProperty(descr_file_newlines, cls=W_File, doc="end-of-line convention used in this file"), softspace=GetSetProperty(descr_file_softspace, descr_file_setsoftspace, cls=W_File,
Create a new Decompress and call its initializer. """ w_stream = space.allocate_instance(Decompress, w_subtype) w_stream = space.interp_w(Decompress, w_stream) try: stream = rzlib.inflateInit(wbits) except rzlib.RZlibError as e: raise zlib_error(space, e.msg) except ValueError: raise oefmt(space.w_ValueError, "Invalid initialization option") Decompress.__init__(w_stream, space, stream, '', '') return w_stream Decompress.typedef = TypeDef( 'Decompress', __new__=interp2app(Decompress___new__), copy=interp2app(Decompress.copy), decompress=interp2app(Decompress.decompress), flush=interp2app(Decompress.flush), unused_data=interp_attrproperty('unused_data', Decompress, wrapfn="newbytes"), unconsumed_tail=interp_attrproperty('unconsumed_tail', Decompress, wrapfn="newbytes"), __doc__="""decompressobj([wbits]) -- Return a decompressor object. Optional arg wbits is the window buffer size. """)
if _MS_WINDOWS: name_spec = 'fsencode' else: name_spec = 'fsencode_or_none' @unwrap_spec(name=name_spec) def descr_new_cdll(space, w_type, name): cdll = open_cdll(space, name) return W_CDLL(space, name, cdll) W_CDLL.typedef = TypeDef( 'CDLL', __new__ = interp2app(descr_new_cdll), ptr = interp2app(W_CDLL.ptr), getaddressindll = interp2app(W_CDLL.getaddressindll), name = interp_attrproperty('name', W_CDLL, wrapfn="newtext_or_none"), __doc__ = """ C Dynamically loaded library use CDLL(libname) to create a handle to a C library (the argument is processed the same way as dlopen processes it). On such a library you can call: lib.ptr(func_name, argtype_list, restype) where argtype_list is a list of single characters and restype is a single character. The character meanings are more or less the same as in the struct module, except that s has trailing \x00 added, while p is considered a raw buffer.""" # xxx fix doc ) unroll_letters_for_numbers = unrolling_iterable(TYPEMAP_NUMBER_LETTERS) unroll_letters_for_floats = unrolling_iterable(TYPEMAP_FLOAT_LETTERS) _ARM = rffi_platform.getdefined('__arm__', '')
prev_combining = 0 current = next continue result[next_insert] = next next_insert += 1 if next_combining > prev_combining: prev_combining = next_combining result[starter_pos] = current return space.wrap(u''.join([unichr(i) for i in result[:next_insert]])) methods = {} for methodname in """ _get_code lookup name decimal digit numeric category east_asian_width bidirectional combining mirrored decomposition normalize """.split(): methods[methodname] = interp2app(getattr(UCD, methodname)) UCD.typedef = TypeDef("unicodedata.UCD", __doc__ = "", unidata_version = interp_attrproperty('version', UCD), **methods) ucd_3_2_0 = UCD(unicodedb_3_2_0) ucd_5_2_0 = UCD(unicodedb_5_2_0) ucd = ucd_5_2_0
if sig == llapi.HPyFunc_VARARGS: return self.call_varargs_kw(space, h_self, __args__, skip_args, has_keywords=False) else: # shouldn't happen! raise oefmt(space.w_RuntimeError, "unknown calling convention") W_ExtensionFunction.typedef = TypeDef( 'extension_function', __call__=interp2app(W_ExtensionFunction.descr_call), __doc__=interp_attrproperty('doc', cls=W_ExtensionFunction, wrapfn="newtext_or_none"), ) W_ExtensionFunction.typedef.acceptable_as_base_class = False class W_ExtensionMethod(W_ExtensionFunction): def __init__(self, space, name, sig, doc, cfuncptr, w_objclass): W_ExtensionFunction.__init__(self, space, name, sig, doc, cfuncptr, space.w_None) self.w_objclass = w_objclass def descr_call(self, space, __args__): # XXX: basically a copy of cpyext's W_PyCMethodObject.descr_call() if len(__args__.arguments_w) == 0: w_objclass = self.w_objclass
def _get_escapechar(space, dialect): if dialect.escapechar == '\0': return space.w_None return space.newtext(dialect.escapechar) def _get_quotechar(space, dialect): if dialect.quotechar == '\0': return space.w_None return space.newtext(dialect.quotechar) W_Dialect.typedef = TypeDef( '_csv.Dialect', __new__ = interp2app(W_Dialect___new__), delimiter = interp_attrproperty('delimiter', W_Dialect, wrapfn='newtext'), doublequote = interp_attrproperty('doublequote', W_Dialect, wrapfn='newbool'), escapechar = GetSetProperty(_get_escapechar, cls=W_Dialect), lineterminator = interp_attrproperty('lineterminator', W_Dialect, wrapfn='newtext'), quotechar = GetSetProperty(_get_quotechar, cls=W_Dialect), quoting = interp_attrproperty('quoting', W_Dialect, wrapfn='newint'), skipinitialspace = interp_attrproperty('skipinitialspace', W_Dialect, wrapfn='newbool'), strict = interp_attrproperty('strict', W_Dialect, wrapfn='newbool'), __doc__ = """CSV dialect
return space.wrap(subdialect) def _get_escapechar(space, dialect): if dialect.escapechar == '\0': return space.w_None return space.wrap(dialect.escapechar) def _get_quotechar(space, dialect): if dialect.quotechar == '\0': return space.w_None return space.wrap(dialect.quotechar) W_Dialect.typedef = TypeDef( '_csv.Dialect', __new__=interp2app(W_Dialect___new__), delimiter=interp_attrproperty('delimiter', W_Dialect), doublequote=interp_attrproperty('doublequote', W_Dialect), escapechar=GetSetProperty(_get_escapechar, cls=W_Dialect), lineterminator=interp_attrproperty('lineterminator', W_Dialect), quotechar=GetSetProperty(_get_quotechar, cls=W_Dialect), quoting=interp_attrproperty('quoting', W_Dialect), skipinitialspace=interp_attrproperty('skipinitialspace', W_Dialect), strict=interp_attrproperty('strict', W_Dialect), __doc__="""CSV dialect The Dialect type records CSV parsing and generation options. """)
fmin = -(r_longlong(1) << (self.bitsize - 1)) fmax = (r_longlong(1) << (self.bitsize - 1)) - 1 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('ctype', W_CField), offset = interp_attrproperty('offset', W_CField), bitshift = interp_attrproperty('bitshift', W_CField), bitsize = interp_attrproperty('bitsize', W_CField), ) W_CField.typedef.acceptable_as_base_class = False