W_CData.typedef = TypeDef( '_cffi_backend.CData', __module__ = '_cffi_backend', __name__ = '<cdata>', __repr__ = interp2app(W_CData.repr), __bool__ = interp2app(W_CData.bool), __int__ = interp2app(W_CData.int), __long__ = interp2app(W_CData.long), __float__ = interp2app(W_CData.float), __len__ = interp2app(W_CData.len), __lt__ = interp2app(W_CData.lt), __le__ = interp2app(W_CData.le), __eq__ = interp2app(W_CData.eq), __ne__ = interp2app(W_CData.ne), __gt__ = interp2app(W_CData.gt), __ge__ = interp2app(W_CData.ge), __hash__ = interp2app(W_CData.hash), __getitem__ = interp2app(W_CData.getitem), __setitem__ = interp2app(W_CData.setitem), __add__ = interp2app(W_CData.add), __radd__ = interp2app(W_CData.add), __sub__ = interp2app(W_CData.sub), __getattr__ = interp2app(W_CData.getattr), __setattr__ = interp2app(W_CData.setattr), __call__ = interp2app(W_CData.call), __iter__ = interp2app(W_CData.iter), __weakref__ = make_weakref_descr(W_CData), ) W_CData.typedef.acceptable_as_base_class = False
def descr_typecode(space, self): return space.wrap(self.typecode) class W_ArrayBase(W_Object): @staticmethod def register(typeorder): typeorder[W_ArrayBase] = [] W_ArrayBase.typedef = StdTypeDef( 'array', __new__ = interp2app(w_array), __module__ = 'array', itemsize = GetSetProperty(descr_itemsize), typecode = GetSetProperty(descr_typecode), __weakref__ = make_weakref_descr(W_ArrayBase), ) W_ArrayBase.typedef.registermethods(globals()) class TypeCode(object): def __init__(self, itemtype, unwrap, canoverflow=False, signed=False): self.itemtype = itemtype self.bytes = rffi.sizeof(itemtype) #self.arraytype = lltype.GcArray(itemtype) self.arraytype = lltype.Array(itemtype, hints={'nolength': True}) self.unwrap = unwrap self.signed = signed self.canoverflow = canoverflow self.w_class = None
# so that we don't need to do it here. Creating new SRE_Pattern # objects all the time would be bad for the JIT, which relies on the # identity of the CompiledPattern() object. srepat.code = rsre_core.CompiledPattern(code, flags) srepat.num_groups = groups srepat.w_groupindex = w_groupindex srepat.w_indexgroup = w_indexgroup return w_srepat 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
"don't know the size pointed to by '%s'", ctype.name) ptr = w_cdata.unsafe_escaping_ptr() # w_cdata kept alive by MiniBuffer() return MiniBuffer(LLBuffer(ptr, size), w_cdata) MiniBuffer.typedef = TypeDef( "_cffi_backend.buffer", None, None, "read-write", __new__ = interp2app(MiniBuffer___new__), __len__ = interp2app(MiniBuffer.descr_len), __getitem__ = interp2app(MiniBuffer.descr_getitem), __setitem__ = interp2app(MiniBuffer.descr_setitem), __eq__ = interp2app(MiniBuffer.descr_eq), __ne__ = interp2app(MiniBuffer.descr_ne), __lt__ = interp2app(MiniBuffer.descr_lt), __le__ = interp2app(MiniBuffer.descr_le), __gt__ = interp2app(MiniBuffer.descr_gt), __ge__ = interp2app(MiniBuffer.descr_ge), __weakref__ = make_weakref_descr(MiniBuffer), __doc__ = """ffi.buffer(cdata[, byte_size]): Return a read-write buffer object that references the raw C data pointed to by the given 'cdata'. The 'cdata' must be a pointer or an array. Can be passed to functions expecting a buffer, or directly manipulated with: buf[:] get a copy of it in a regular string, or buf[idx] as a single character buf[:] = ... buf[idx] = ... change the content """, ) MiniBuffer.typedef.acceptable_as_base_class = False
"read-write", variable_sized=True, __doc__="""\ Create a new memoryview object which references the given object. """, __new__=interp2app(W_MemoryView.descr_new_memoryview), __eq__=interp2app(W_MemoryView.descr_eq), __getitem__=interp2app(W_MemoryView.descr_getitem), __len__=interp2app(W_MemoryView.descr_len), __ne__=interp2app(W_MemoryView.descr_ne), __setitem__=interp2app(W_MemoryView.descr_setitem), __repr__=interp2app(W_MemoryView.descr_repr), __hash__=interp2app(W_MemoryView.descr_hash), __enter__=interp2app(W_MemoryView.descr_enter), __exit__=interp2app(W_MemoryView.descr_exit), __weakref__=make_weakref_descr(W_MemoryView), cast=interp2app(W_MemoryView.descr_cast), hex=interp2app(W_MemoryView.descr_hex), tobytes=interp2app(W_MemoryView.descr_tobytes), tolist=interp2app(W_MemoryView.descr_tolist), release=interp2app(W_MemoryView.descr_release), format=GetSetProperty(W_MemoryView.w_get_format), itemsize=GetSetProperty(W_MemoryView.w_get_itemsize), ndim=GetSetProperty(W_MemoryView.w_get_ndim), nbytes=GetSetProperty(W_MemoryView.w_get_nbytes), readonly=GetSetProperty(W_MemoryView.w_is_readonly), shape=GetSetProperty(W_MemoryView.w_get_shape), strides=GetSetProperty(W_MemoryView.w_get_strides), suboffsets=GetSetProperty(W_MemoryView.w_get_suboffsets), obj=GetSetProperty(W_MemoryView.w_get_obj), _pypy_raw_address=interp2app(W_MemoryView.descr_pypy_raw_address),
W_Root, W_Root]), __delslice__ = interp2app(W_InstanceObject.descr_delslice, unwrap_spec=['self', ObjSpace, W_Root, W_Root]), __call__ = interp2app(W_InstanceObject.descr_call, unwrap_spec=['self', ObjSpace, Arguments]), __nonzero__ = interp2app(W_InstanceObject.descr_nonzero, unwrap_spec=['self', ObjSpace]), __cmp__ = interp2app(W_InstanceObject.descr_cmp, unwrap_spec=['self', ObjSpace, W_Root]), __hash__ = interp2app(W_InstanceObject.descr_hash, unwrap_spec=['self', ObjSpace]), __index__ = interp2app(W_InstanceObject.descr_index, unwrap_spec=['self', ObjSpace]), __contains__ = interp2app(W_InstanceObject.descr_contains, unwrap_spec=['self', ObjSpace, W_Root]), __pow__ = interp2app(W_InstanceObject.descr_pow, unwrap_spec=['self', ObjSpace, W_Root, W_Root]), __rpow__ = interp2app(W_InstanceObject.descr_rpow, unwrap_spec=['self', ObjSpace, W_Root, W_Root]), next = interp2app(W_InstanceObject.descr_next, unwrap_spec=['self', ObjSpace]), __weakref__ = make_weakref_descr(W_InstanceObject), __del__ = interp2app(W_InstanceObject.descr_del, unwrap_spec=['self', ObjSpace]), **rawdict ) class W_InstanceObjectWithDel(W_InstanceObject): def __del__(self): self._enqueue_for_destruction(self.space)
elif __args__.arguments_w or __args__.keywords: raise OperationError(space.w_TypeError, space.wrap("this constructor takes no arguments")) return w_inst W_ClassObject.typedef = TypeDef( "classobj", __new__=interp2app(descr_classobj_new), __repr__=interp2app(W_ClassObject.descr_repr), __str__=interp2app(W_ClassObject.descr_str), __call__=interp2app(class_descr_call), __getattribute__=interp2app(W_ClassObject.descr_getattribute), __setattr__=interp2app(W_ClassObject.descr_setattr), __delattr__=interp2app(W_ClassObject.descr_delattr), __weakref__=make_weakref_descr(W_ClassObject), ) W_ClassObject.typedef.acceptable_as_base_class = False def make_unary_instance_method(name): def unaryop(self, space): w_meth = self.getattr(space, name, True) return space.call_function(w_meth) unaryop.func_name = name return unaryop def make_binary_returning_notimplemented_instance_method(name): def binaryop(self, space, w_other):
def fget_item(self, space): return self._fget('i') def fget_length(self, space): return self._fget('l') def fget_fields(self, space): return self._fget('f') def fget_args(self, space): return self._fget('a') def fget_result(self, space): return self._fget('r') def fget_ellipsis(self, space): return self._fget('E') def fget_abi(self, space): return self._fget('A') def fget_elements(self, space): return self._fget('e') def fget_relements(self, space):return self._fget('R') W_CType.typedef = TypeDef( 'CTypeDescr', __module__ = '_cffi_backend', __repr__ = interp2app(W_CType.repr), __weakref__ = make_weakref_descr(W_CType), kind = GetSetProperty(W_CType.fget_kind, doc="kind"), cname = GetSetProperty(W_CType.fget_cname, doc="C name"), item = GetSetProperty(W_CType.fget_item, doc="pointer to, or array of"), length = GetSetProperty(W_CType.fget_length, doc="array length or None"), fields = GetSetProperty(W_CType.fget_fields, doc="struct or union fields"), args = GetSetProperty(W_CType.fget_args, doc="function argument types"), result = GetSetProperty(W_CType.fget_result, doc="function result type"), ellipsis = GetSetProperty(W_CType.fget_ellipsis, doc="function has '...'"), abi = GetSetProperty(W_CType.fget_abi, doc="function ABI"), elements = GetSetProperty(W_CType.fget_elements, doc="enum elements"), relements = GetSetProperty(W_CType.fget_relements, doc="enum elements, reversed"), __dir__ = interp2app(W_CType.dir), ) W_CType.typedef.acceptable_as_base_class = False
from pypy.objspace.std.typeobject import _precheck_for_new w_subtype = _precheck_for_new(space, w_subtype) if __args__.arguments_w or __args__.keywords: w_parent_init, _ = space.lookup_in_type_where(w_subtype, '__init__') if w_parent_init is space.w_object: raise oefmt(space.w_TypeError, "Initialization arguments are not supported") local = space.allocate_instance(Local, w_subtype) Local.__init__(local, space, __args__) return local Local.typedef = TypeDef("_thread._local", __doc__ = "Thread-local data", __new__ = interp2app(Local.descr_local__new__.im_func), __dict__ = GetSetProperty(descr_get_dict, cls=Local), __weakref__ = make_weakref_descr(Local), ) def thread_is_stopping(ec): sentinel_lock = ec._sentinel_lock if sentinel_lock is not None: if sentinel_lock.lock.is_acquired(): sentinel_lock.descr_lock_release(ec.space) tlobjs = ec._thread_local_objs if tlobjs is None: return ec._thread_local_objs = None for wref in tlobjs.items(): local = wref() if local is not None: del local.dicts[ec]
flush=interp2app(W_IOBase.flush_w), seek=interp2app(W_IOBase.seek_w), tell=interp2app(W_IOBase.tell_w), truncate=interp2app(W_IOBase.truncate_w), fileno=interp2app(W_IOBase.fileno_w), isatty=interp2app(W_IOBase.isatty_w), readable=interp2app(W_IOBase.readable_w), writable=interp2app(W_IOBase.writable_w), seekable=interp2app(W_IOBase.seekable_w), _checkReadable=interp2app(check_readable_w), _checkWritable=interp2app(check_writable_w), _checkSeekable=interp2app(check_seekable_w), _checkClosed=interp2app(W_IOBase.check_closed_w), closed=GetSetProperty(W_IOBase.closed_get_w), __dict__=GetSetProperty(descr_get_dict, descr_set_dict, cls=W_IOBase), __weakref__=make_weakref_descr(W_IOBase), readline=interp2app(W_IOBase.readline_w), readlines=interp2app(W_IOBase.readlines_w), writelines=interp2app(W_IOBase.writelines_w), ) class W_RawIOBase(W_IOBase): # ________________________________________________________________ # Abstract read methods, based on readinto() def read_w(self, space, w_size=None): size = convert_size(space, w_size) if size < 0: return space.call_method(self, "readall")
def descr_iter_unpack(self, space, w_buffer): return W_UnpackIter(space, self, w_buffer) W_Struct.typedef = TypeDef("Struct", __new__=interp2app(W_Struct.descr__new__.im_func), __init__=interp2app(W_Struct.descr__init__), format=interp_attrproperty("format", cls=W_Struct, wrapfn="newbytes"), size=interp_attrproperty("size", cls=W_Struct, wrapfn="newint"), pack=interp2app(W_Struct.descr_pack), unpack=interp2app(W_Struct.descr_unpack), pack_into=interp2app(W_Struct.descr_pack_into), unpack_from=interp2app(W_Struct.descr_unpack_from), iter_unpack=interp2app(W_Struct.descr_iter_unpack), __weakref__=make_weakref_descr(W_Struct), ) W_UnpackIter.typedef = TypeDef("unpack_iterator", __iter__=interp2app(W_UnpackIter.descr_iter), __next__=interp2app(W_UnpackIter.descr_next), __length_hint__=interp2app(W_UnpackIter.descr_length_hint) ) def iter_unpack(space, w_format, w_buffer): w_struct = W_Struct() w_struct.descr__init__(space, w_format) return W_UnpackIter(space, w_struct, w_buffer) def clearcache(space): """No-op on PyPy"""
__repr__=interp2app(GeneratorIterator.descr__repr__), __reduce__=interp2app(GeneratorIterator.descr__reduce__), __setstate__=interp2app(GeneratorIterator.descr__setstate__), next=interp2app(GeneratorIterator.descr_next, descrmismatch='next'), send=interp2app(GeneratorIterator.descr_send, descrmismatch='send'), throw=interp2app(GeneratorIterator.descr_throw, descrmismatch='throw'), close=interp2app(GeneratorIterator.descr_close, descrmismatch='close'), __iter__=interp2app(GeneratorIterator.descr__iter__, descrmismatch='__iter__'), gi_running=interp_attrproperty('running', cls=GeneratorIterator, wrapfn="newbool"), gi_frame=GetSetProperty(GeneratorIterator.descr_gi_frame), gi_code=GetSetProperty(GeneratorIterator.descr_gi_code), __name__=GetSetProperty(GeneratorIterator.descr__name__), __weakref__=make_weakref_descr(GeneratorIterator), ) assert not GeneratorIterator.typedef.acceptable_as_base_class # no __new__ def get_printable_location_genentry(bytecode): return '%s <generator>' % (bytecode.get_repr(), ) generatorentry_driver = jit.JitDriver( greens=['pycode'], reds=['gen', 'w_arg', 'operr'], get_printable_location=get_printable_location_genentry, name='generatorentry') from pypy.tool.stdlib_opcode import HAVE_ARGUMENT, opmap
self.keepalive = keepalive def descr_setitem(self, space, w_index, w_obj): try: W_Buffer.descr_setitem(self, space, w_index, w_obj) except OperationError as e: if e.match(space, space.w_TypeError): e.w_type = space.w_ValueError raise MiniBuffer.typedef = TypeDef( "_cffi_backend.buffer", __len__ = interp2app(MiniBuffer.descr_len), __getitem__ = interp2app(MiniBuffer.descr_getitem), __setitem__ = interp2app(MiniBuffer.descr_setitem), __weakref__ = make_weakref_descr(MiniBuffer), __str__ = interp2app(MiniBuffer.descr_str), ) MiniBuffer.typedef.acceptable_as_base_class = False @unwrap_spec(w_cdata=cdataobj.W_CData, size=int) def buffer(space, w_cdata, size=-1): ctype = w_cdata.ctype if isinstance(ctype, ctypeptr.W_CTypePointer): if size < 0: structobj = w_cdata.get_structobj() if (structobj is not None and isinstance(structobj.ctype, ctypestruct.W_CTypeStructOrUnion)): size = structobj._sizeof() if size < 0:
Build an ordered collection accessible from endpoints only.""", __new__ = interp2app(descr__new__), __init__ = interp2app(W_Deque.init), append = interp2app(W_Deque.append), appendleft = interp2app(W_Deque.appendleft), clear = interp2app(W_Deque.clear), count = interp2app(W_Deque.count), extend = interp2app(W_Deque.extend), extendleft = interp2app(W_Deque.extendleft), pop = interp2app(W_Deque.pop), popleft = interp2app(W_Deque.popleft), remove = interp2app(W_Deque.remove), reverse = interp2app(W_Deque.reverse), rotate = interp2app(W_Deque.rotate), __weakref__ = make_weakref_descr(W_Deque), __iter__ = interp2app(W_Deque.iter), __reversed__ = interp2app(W_Deque.reviter), __len__ = interp2app(W_Deque.length), __repr__ = interp2app(W_Deque.repr), __lt__ = interp2app(W_Deque.lt), __le__ = interp2app(W_Deque.le), __eq__ = interp2app(W_Deque.eq), __ne__ = interp2app(W_Deque.ne), __gt__ = interp2app(W_Deque.gt), __ge__ = interp2app(W_Deque.ge), __hash__ = None, __iadd__ = interp2app(W_Deque.iadd), __getitem__ = interp2app(W_Deque.getitem), __setitem__ = interp2app(W_Deque.setitem), __delitem__ = interp2app(W_Deque.delitem),
rfind = interp2app(W_MMap.rfind), seek = interp2app(W_MMap.seek), tell = interp2app(W_MMap.tell), size = interp2app(W_MMap.descr_size), write = interp2app(W_MMap.write), write_byte = interp2app(W_MMap.write_byte), flush = interp2app(W_MMap.flush), move = interp2app(W_MMap.move), resize = interp2app(W_MMap.resize), __len__ = interp2app(W_MMap.__len__), __getitem__ = interp2app(W_MMap.descr_getitem), __setitem__ = interp2app(W_MMap.descr_setitem), __enter__ = interp2app(W_MMap.descr_enter), __exit__ = interp2app(W_MMap.descr_exit), __weakref__ = make_weakref_descr(W_MMap), closed = GetSetProperty(W_MMap.closed_get), ) constants = rmmap.constants PAGESIZE = rmmap.PAGESIZE ALLOCATIONGRANULARITY = rmmap.ALLOCATIONGRANULARITY ACCESS_READ = rmmap.ACCESS_READ ACCESS_WRITE = rmmap.ACCESS_WRITE ACCESS_COPY = rmmap.ACCESS_COPY @objectmodel.dont_inline def mmap_error(space, e): if isinstance(e, RValueError):
Build an ordered collection accessible from endpoints only.""", __module__='_collections', __new__=interp2app(descr__new__), __init__=interp2app(W_Deque.init), append=interp2app(W_Deque.append), appendleft=interp2app(W_Deque.appendleft), clear=interp2app(W_Deque.clear), count=interp2app(W_Deque.count), extend=interp2app(W_Deque.extend), extendleft=interp2app(W_Deque.extendleft), pop=interp2app(W_Deque.pop), popleft=interp2app(W_Deque.popleft), remove=interp2app(W_Deque.remove), reverse=interp2app(W_Deque.reverse), rotate=interp2app(W_Deque.rotate), __weakref__=make_weakref_descr(W_Deque), __iter__=interp2app(W_Deque.iter), __reversed__=interp2app(W_Deque.reviter), __len__=interp2app(W_Deque.length), __repr__=interp2app(W_Deque.repr), __lt__=interp2app(W_Deque.lt), __le__=interp2app(W_Deque.le), __eq__=interp2app(W_Deque.eq), __ne__=interp2app(W_Deque.ne), __gt__=interp2app(W_Deque.gt), __ge__=interp2app(W_Deque.ge), __hash__=None, __iadd__=interp2app(W_Deque.iadd), __getitem__=interp2app(W_Deque.getitem), __setitem__=interp2app(W_Deque.setitem), __delitem__=interp2app(W_Deque.delitem),
def W_TeeIterable___new__(space, w_subtype, w_iterable): # Obscure and undocumented function. PyPy only supports w_iterable # being a W_TeeIterable, because the case where it is a general # iterable is useless and confusing as far as I can tell (as the # semantics are then slightly different; see the XXX in lib-python's # test_itertools). myiter = space.interp_w(W_TeeIterable, w_iterable) return space.wrap(W_TeeIterable(space, myiter.w_iterator, myiter.chained_list)) W_TeeIterable.typedef = TypeDef( 'itertools._tee', __new__ = interp2app(W_TeeIterable___new__), __iter__ = interp2app(W_TeeIterable.iter_w), __next__ = interp2app(W_TeeIterable.next_w), __weakref__ = make_weakref_descr(W_TeeIterable), ) W_TeeIterable.typedef.acceptable_as_base_class = False class W_GroupBy(W_Root): def __init__(self, space, w_iterable, w_fun): self.space = space self.w_iterable = self.space.iter(w_iterable) if space.is_none(w_fun): self.w_fun = None else: self.w_fun = w_fun self.index = 0 self.lookahead = False self.exhausted = False
__getslice__=interp2app(W_ArrayBase.descr_getslice), __setitem__=interp2app(W_ArrayBase.descr_setitem), __setslice__=interp2app(W_ArrayBase.descr_setslice), __delitem__=interp2app(W_ArrayBase.descr_delitem), __delslice__=interp2app(W_ArrayBase.descr_delslice), __iter__=interp2app(W_ArrayBase.descr_iter), __add__=interpindirect2app(W_ArrayBase.descr_add), __iadd__=interpindirect2app(W_ArrayBase.descr_inplace_add), __mul__=interpindirect2app(W_ArrayBase.descr_mul), __imul__=interpindirect2app(W_ArrayBase.descr_inplace_mul), __radd__=interp2app(W_ArrayBase.descr_radd), __rmul__=interp2app(W_ArrayBase.descr_rmul), __repr__=interp2app(W_ArrayBase.descr_repr), itemsize=GetSetProperty(descr_itemsize), typecode=GetSetProperty(descr_typecode), __weakref__=make_weakref_descr(W_ArrayBase), append=interpindirect2app(W_ArrayBase.descr_append), extend=interp2app(W_ArrayBase.descr_extend), count=interpindirect2app(W_ArrayBase.descr_count), index=interpindirect2app(W_ArrayBase.descr_index), reverse=interpindirect2app(W_ArrayBase.descr_reverse), remove=interpindirect2app(W_ArrayBase.descr_remove), pop=interpindirect2app(W_ArrayBase.descr_pop), insert=interpindirect2app(W_ArrayBase.descr_insert), tolist=interp2app(W_ArrayBase.descr_tolist), fromlist=interp2app(W_ArrayBase.descr_fromlist), tostring=interp2app(W_ArrayBase.descr_tostring), fromstring=interp2app(W_ArrayBase.descr_fromstring), tofile=interp2app(W_ArrayBase.descr_tofile), fromfile=interp2app(W_ArrayBase.descr_fromfile), fromunicode=interp2app(W_ArrayBase.descr_fromunicode),
srepat.space = space srepat.w_pattern = w_pattern # the original uncompiled pattern srepat.flags = flags srepat.code = code srepat.num_groups = groups srepat.w_groupindex = w_groupindex srepat.w_indexgroup = w_indexgroup return w_srepat 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), ) # ____________________________________________________________
Methods of socket objects (keyword arguments not allowed): accept() -- accept a connection, returning new socket and client address 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), ** socketmethods )
return self._fget('E') def fget_abi(self, space): return self._fget('A') def fget_elements(self, space): return self._fget('e') def fget_relements(self, space): return self._fget('R') W_CType.typedef = TypeDef( '_cffi_backend.CTypeDescr', __repr__=interp2app(W_CType.repr), __weakref__=make_weakref_descr(W_CType), kind=GetSetProperty(W_CType.fget_kind, doc="kind"), cname=GetSetProperty(W_CType.fget_cname, doc="C name"), item=GetSetProperty(W_CType.fget_item, doc="pointer to, or array of"), length=GetSetProperty(W_CType.fget_length, doc="array length or None"), fields=GetSetProperty(W_CType.fget_fields, doc="struct or union fields"), args=GetSetProperty(W_CType.fget_args, doc="function argument types"), result=GetSetProperty(W_CType.fget_result, doc="function result type"), ellipsis=GetSetProperty(W_CType.fget_ellipsis, doc="function has '...'"), abi=GetSetProperty(W_CType.fget_abi, doc="function ABI"), elements=GetSetProperty(W_CType.fget_elements, doc="enum elements"), relements=GetSetProperty(W_CType.fget_relements, doc="enum elements, reversed"), __dir__=interp2app(W_CType.dir), ) W_CType.typedef.acceptable_as_base_class = False
"thread.lock", __doc__="""\ A lock object is a synchronization primitive. To create a lock, call the thread.allocate_lock() function. Methods are: acquire() -- lock the lock, possibly blocking until it can be obtained release() -- unlock of the lock locked() -- test whether the lock is currently locked A lock is not owned by the thread that locked it; another thread may unlock it. A thread attempting to lock a lock that it has already locked will block until another thread unlocks it. Deadlocks may ensue.""", acquire=descr_acquire, _py3k_acquire=descr_py3k_acquire, release=descr_release, locked=descr_locked, __enter__=descr__enter__, __exit__=descr__exit__, __weakref__=make_weakref_descr(Lock), # Obsolete synonyms acquire_lock=descr_acquire, release_lock=descr_release, locked_lock=descr_locked, ) def allocate_lock(space): """Create a new lock object. (allocate() is an obsolete synonym.) See LockType.__doc__ for information about locks.""" return Lock(space)
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_Socket), __repr__=interp2app(W_Socket.descr_repr), type=GetSetProperty(W_Socket.get_type_w), proto=GetSetProperty(W_Socket.get_proto_w), family=GetSetProperty(W_Socket.get_family_w), **socketmethods)
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), **dict([(name, interp2app(getattr(W_File, 'file_' + name))) for name in W_File._exposed_method_names]) ) # ____________________________________________________________ def wrap_list_of_str(space, lst): return space.newlist_bytes(lst) class FileState: def __init__(self, space): self.openstreams = {} def getopenstreams(space): return space.fromcache(FileState).openstreams
w_result = space.call_args(w_init, __args__) if not space.is_w(w_result, space.w_None): raise oefmt(space.w_TypeError, "__init__() should return None") elif __args__.arguments_w or __args__.keywords: raise oefmt(space.w_TypeError, "this constructor takes no arguments") return w_inst W_ClassObject.typedef = TypeDef("classobj", __new__ = interp2app(descr_classobj_new), __repr__ = interp2app(W_ClassObject.descr_repr), __str__ = interp2app(W_ClassObject.descr_str), __call__ = interp2app(class_descr_call), __getattribute__ = interp2app(W_ClassObject.descr_getattribute), __setattr__ = interp2app(W_ClassObject.descr_setattr), __delattr__ = interp2app(W_ClassObject.descr_delattr), __weakref__ = make_weakref_descr(W_ClassObject), ) W_ClassObject.typedef.acceptable_as_base_class = False def make_unary_instance_method(name): def unaryop(self, space): w_meth = self.getattr(space, name, True) return space.call_function(w_meth) unaryop.func_name = name return unaryop def make_binary_returning_notimplemented_instance_method(name): def binaryop(self, space, w_other): try: w_meth = self.getattr(space, name, False)
seek = interp2app(W_IOBase.seek_w), tell = interp2app(W_IOBase.tell_w), truncate = interp2app(W_IOBase.truncate_w), fileno = interp2app(W_IOBase.fileno_w), isatty = interp2app(W_IOBase.isatty_w), readable = interp2app(W_IOBase.readable_w), writable = interp2app(W_IOBase.writable_w), seekable = interp2app(W_IOBase.seekable_w), _checkReadable = interp2app(check_readable_w), _checkWritable = interp2app(check_writable_w), _checkSeekable = interp2app(check_seekable_w), _checkClosed = interp2app(W_IOBase.check_closed_w), closed = GetSetProperty(W_IOBase.closed_get_w), __dict__ = GetSetProperty(descr_get_dict, descr_set_dict, cls=W_IOBase), __weakref__ = make_weakref_descr(W_IOBase), readline = interp2app(W_IOBase.readline_w), readlines = interp2app(W_IOBase.readlines_w), writelines = interp2app(W_IOBase.writelines_w), ) class W_RawIOBase(W_IOBase): # ________________________________________________________________ # Abstract read methods, based on readinto() def read_w(self, space, w_size=None): size = convert_size(space, w_size) if size < 0: return space.call_method(self, "readall")
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, doc="Support for 'print'."), __repr__=interp2app(W_File.file__repr__), write=interp2app(W_File.file_write), writelines=interp2app(W_File.file_writelines), __exit__=interp2app(W_File.file__exit__), __weakref__=make_weakref_descr(W_File), **dict([(name, interp2app(getattr(W_File, 'file_' + name))) for name in W_File._exposed_method_names])) # ____________________________________________________________ def wrap_list_of_str(space, lst): return space.newlist_bytes(lst) class FileState: def __init__(self, space): self.openstreams = {}
unwrap_spec=['self', ObjSpace, W_Root, W_Root, W_Root]), __delslice__=interp2app(W_InstanceObject.descr_delslice, unwrap_spec=['self', ObjSpace, W_Root, W_Root]), __call__=interp2app(W_InstanceObject.descr_call, unwrap_spec=['self', ObjSpace, Arguments]), __nonzero__=interp2app(W_InstanceObject.descr_nonzero, unwrap_spec=['self', ObjSpace]), __cmp__=interp2app(W_InstanceObject.descr_cmp, unwrap_spec=['self', ObjSpace, W_Root]), __hash__=interp2app(W_InstanceObject.descr_hash, unwrap_spec=['self', ObjSpace]), __index__=interp2app(W_InstanceObject.descr_index, unwrap_spec=['self', ObjSpace]), __contains__=interp2app(W_InstanceObject.descr_contains, unwrap_spec=['self', ObjSpace, W_Root]), __pow__=interp2app(W_InstanceObject.descr_pow, unwrap_spec=['self', ObjSpace, W_Root, W_Root]), __rpow__=interp2app(W_InstanceObject.descr_rpow, unwrap_spec=['self', ObjSpace, W_Root, W_Root]), next=interp2app(W_InstanceObject.descr_next, unwrap_spec=['self', ObjSpace]), __weakref__=make_weakref_descr(W_InstanceObject), __del__=interp2app(W_InstanceObject.descr_del, unwrap_spec=['self', ObjSpace]), **rawdict) class W_InstanceObjectWithDel(W_InstanceObject): def __del__(self): self._enqueue_for_destruction(self.space)
# Obscure and undocumented function. PyPy only supports w_iterable # being a W_TeeIterable, because the case where it is a general # iterable is useless and confusing as far as I can tell (as the # semantics are then slightly different; see the XXX in lib-python's # test_itertools). myiter = space.interp_w(W_TeeIterable, w_iterable) return W_TeeIterable(space, myiter.w_iterator, myiter.chained_list) W_TeeIterable.typedef = TypeDef( 'itertools._tee', __new__=interp2app(W_TeeIterable___new__), __iter__=interp2app(W_TeeIterable.iter_w), next=interp2app(W_TeeIterable.next_w), __copy__=interp2app(W_TeeIterable.copy_w), __weakref__=make_weakref_descr(W_TeeIterable), ) W_TeeIterable.typedef.acceptable_as_base_class = False class W_GroupBy(W_Root): def __init__(self, space, w_iterable, w_fun): self.space = space self.w_iterator = self.space.iter(w_iterable) if w_fun is None: w_fun = space.w_None self.w_keyfunc = w_fun self.w_tgtkey = None self.w_currkey = None self.w_currvalue = None
W_CData.typedef = TypeDef( '_cffi_backend.CData', __module__='_cffi_backend', __name__='<cdata>', __repr__=interp2app(W_CData.repr), __bool__=interp2app(W_CData.bool), __int__=interp2app(W_CData.int), __long__=interp2app(W_CData.long), __float__=interp2app(W_CData.float), __len__=interp2app(W_CData.len), __lt__=interp2app(W_CData.lt), __le__=interp2app(W_CData.le), __eq__=interp2app(W_CData.eq), __ne__=interp2app(W_CData.ne), __gt__=interp2app(W_CData.gt), __ge__=interp2app(W_CData.ge), __hash__=interp2app(W_CData.hash), __getitem__=interp2app(W_CData.getitem), __setitem__=interp2app(W_CData.setitem), __add__=interp2app(W_CData.add), __radd__=interp2app(W_CData.add), __sub__=interp2app(W_CData.sub), __getattr__=interp2app(W_CData.getattr), __setattr__=interp2app(W_CData.setattr), __call__=interp2app(W_CData.call), __iter__=interp2app(W_CData.iter), __weakref__=make_weakref_descr(W_CData), ) W_CData.typedef.acceptable_as_base_class = False
self.rlock_owner = owner self.rlock_count = count def release_save_w(self, space): """For internal use by `threading.Condition`.""" count, self.rlock_count = self.rlock_count, 0 owner, self.rlock_owner = self.rlock_owner, 0 self.lock.release() return space.newtuple([space.wrap(count), space.wrap(owner)]) def descr__enter__(self, space): self.acquire_w(space) return self def descr__exit__(self, space, __args__): self.release_w(space) W_RLock.typedef = TypeDef( "_thread.RLock", __new__=interp2app(W_RLock.descr__new__.im_func), acquire=interp2app(W_RLock.acquire_w), release=interp2app(W_RLock.release_w), _is_owned=interp2app(W_RLock.is_owned_w), _acquire_restore=interp2app(W_RLock.acquire_restore_w), _release_save=interp2app(W_RLock.release_save_w), __enter__=interp2app(W_RLock.descr__enter__), __exit__=interp2app(W_RLock.descr__exit__), __weakref__=make_weakref_descr(W_RLock), )