def errors_get_w(self, space):
return space.w_None
def newlines_get_w(self, space):
return space.w_None
W_TextIOBase.typedef = TypeDef(
'_io._TextIOBase',
W_IOBase.typedef,
__new__=generic_new_descr(W_TextIOBase),
read=interp2app(W_TextIOBase.read_w),
readline=interp2app(W_TextIOBase.readline_w),
write=interp2app(W_TextIOBase.write_w),
detach=interp2app(W_TextIOBase.detach_w),
encoding=interp_attrproperty_w("w_encoding", W_TextIOBase),
newlines=GetSetProperty(W_TextIOBase.newlines_get_w),
errors=GetSetProperty(W_TextIOBase.errors_get_w),
)
def _determine_encoding(space, encoding):
if encoding is not None:
return space.newtext(encoding)
try:
w_locale = space.call_method(space.builtin, '__import__',
space.newtext('locale'))
w_encoding = space.call_method(w_locale, 'getpreferredencoding')
except OperationError as e:
# getpreferredencoding() may also raise ImportError
space.w_TypeError,
space.wrap("Trying to set readonly attribute %s on property" %
(attr, )))
setattr.unwrap_spec = ['self', ObjSpace, str, W_Root]
W_Property.typedef = TypeDef(
'property',
__doc__=
'''property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for deleting, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "I am the 'x' property.")''',
__new__=interp2app(W_Property.new.im_func),
__get__=interp2app(W_Property.get),
__set__=interp2app(W_Property.set),
__delete__=interp2app(W_Property.delete),
__getattribute__=interp2app(W_Property.getattribute),
__setattr__=interp2app(W_Property.setattr),
fdel=interp_attrproperty_w('w_fdel', W_Property),
fget=interp_attrproperty_w('w_fget', W_Property),
fset=interp_attrproperty_w('w_fset', W_Property),
)
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_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),
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
self.ctx = ctx
if asking_for_bound:
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(
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
W_Property.typedef = TypeDef(
'property',
__doc__ = '''property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for deleting, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "I am the 'x' property.")''',
__new__ = generic_new_descr(W_Property),
__init__ = interp2app(W_Property.init),
__get__ = interp2app(W_Property.get),
__set__ = interp2app(W_Property.set),
__delete__ = interp2app(W_Property.delete),
fdel = interp_attrproperty_w('w_fdel', W_Property),
fget = interp_attrproperty_w('w_fget', W_Property),
fset = interp_attrproperty_w('w_fset', W_Property),
getter = interp2app(W_Property.getter),
setter = interp2app(W_Property.setter),
deleter = interp2app(W_Property.deleter),
)
# This allows there to be a __doc__ of the property type and a __doc__
# descriptor for the instances.
W_Property.typedef.rawdict['__doc__'] = interp_attrproperty_w('w_doc',
W_Property)
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_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"),
w_strict=None,
):
"""
csv_writer = csv.writer(fileobj [, dialect='excel']
[optional keyword args])
for row in sequence:
csv_writer.writerow(row)
[or]
csv_writer = csv.writer(fileobj [, dialect='excel']
[optional keyword args])
csv_writer.writerows(rows)
The \"fileobj\" argument can be any object that supports the file API."""
dialect = _build_dialect(space, w_dialect, w_delimiter, w_doublequote,
w_escapechar, w_lineterminator, w_quotechar,
w_quoting, w_skipinitialspace, w_strict)
return W_Writer(space, dialect, w_fileobj)
W_Writer.typedef = TypeDef('_csv.writer',
dialect=interp_attrproperty_w('dialect', W_Writer),
writerow=interp2app(W_Writer.writerow),
writerows=interp2app(W_Writer.writerows),
__doc__="""CSV writer
Writer objects are responsible for generating tabular data
in CSV format from sequence input.""")
W_Writer.typedef.acceptable_as_base_class = False
def descr_call(self, space, __args__):
return space.call_args(self.w_function, __args__)
def descr_repr(self, space):
return self.getrepr(space, u'<instancemethod %s>' %
(self.w_function.getname(space),))
InstanceMethod.typedef = TypeDef("instancemethod",
__new__ = interp2app(InstanceMethod.descr_new),
__call__ = interp2app(InstanceMethod.descr_call,
descrmismatch='__call__'),
__get__ = interp2app(InstanceMethod.descr_get),
__repr__ = interp2app(InstanceMethod.descr_repr,
descrmismatch='__repr__'),
__func__= interp_attrproperty_w('w_function', cls=InstanceMethod),
)
InstanceMethod.typedef.acceptable_as_base_class = False
@cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
def PyInstanceMethod_Check(space, w_o):
"""Return true if o is an instance method object (has type
PyInstanceMethod_Type). The parameter must not be NULL."""
return space.isinstance_w(w_o,
space.gettypeobject(InstanceMethod.typedef))
@cpython_api([PyObject], PyObject)
def PyInstanceMethod_New(space, w_func):
"""Return a new instance method object, with func being any
callable object func is the function that will be called when the
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),
)
else:
pos = line.find(self.readnl[0], start, end)
if pos >= 0:
return -1, pos - start
return -1, size
W_TextIOBase.typedef = TypeDef(
'_io._TextIOBase', W_IOBase.typedef,
__new__ = generic_new_descr(W_TextIOBase),
read = interp2app(W_TextIOBase.read_w),
readline = interp2app(W_TextIOBase.readline_w),
write = interp2app(W_TextIOBase.write_w),
detach = interp2app(W_TextIOBase.detach_w),
encoding = interp_attrproperty_w("w_encoding", W_TextIOBase),
newlines = GetSetProperty(W_TextIOBase.newlines_get_w),
errors = GetSetProperty(W_TextIOBase.errors_get_w),
)
def _determine_encoding(space, encoding):
if encoding is not None:
return space.wrap(encoding)
try:
w_locale = space.call_method(space.builtin, '__import__',
space.wrap('locale'))
w_encoding = space.call_method(w_locale, 'getpreferredencoding')
except OperationError as e:
# getpreferredencoding() may also raise ImportError
getattribute.unwrap_spec = ["self", ObjSpace, str]
def setattr(self, space, attr, w_value):
raise OperationError(space.w_TypeError, space.wrap("Trying to set readonly attribute %s on property" % (attr,)))
setattr.unwrap_spec = ["self", ObjSpace, str, W_Root]
W_Property.typedef = TypeDef(
"property",
__doc__="""property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for deleting, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "I am the 'x' property.")""",
__new__=interp2app(W_Property.new.im_func),
__get__=interp2app(W_Property.get),
__set__=interp2app(W_Property.set),
__delete__=interp2app(W_Property.delete),
__getattribute__=interp2app(W_Property.getattribute),
__setattr__=interp2app(W_Property.setattr),
fdel=interp_attrproperty_w("w_fdel", W_Property),
fget=interp_attrproperty_w("w_fget", W_Property),
fset=interp_attrproperty_w("w_fset", W_Property),
)
w_shape = args_w[0]
# shape in W_ArrayInstance-speak is somewhat different from what
# e.g. numpy thinks of it: self.shape contains the info (itemcode,
# size, etc.) of a single entry; length is user-facing shape
self.length = space.int_w(space.getitem(w_shape, space.newint(0)))
W_LowLevelView.typedef = TypeDef(
'LowLevelView',
__repr__=interp2app(W_LowLevelView.descr_repr),
__setitem__=interp2app(W_LowLevelView.descr_setitem),
__getitem__=interp2app(W_LowLevelView.descr_getitem),
__len__=interp2app(W_LowLevelView.getlength),
buffer=GetSetProperty(W_LowLevelView.getbuffer),
shape=interp_attrproperty_w('shape', W_LowLevelView),
free=interp2app(W_LowLevelView.free),
byptr=interp2app(W_LowLevelView.byptr),
itemaddress=interp2app(W_LowLevelView.descr_itemaddress),
reshape=interp2app(W_LowLevelView.reshape),
)
W_LowLevelView.typedef.acceptable_as_base_class = False
class W_ArrayOfInstances(W_Root):
_attrs_ = ['converter', 'baseaddress', 'clssize', 'length']
_immutable_fields_ = ['converter', 'baseaddress', 'clssize']
def __init__(self, space, clsdecl, address, length, dimensions):
from pypy.module._cppyy import converter
name = clsdecl.name
def __repr__(self):
return '<Field %s %s>' % (self.name, self.w_ffitype.name)
@unwrap_spec(name='text')
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, wrapfn="newtext_or_none"),
ffitype=interp_attrproperty_w('w_ffitype', W_Field),
offset=interp_attrproperty('offset', W_Field, wrapfn="newint"),
)
# ==============================================================================
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
@must_be_light_finalizer
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),
)
getarg=interp2app(WrappedOp.descr_getarg),
setarg=interp2app(WrappedOp.descr_setarg),
result=GetSetProperty(WrappedOp.descr_getresult,
WrappedOp.descr_setresult),
offset=interp_attrproperty("offset", cls=WrappedOp),
)
WrappedOp.acceptable_as_base_class = False
DebugMergePoint.typedef = TypeDef(
'DebugMergePoint',
WrappedOp.typedef,
__new__=interp2app(descr_new_dmp),
__doc__=DebugMergePoint.__doc__,
greenkey=interp_attrproperty_w(
"w_greenkey",
cls=DebugMergePoint,
doc="Representation of place where the loop was compiled. "
"In the case of the main interpreter loop, it's a triplet "
"(code, ofs, is_profiled)"),
pycode=GetSetProperty(DebugMergePoint.get_pycode),
bytecode_no=GetSetProperty(DebugMergePoint.get_bytecode_no,
doc="offset in the bytecode"),
call_depth=interp_attrproperty("call_depth",
cls=DebugMergePoint,
doc="Depth of calls within this loop"),
call_id=interp_attrproperty(
"call_id",
cls=DebugMergePoint,
doc="Number of applevel function traced in this loop"),
jitdriver_name=GetSetProperty(
DebugMergePoint.get_jitdriver_name,
doc="Name of the jitdriver 'pypyjit' in the case "
if not space.exception_match(w_exc_type, self.w_ExpectedException):
self.report_error(space.text_w(space.repr(w_exc_type)))
self.w_value = w_exc_value # for the 'value' app-level attribute
return space.w_True # suppress the exception
def report_error(self, got):
space = self.space
raise oefmt(space.w_AssertionError,
"raises() expected %s, but got %s",
space.text_w(space.repr(self.w_ExpectedException)),
got)
W_RaisesContextManager.typedef = typedef.TypeDef("RaisesContextManager",
__enter__ = gateway.interp2app_temp(W_RaisesContextManager.enter),
__exit__ = gateway.interp2app_temp(W_RaisesContextManager.exit),
value = typedef.interp_attrproperty_w('w_value', cls=W_RaisesContextManager)
)
def pypyraises(space, w_ExpectedException, w_expr=None, __args__=None):
"""A built-in function providing the equivalent of py.test.raises()."""
if w_expr is None:
return W_RaisesContextManager(space, w_ExpectedException)
args_w, kwds_w = __args__.unpack()
if space.isinstance_w(w_expr, space.w_text):
if args_w:
raise oefmt(space.w_TypeError,
"raises() takes no argument after a string expression")
expr = space.unwrap(w_expr)
source = py.code.Source(expr)
frame = space.getexecutioncontext().gettopframe()
w_locals = frame.getdictscope()
for i in range(len(value)):
ll_buffer[start + i] = value[i]
def buffer_w(self, space, flags):
return RawBufferView(
RawFFIBuffer(self), self.shape.itemcode, self.shape.size)
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_w('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()
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),
W_Cursor.typedef = TypeDef(
'Cursor',
execute = interp2app(W_Cursor.execute),
executemany = interp2app(W_Cursor.executemany),
prepare = interp2app(W_Cursor.prepare),
fetchone = interp2app(W_Cursor.fetchone),
fetchmany = interp2app(W_Cursor.fetchmany),
fetchall = interp2app(W_Cursor.fetchall),
close = interp2app(W_Cursor.close),
bindnames = interp2app(W_Cursor.bindnames),
callfunc = interp2app(W_Cursor.callfunc),
callproc = interp2app(W_Cursor.callproc),
var = interp2app(W_Cursor.var),
arrayvar = interp2app(W_Cursor.arrayvar),
setinputsizes = interp2app(W_Cursor.setinputsizes),
setoutputsize = interp2app(W_Cursor.setoutputsize),
__iter__ = interp2app(W_Cursor.descr_iter),
next = interp2app(W_Cursor.descr_next),
arraysize = GetSetProperty(W_Cursor.arraysize_get,
W_Cursor.arraysize_set),
bindarraysize = GetSetProperty(W_Cursor.bindarraysize_get,
W_Cursor.bindarraysize_set),
rowcount = interp_attrproperty('rowCount', W_Cursor),
statement = interp_attrproperty_w('w_statement', W_Cursor),
bindvars = GetSetProperty(W_Cursor.bindvars_get),
fetchvars = GetSetProperty(W_Cursor.fetchvars_get),
description = GetSetProperty(W_Cursor.getDescription),
)
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):
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
W_Range.typedef = TypeDef("range",
__new__ = interp2app(W_Range.descr_new.im_func),
__repr__ = interp2app(W_Range.descr_repr),
__getitem__ = interp2app(W_Range.descr_getitem),
__iter__ = interp2app(W_Range.descr_iter),
__len__ = interp2app(W_Range.descr_len),
__reversed__ = interp2app(W_Range.descr_reversed),
__reduce__ = interp2app(W_Range.descr_reduce),
__contains__ = interp2app(W_Range.descr_contains),
__eq__ = interp2app(W_Range.descr_eq),
__hash__ = interp2app(W_Range.descr_hash),
count = interp2app(W_Range.descr_count),
index = interp2app(W_Range.descr_index),
start = interp_attrproperty_w('w_start', cls=W_Range),
stop = interp_attrproperty_w('w_stop', cls=W_Range),
step = interp_attrproperty_w('w_step', cls=W_Range),
)
W_Range.typedef.acceptable_as_base_class = False
class W_AbstractRangeIterator(W_Root):
def descr_iter(self, space):
return self
def descr_len(self, space):
raise NotImplementedError
def descr_next(self, space):
num = GetSetProperty(WrappedOp.descr_num),
name = GetSetProperty(WrappedOp.descr_name),
getarg = interp2app(WrappedOp.descr_getarg),
setarg = interp2app(WrappedOp.descr_setarg),
result = GetSetProperty(WrappedOp.descr_getresult,
WrappedOp.descr_setresult),
offset = interp_attrproperty("offset", cls=WrappedOp),
)
WrappedOp.acceptable_as_base_class = False
DebugMergePoint.typedef = TypeDef(
'DebugMergePoint', WrappedOp.typedef,
__new__ = interp2app(descr_new_dmp),
__doc__ = DebugMergePoint.__doc__,
greenkey = interp_attrproperty_w("w_greenkey", cls=DebugMergePoint,
doc="Representation of place where the loop was compiled. "
"In the case of the main interpreter loop, it's a triplet "
"(code, ofs, is_profiled)"),
pycode = GetSetProperty(DebugMergePoint.get_pycode),
bytecode_no = GetSetProperty(DebugMergePoint.get_bytecode_no,
doc="offset in the bytecode"),
call_depth = interp_attrproperty("call_depth", cls=DebugMergePoint,
doc="Depth of calls within this loop"),
call_id = interp_attrproperty("call_id", cls=DebugMergePoint,
doc="Number of applevel function traced in this loop"),
jitdriver_name = GetSetProperty(DebugMergePoint.get_jitdriver_name,
doc="Name of the jitdriver 'pypyjit' in the case "
"of the main interpreter loop"),
)
DebugMergePoint.acceptable_as_base_class = False
i = self.shape.getindex(space, attr)
ptr = rffi.ptradd(self.ll_buffer, self.shape.ll_positions[i])
return space.newint(rffi.cast(lltype.Unsigned, ptr))
def getrawsize(self):
return self.shape.size
W_StructureInstance.typedef = TypeDef(
'StructureInstance',
__repr__=interp2app(W_StructureInstance.descr_repr),
__getattr__=interp2app(W_StructureInstance.getattr),
__setattr__=interp2app(W_StructureInstance.setattr),
buffer=GetSetProperty(W_StructureInstance.getbuffer),
free=interp2app(W_StructureInstance.free),
shape=interp_attrproperty_w('shape', W_StructureInstance),
byptr=interp2app(W_StructureInstance.byptr),
fieldaddress=interp2app(W_StructureInstance.descr_fieldaddress),
)
W_StructureInstance.typedef.acceptable_as_base_class = False
class W_StructureInstanceAutoFree(W_StructureInstance):
def __init__(self, space, shape):
W_StructureInstance.__init__(self, space, shape, 0)
@rgc.must_be_light_finalizer
def __del__(self):
if self.ll_buffer:
self._free()
# XXX kill me? This is mostly to make tests happy, raising
# a TypeError instead of an AttributeError and using "readonly"
# instead of "read-only" in the error message :-/
raise OperationError(space.w_TypeError, space.wrap(
"Trying to set readonly attribute %s on property" % (attr,)))
setattr.unwrap_spec = ['self', ObjSpace, str, W_Root]
W_Property.typedef = TypeDef(
'property',
__doc__ = '''property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for deleting, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "I am the 'x' property.")''',
__new__ = interp2app(W_Property.new.im_func),
__get__ = interp2app(W_Property.get),
__set__ = interp2app(W_Property.set),
__delete__ = interp2app(W_Property.delete),
__getattribute__ = interp2app(W_Property.getattribute),
__setattr__ = interp2app(W_Property.setattr),
fdel = interp_attrproperty_w('w_fdel', W_Property),
fget = interp_attrproperty_w('w_fget', W_Property),
fset = interp_attrproperty_w('w_fset', W_Property),
)
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
def get_jitdriver_name(self, space):
return space.wrap(self.jd_name)
WrappedOp.typedef = TypeDef(
'ResOperation',
__doc__ = WrappedOp.__doc__,
__new__ = interp2app(descr_new_resop),
__repr__ = interp2app(WrappedOp.descr_repr),
num = GetSetProperty(WrappedOp.descr_num),
name = GetSetProperty(WrappedOp.descr_name),
getarg = interp2app(WrappedOp.descr_getarg),
setarg = interp2app(WrappedOp.descr_setarg),
result = GetSetProperty(WrappedOp.descr_getresult,
WrappedOp.descr_setresult)
)
WrappedOp.acceptable_as_base_class = False
DebugMergePoint.typedef = TypeDef(
'DebugMergePoint', WrappedOp.typedef,
__new__ = interp2app(descr_new_dmp),
greenkey = interp_attrproperty_w("w_greenkey", cls=DebugMergePoint),
pycode = GetSetProperty(DebugMergePoint.get_pycode),
bytecode_no = GetSetProperty(DebugMergePoint.get_bytecode_no),
call_depth = interp_attrproperty("call_depth", cls=DebugMergePoint),
call_id = interp_attrproperty("call_id", cls=DebugMergePoint),
jitdriver_name = GetSetProperty(DebugMergePoint.get_jitdriver_name),
)
DebugMergePoint.acceptable_as_base_class = False
W_PyCFunctionObject.fset_module,
W_PyCFunctionObject.fdel_module),
__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(
'classmethod',
__get__=interp2app(cclassmethod_descr_get),
__call__=interp2app(W_PyCClassMethodObject.descr_call),
__name__=interp_attrproperty('name',
cls=W_PyCClassMethodObject,
wrapfn="newtext_or_none"),
__objclass__=interp_attrproperty_w('w_objclass',
cls=W_PyCClassMethodObject),
__repr__=interp2app(W_PyCClassMethodObject.descr_method_repr),
)
def descr_call(self, space, __args__):
return space.call_args(self.w_function, __args__)
def descr_repr(self, space):
return self.getrepr(
space, u'<instancemethod %s>' % (self.w_function.getname(space), ))
InstanceMethod.typedef = TypeDef(
"instancemethod",
__new__=interp2app(InstanceMethod.descr_new),
__call__=interp2app(InstanceMethod.descr_call, descrmismatch='__call__'),
__get__=interp2app(InstanceMethod.descr_get),
__repr__=interp2app(InstanceMethod.descr_repr, descrmismatch='__repr__'),
__func__=interp_attrproperty_w('w_function', cls=InstanceMethod),
__name__=GetSetProperty(InstanceMethod.fget_name, cls=InstanceMethod),
__module__=GetSetProperty(InstanceMethod.fget_module, cls=InstanceMethod),
__doc__=GetSetProperty(InstanceMethod.fget_docstring, cls=InstanceMethod),
)
InstanceMethod.typedef.acceptable_as_base_class = False
@cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
def PyInstanceMethod_Check(space, w_o):
"""Return true if o is an instance method object (has type
PyInstanceMethod_Type). The parameter must not be NULL."""
return space.isinstance_w(w_o, space.gettypeobject(InstanceMethod.typedef))
@cpython_api([PyObject], PyObject)
except OperationError as e:
if not e.match(space, space.w_AttributeError):
raise
w_type = w_objtype
if space.issubtype_w(w_type, w_starttype):
return w_type
raise oefmt(space.w_TypeError,
"super(type, obj): obj must be an instance or subtype of type")
W_Super.typedef = TypeDef(
'super',
__new__ = generic_new_descr(W_Super),
__init__ = interp2app(W_Super.descr_init),
__repr__ = interp2app(W_Super.descr_repr),
__thisclass__ = interp_attrproperty_w("w_starttype", W_Super),
__self__ = interp_attrproperty_w("w_self", W_Super),
__self_class__ = interp_attrproperty_w("w_objtype", W_Super),
__getattribute__ = interp2app(W_Super.getattribute),
__get__ = interp2app(W_Super.get),
__doc__ = """\
super(type) -> unbound super object
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
def meth(self, arg):
super(C, self).meth(arg)"""
)
raise
w_type = w_objtype
if space.issubtype_w(w_type, w_starttype):
return w_type
raise oefmt(
space.w_TypeError,
"super(type, obj): obj must be an instance or subtype of type")
W_Super.typedef = TypeDef(
'super',
__new__=generic_new_descr(W_Super),
__init__=interp2app(W_Super.descr_init),
__repr__=interp2app(W_Super.descr_repr),
__thisclass__=interp_attrproperty_w("w_starttype", W_Super),
__self__=interp_attrproperty_w("w_self", W_Super),
__self_class__=interp_attrproperty_w("w_objtype", W_Super),
__getattribute__=interp2app(W_Super.getattribute),
__get__=interp2app(W_Super.get),
__doc__="""\
super(type) -> unbound super object
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
def meth(self, arg):
super(C, self).meth(arg)""")
of input for each iteration, such as a file object or a list. The
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()
return space.call_function(w_type, w_getter, w_setter, w_deleter, w_doc)
W_Property.typedef = TypeDef(
"property",
__doc__="""property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for deleting, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "I am the 'x' property.")""",
__new__=generic_new_descr(W_Property),
__init__=interp2app(W_Property.init),
__get__=interp2app(W_Property.get),
__set__=interp2app(W_Property.set),
__delete__=interp2app(W_Property.delete),
fdel=interp_attrproperty_w("w_fdel", W_Property),
fget=interp_attrproperty_w("w_fget", W_Property),
fset=interp_attrproperty_w("w_fset", W_Property),
getter=interp2app(W_Property.getter),
setter=interp2app(W_Property.setter),
deleter=interp2app(W_Property.deleter),
)
# This allows there to be a __doc__ of the property type and a __doc__
# descriptor for the instances.
W_Property.typedef.rawdict["__doc__"] = interp_attrproperty_w("w_doc", W_Property)
self.readable = True
self._init(space)
self._reader_reset_buf()
self.state = STATE_OK
W_BufferedReader.typedef = TypeDef(
'BufferedReader', W_BufferedIOBase.typedef,
__new__ = generic_new_descr(W_BufferedReader),
__init__ = interp2app(W_BufferedReader.descr_init),
__module__ = "_io",
read = interp2app(W_BufferedReader.read_w),
peek = interp2app(W_BufferedReader.peek_w),
read1 = interp2app(W_BufferedReader.read1_w),
raw = interp_attrproperty_w("w_raw", cls=W_BufferedReader),
# from the mixin class
__repr__ = interp2app(W_BufferedReader.repr_w),
readable = interp2app(W_BufferedReader.readable_w),
writable = interp2app(W_BufferedReader.writable_w),
seekable = interp2app(W_BufferedReader.seekable_w),
seek = interp2app(W_BufferedReader.seek_w),
tell = interp2app(W_BufferedReader.tell_w),
close = interp2app(W_BufferedReader.close_w),
flush = interp2app(W_BufferedReader.simple_flush_w), # Not flush_w!
detach = interp2app(W_BufferedReader.detach_w),
truncate = interp2app(W_BufferedReader.truncate_w),
fileno = interp2app(W_BufferedReader.fileno_w),
isatty = interp2app(W_BufferedReader.isatty_w),
closed = GetSetProperty(W_BufferedReader.closed_get_w),
of input for each iteration, such as a file object or a list. The
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()
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))
W_Property.typedef = TypeDef(
'property',
__doc__=
'''property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for deleting, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "I am the 'x' property.")''',
__new__=generic_new_descr(W_Property),
__init__=interp2app(W_Property.init),
__get__=interp2app(W_Property.get),
__set__=interp2app(W_Property.set),
__delete__=interp2app(W_Property.delete),
fdel=interp_attrproperty_w('w_fdel', W_Property),
fget=interp_attrproperty_w('w_fget', W_Property),
fset=interp_attrproperty_w('w_fset', W_Property),
getter=interp2app(W_Property.getter),
setter=interp2app(W_Property.setter),
deleter=interp2app(W_Property.deleter),
)
# This allows there to be a __doc__ of the property type and a __doc__
# descriptor for the instances.
W_Property.typedef.rawdict['__doc__'] = interp_attrproperty_w(
'w_doc', W_Property)
def fget_string_position(space, self):
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):
compatVar = VT_String(cursor, cursor.arraySize, MAX_STRING_CHARS)
# call stored procedure
cursor._call(space, "dbms_utility.db_version",
None, space.newlist([space.wrap(versionVar),
space.wrap(compatVar)]))
# retrieve value
self.w_version = versionVar.getValue(space, 0)
return self.w_version
W_Connection.typedef = TypeDef(
"Connection",
__new__ = interp2app(W_Connection.descr_new.im_func,
unwrap_spec=W_Connection.descr_new.unwrap_spec),
username = interp_attrproperty_w('w_username', W_Connection),
password = interp_attrproperty_w('w_password', W_Connection),
tnsentry = interp_attrproperty_w('w_tnsentry', W_Connection),
close = interp2app(W_Connection.close),
commit = interp2app(W_Connection.commit),
rollback = interp2app(W_Connection.rollback),
cursor = interp2app(W_Connection.newCursor),
encoding = GetSetProperty(W_Connection.get_encoding),
nationalencoding = GetSetProperty(W_Connection.get_nationalencoding),
maxBytesPerCharacter = GetSetProperty(W_Connection.get_maxbytespercharacter),
version = GetSetProperty(W_Connection.get_version),
)
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(
return space.newlist(self.fetchVariables)
W_Cursor.typedef = TypeDef(
'Cursor',
execute=interp2app(W_Cursor.execute),
executemany=interp2app(W_Cursor.executemany),
prepare=interp2app(W_Cursor.prepare),
fetchone=interp2app(W_Cursor.fetchone),
fetchmany=interp2app(W_Cursor.fetchmany),
fetchall=interp2app(W_Cursor.fetchall),
close=interp2app(W_Cursor.close),
bindnames=interp2app(W_Cursor.bindnames),
callfunc=interp2app(W_Cursor.callfunc),
callproc=interp2app(W_Cursor.callproc),
var=interp2app(W_Cursor.var),
arrayvar=interp2app(W_Cursor.arrayvar),
setinputsizes=interp2app(W_Cursor.setinputsizes),
setoutputsize=interp2app(W_Cursor.setoutputsize),
__iter__=interp2app(W_Cursor.descr_iter),
next=interp2app(W_Cursor.descr_next),
arraysize=GetSetProperty(W_Cursor.arraysize_get, W_Cursor.arraysize_set),
bindarraysize=GetSetProperty(W_Cursor.bindarraysize_get,
W_Cursor.bindarraysize_set),
rowcount=interp_attrproperty('rowCount', W_Cursor),
statement=interp_attrproperty_w('w_statement', W_Cursor),
bindvars=GetSetProperty(W_Cursor.bindvars_get),
fetchvars=GetSetProperty(W_Cursor.fetchvars_get),
description=GetSetProperty(W_Cursor.getDescription),
)
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):
self.space = srepat.space
w_strict = None,
):
"""
csv_writer = csv.writer(fileobj [, dialect='excel']
[optional keyword args])
for row in sequence:
csv_writer.writerow(row)
[or]
csv_writer = csv.writer(fileobj [, dialect='excel']
[optional keyword args])
csv_writer.writerows(rows)
The \"fileobj\" argument can be any object that supports the file API."""
dialect = _build_dialect(space, w_dialect, w_delimiter, w_doublequote,
w_escapechar, w_lineterminator, w_quotechar,
w_quoting, w_skipinitialspace, w_strict)
return W_Writer(space, dialect, w_fileobj)
W_Writer.typedef = TypeDef(
'_csv.writer',
dialect = interp_attrproperty_w('dialect', W_Writer),
writerow = interp2app(W_Writer.writerow),
writerows = interp2app(W_Writer.writerows),
__doc__ = """CSV writer
Writer objects are responsible for generating tabular data
in CSV format from sequence input.""")
W_Writer.typedef.acceptable_as_base_class = False
# allocate version and compatibility variables
versionVar = VT_String(cursor, cursor.arraySize, MAX_STRING_CHARS)
compatVar = VT_String(cursor, cursor.arraySize, MAX_STRING_CHARS)
# call stored procedure
cursor._call(
space, "dbms_utility.db_version", None,
space.newlist([space.wrap(versionVar),
space.wrap(compatVar)]))
# retrieve value
self.w_version = versionVar.getValue(space, 0)
return self.w_version
W_Connection.typedef = TypeDef(
"Connection",
__new__=interp2app(W_Connection.descr_new.im_func),
username=interp_attrproperty_w('w_username', W_Connection),
password=interp_attrproperty_w('w_password', W_Connection),
tnsentry=interp_attrproperty_w('w_tnsentry', W_Connection),
close=interp2app(W_Connection.close),
commit=interp2app(W_Connection.commit),
rollback=interp2app(W_Connection.rollback),
cursor=interp2app(W_Connection.newCursor),
encoding=GetSetProperty(W_Connection.get_encoding),
nationalencoding=GetSetProperty(W_Connection.get_nationalencoding),
maxBytesPerCharacter=GetSetProperty(W_Connection.get_maxbytespercharacter),
version=GetSetProperty(W_Connection.get_version),
)
raise operationerrfmt(space.w_TypeError, msg, w_dtype)
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),
)
self.readable = True
self._init(space)
self._reader_reset_buf()
self.state = STATE_OK
W_BufferedReader.typedef = TypeDef(
'BufferedReader', W_BufferedIOBase.typedef,
__new__ = generic_new_descr(W_BufferedReader),
__init__ = interp2app(W_BufferedReader.descr_init),
__module__ = "_io",
read = interp2app(W_BufferedReader.read_w),
peek = interp2app(W_BufferedReader.peek_w),
read1 = interp2app(W_BufferedReader.read1_w),
raw = interp_attrproperty_w("w_raw", cls=W_BufferedReader),
# from the mixin class
__repr__ = interp2app(W_BufferedReader.repr_w),
readable = interp2app(W_BufferedReader.readable_w),
writable = interp2app(W_BufferedReader.writable_w),
seekable = interp2app(W_BufferedReader.seekable_w),
seek = interp2app(W_BufferedReader.seek_w),
tell = interp2app(W_BufferedReader.tell_w),
close = interp2app(W_BufferedReader.close_w),
flush = interp2app(W_BufferedReader.simple_flush_w), # Not flush_w!
detach = interp2app(W_BufferedReader.detach_w),
truncate = interp2app(W_BufferedReader.truncate_w),
fileno = interp2app(W_BufferedReader.fileno_w),
isatty = interp2app(W_BufferedReader.isatty_w),
closed = GetSetProperty(W_BufferedReader.closed_get_w),
raise
w_type = w_objtype
if not space.is_true(space.issubtype(w_type, w_starttype)):
raise OperationError(space.w_TypeError,
space.wrap("super(type, obj): "
"obj must be an instance or subtype of type"))
# XXX the details of how allocate_instance() should be used are not
# really well defined
w_result = space.allocate_instance(W_Super, w_subtype)
W_Super.__init__(w_result, space, w_starttype, w_type, w_obj_or_type)
return w_result
W_Super.typedef = TypeDef(
'super',
__new__ = interp2app(descr_new_super),
__thisclass__ = interp_attrproperty_w("w_starttype", W_Super),
__getattribute__ = interp2app(W_Super.getattribute),
__get__ = interp2app(W_Super.get),
__doc__ = """super(type) -> unbound super object
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
def meth(self, arg):
super(C, self).meth(arg)"""
)
class W_Property(W_Root):
