Author: Ronan Lamy <[email protected]>
Branch:
Changeset: r89499:77a7751e0e13
Date: 2017-01-11 17:41 +0000
http://bitbucket.org/pypy/pypy/changeset/77a7751e0e13/
Log: Remove more uses of api.XXX magic
diff --git a/pypy/module/cpyext/cdatetime.py b/pypy/module/cpyext/cdatetime.py
--- a/pypy/module/cpyext/cdatetime.py
+++ b/pypy/module/cpyext/cdatetime.py
@@ -118,12 +118,16 @@
""" % (type_name,)))
except OperationError:
return 0
+ return check, check_exact
-make_check_function("PyDateTime_Check", "datetime")
-make_check_function("PyDate_Check", "date")
-make_check_function("PyTime_Check", "time")
-make_check_function("PyDelta_Check", "timedelta")
-make_check_function("PyTZInfo_Check", "tzinfo")
+PyDateTime_Check, PyDateTime_CheckExact = make_check_function(
+ "PyDateTime_Check", "datetime")
+PyDate_Check, PyDate_CheckExact = make_check_function("PyDate_Check", "date")
+PyTime_Check, PyTime_CheckExact = make_check_function("PyTime_Check", "time")
+PyDelta_Check, PyDelta_CheckExact = make_check_function(
+ "PyDelta_Check", "timedelta")
+PyTZInfo_Check, PyTZInfo_CheckExact = make_check_function(
+ "PyTZInfo_Check", "tzinfo")
# Constructors. They are better used as macros.
diff --git a/pypy/module/cpyext/test/test_classobject.py
b/pypy/module/cpyext/test/test_classobject.py
--- a/pypy/module/cpyext/test/test_classobject.py
+++ b/pypy/module/cpyext/test/test_classobject.py
@@ -1,9 +1,13 @@
+from pypy.interpreter.function import Function
from pypy.module.cpyext.test.test_api import BaseApiTest
from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase
-from pypy.interpreter.function import Function, Method
+from pypy.module.cpyext.classobject import (
+ PyClass_Check, PyClass_New, PyInstance_Check, PyInstance_New,
+ PyInstance_NewRaw, _PyInstance_Lookup)
+from pypy.module.cpyext.object import PyObject_GetAttr
class TestClassObject(BaseApiTest):
- def test_newinstance(self, space, api):
+ def test_newinstance(self, space):
w_class = space.appexec([], """():
class C:
x = None
@@ -14,23 +18,23 @@
return C
""")
- assert api.PyClass_Check(w_class)
+ assert PyClass_Check(space, w_class)
- w_instance = api.PyInstance_NewRaw(w_class, None)
- assert api.PyInstance_Check(w_instance)
+ w_instance = PyInstance_NewRaw(space, w_class, None)
+ assert PyInstance_Check(space, w_instance)
assert space.getattr(w_instance, space.wrap('x')) is space.w_None
- w_instance = api.PyInstance_NewRaw(w_class, space.wrap(dict(a=3)))
+ w_instance = PyInstance_NewRaw(space, w_class, space.wrap(dict(a=3)))
assert space.getattr(w_instance, space.wrap('x')) is space.w_None
assert space.unwrap(space.getattr(w_instance, space.wrap('a'))) == 3
- w_instance = api.PyInstance_New(w_class,
+ w_instance = PyInstance_New(space, w_class,
space.wrap((3,)),
space.wrap(dict(y=2)))
assert space.unwrap(space.getattr(w_instance, space.wrap('x'))) == 1
assert space.unwrap(space.getattr(w_instance, space.wrap('y'))) == 2
assert space.unwrap(space.getattr(w_instance, space.wrap('args'))) ==
(3,)
- def test_lookup(self, space, api):
+ def test_lookup(self, space):
w_instance = space.appexec([], """():
class C:
def __init__(self):
@@ -39,25 +43,26 @@
return C()
""")
- assert api.PyInstance_Check(w_instance)
- assert api.PyObject_GetAttr(w_instance, space.wrap('x')) is
space.w_None
- assert api._PyInstance_Lookup(w_instance, space.wrap('x')) is
space.w_None
- assert api._PyInstance_Lookup(w_instance, space.wrap('y')) is None
- assert not api.PyErr_Occurred()
+ assert PyInstance_Check(space, w_instance)
+ assert PyObject_GetAttr(space, w_instance, space.wrap('x')) is
space.w_None
+ assert _PyInstance_Lookup(space, w_instance, space.wrap('x')) is
space.w_None
+ assert _PyInstance_Lookup(space, w_instance, space.wrap('y')) is None
# getattr returns a bound method
- assert not isinstance(api.PyObject_GetAttr(w_instance,
space.wrap('f')), Function)
+ assert not isinstance(
+ PyObject_GetAttr(space, w_instance, space.wrap('f')), Function)
# _PyInstance_Lookup returns the raw descriptor
- assert isinstance(api._PyInstance_Lookup(w_instance, space.wrap('f')),
Function)
+ assert isinstance(
+ _PyInstance_Lookup(space, w_instance, space.wrap('f')), Function)
- def test_pyclass_new(self, space, api):
+ def test_pyclass_new(self, space):
w_bases = space.newtuple([])
w_dict = space.newdict()
w_name = space.wrap("C")
- w_class = api.PyClass_New(w_bases, w_dict, w_name)
+ w_class = PyClass_New(space, w_bases, w_dict, w_name)
assert not space.isinstance_w(w_class, space.w_type)
w_instance = space.call_function(w_class)
- assert api.PyInstance_Check(w_instance)
+ assert PyInstance_Check(space, w_instance)
assert space.is_true(space.call_method(space.builtin, "isinstance",
w_instance, w_class))
@@ -69,5 +74,6 @@
Py_INCREF(&PyClass_Type);
return (PyObject*)&PyClass_Type;
""")])
- class C: pass
+ class C:
+ pass
assert module.get_classtype() is type(C)
diff --git a/pypy/module/cpyext/test/test_codecs.py
b/pypy/module/cpyext/test/test_codecs.py
--- a/pypy/module/cpyext/test/test_codecs.py
+++ b/pypy/module/cpyext/test/test_codecs.py
@@ -1,14 +1,15 @@
# encoding: iso-8859-15
from pypy.module.cpyext.test.test_api import BaseApiTest
-from rpython.rtyper.lltypesystem import rffi, lltype
+from rpython.rtyper.lltypesystem import rffi
+from pypy.module.cpyext.codecs import (
+ PyCodec_IncrementalEncoder, PyCodec_IncrementalDecoder)
class TestCodecs(BaseApiTest):
- def test_incremental(self, space, api):
+ def test_incremental(self, space):
utf8 = rffi.str2charp('utf-8')
- w_encoder = api.PyCodec_IncrementalEncoder(utf8, None)
+ w_encoder = PyCodec_IncrementalEncoder(space, utf8, None)
w_encoded = space.call_method(w_encoder, 'encode',
space.wrap(u'späm'))
- w_decoder = api.PyCodec_IncrementalDecoder(utf8, None)
+ w_decoder = PyCodec_IncrementalDecoder(space, utf8, None)
w_decoded = space.call_method(w_decoder, 'decode', w_encoded)
assert space.unwrap(w_decoded) == u'späm'
rffi.free_charp(utf8)
-
diff --git a/pypy/module/cpyext/test/test_complexobject.py
b/pypy/module/cpyext/test/test_complexobject.py
--- a/pypy/module/cpyext/test/test_complexobject.py
+++ b/pypy/module/cpyext/test/test_complexobject.py
@@ -1,23 +1,23 @@
from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase
-from pypy.module.cpyext.test.test_api import BaseApiTest
+from pypy.module.cpyext.test.test_api import BaseApiTest, raises_w
+from pypy.module.cpyext.complexobject import (
+ PyComplex_FromDoubles, PyComplex_RealAsDouble, PyComplex_ImagAsDouble)
class TestComplexObject(BaseApiTest):
- def test_complexobject(self, space, api):
- w_value = api.PyComplex_FromDoubles(1.2, 3.4)
+ def test_complexobject(self, space):
+ w_value = PyComplex_FromDoubles(space, 1.2, 3.4)
assert space.unwrap(w_value) == 1.2+3.4j
- assert api.PyComplex_RealAsDouble(w_value) == 1.2
- assert api.PyComplex_ImagAsDouble(w_value) == 3.4
+ assert PyComplex_RealAsDouble(space, w_value) == 1.2
+ assert PyComplex_ImagAsDouble(space, w_value) == 3.4
- assert api.PyComplex_RealAsDouble(space.wrap(42)) == 42
- assert api.PyComplex_RealAsDouble(space.wrap(1.5)) == 1.5
- assert api.PyComplex_ImagAsDouble(space.wrap(1.5)) == 0.0
+ assert PyComplex_RealAsDouble(space, space.wrap(42)) == 42
+ assert PyComplex_RealAsDouble(space, space.wrap(1.5)) == 1.5
+ assert PyComplex_ImagAsDouble(space, space.wrap(1.5)) == 0.0
# cpython accepts anything for PyComplex_ImagAsDouble
- assert api.PyComplex_ImagAsDouble(space.w_None) == 0.0
- assert not api.PyErr_Occurred()
- assert api.PyComplex_RealAsDouble(space.w_None) == -1.0
- assert api.PyErr_Occurred()
- api.PyErr_Clear()
+ assert PyComplex_ImagAsDouble(space, space.w_None) == 0.0
+ with raises_w(space, TypeError):
+ PyComplex_RealAsDouble(space, space.w_None)
class AppTestCComplex(AppTestCpythonExtensionBase):
def test_AsCComplex(self):
diff --git a/pypy/module/cpyext/test/test_datetime.py
b/pypy/module/cpyext/test/test_datetime.py
--- a/pypy/module/cpyext/test/test_datetime.py
+++ b/pypy/module/cpyext/test/test_datetime.py
@@ -1,92 +1,96 @@
from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase
from pypy.module.cpyext.test.test_api import BaseApiTest
+from pypy.module.cpyext.cdatetime import *
+from pypy.module.cpyext.cdatetime import (
+ _PyDateTime_Import, _PyDateTime_FromDateAndTime, _PyDate_FromDate,
+ _PyTime_FromTime, _PyDelta_FromDelta)
import datetime
class TestDatetime(BaseApiTest):
- def test_date(self, space, api):
- date_api = api._PyDateTime_Import()
- w_date = api._PyDate_FromDate(2010, 06, 03, date_api.c_DateType)
+ def test_date(self, space):
+ date_api = _PyDateTime_Import(space)
+ w_date = _PyDate_FromDate(space, 2010, 06, 03, date_api.c_DateType)
assert space.unwrap(space.str(w_date)) == '2010-06-03'
- assert api.PyDate_Check(w_date)
- assert api.PyDate_CheckExact(w_date)
+ assert PyDate_Check(space, w_date)
+ assert PyDate_CheckExact(space, w_date)
- assert api.PyDateTime_GET_YEAR(w_date) == 2010
- assert api.PyDateTime_GET_MONTH(w_date) == 6
- assert api.PyDateTime_GET_DAY(w_date) == 3
+ assert PyDateTime_GET_YEAR(space, w_date) == 2010
+ assert PyDateTime_GET_MONTH(space, w_date) == 6
+ assert PyDateTime_GET_DAY(space, w_date) == 3
- def test_time(self, space, api):
- date_api = api._PyDateTime_Import()
- w_time = api._PyTime_FromTime(23, 15, 40, 123456,
- space.w_None, date_api.c_TimeType)
+ def test_time(self, space):
+ date_api = _PyDateTime_Import(space)
+ w_time = _PyTime_FromTime(
+ space, 23, 15, 40, 123456, space.w_None, date_api.c_TimeType)
assert space.unwrap(space.str(w_time)) == '23:15:40.123456'
- assert api.PyTime_Check(w_time)
- assert api.PyTime_CheckExact(w_time)
+ assert PyTime_Check(space, w_time)
+ assert PyTime_CheckExact(space, w_time)
- assert api.PyDateTime_TIME_GET_HOUR(w_time) == 23
- assert api.PyDateTime_TIME_GET_MINUTE(w_time) == 15
- assert api.PyDateTime_TIME_GET_SECOND(w_time) == 40
- assert api.PyDateTime_TIME_GET_MICROSECOND(w_time) == 123456
+ assert PyDateTime_TIME_GET_HOUR(space, w_time) == 23
+ assert PyDateTime_TIME_GET_MINUTE(space, w_time) == 15
+ assert PyDateTime_TIME_GET_SECOND(space, w_time) == 40
+ assert PyDateTime_TIME_GET_MICROSECOND(space, w_time) == 123456
- def test_datetime(self, space, api):
- date_api = api._PyDateTime_Import()
- w_date = api._PyDateTime_FromDateAndTime(
- 2010, 06, 03, 23, 15, 40, 123456,
- space.w_None, date_api.c_DateTimeType)
+ def test_datetime(self, space):
+ date_api = _PyDateTime_Import(space)
+ w_date = _PyDateTime_FromDateAndTime(
+ space, 2010, 06, 03, 23, 15, 40, 123456, space.w_None,
+ date_api.c_DateTimeType)
assert space.unwrap(space.str(w_date)) == '2010-06-03 23:15:40.123456'
- assert api.PyDateTime_Check(w_date)
- assert api.PyDateTime_CheckExact(w_date)
- assert api.PyDate_Check(w_date)
- assert not api.PyDate_CheckExact(w_date)
+ assert PyDateTime_Check(space, w_date)
+ assert PyDateTime_CheckExact(space, w_date)
+ assert PyDate_Check(space, w_date)
+ assert not PyDate_CheckExact(space, w_date)
- assert api.PyDateTime_GET_YEAR(w_date) == 2010
- assert api.PyDateTime_GET_MONTH(w_date) == 6
- assert api.PyDateTime_GET_DAY(w_date) == 3
- assert api.PyDateTime_DATE_GET_HOUR(w_date) == 23
- assert api.PyDateTime_DATE_GET_MINUTE(w_date) == 15
- assert api.PyDateTime_DATE_GET_SECOND(w_date) == 40
- assert api.PyDateTime_DATE_GET_MICROSECOND(w_date) == 123456
+ assert PyDateTime_GET_YEAR(space, w_date) == 2010
+ assert PyDateTime_GET_MONTH(space, w_date) == 6
+ assert PyDateTime_GET_DAY(space, w_date) == 3
+ assert PyDateTime_DATE_GET_HOUR(space, w_date) == 23
+ assert PyDateTime_DATE_GET_MINUTE(space, w_date) == 15
+ assert PyDateTime_DATE_GET_SECOND(space, w_date) == 40
+ assert PyDateTime_DATE_GET_MICROSECOND(space, w_date) == 123456
- def test_delta(self, space, api):
- date_api = api._PyDateTime_Import()
+ def test_delta(self, space):
+ date_api = _PyDateTime_Import(space)
w_delta = space.appexec(
[space.wrap(3), space.wrap(15)], """(days, seconds):
from datetime import timedelta
return timedelta(days, seconds)
""")
- assert api.PyDelta_Check(w_delta)
- assert api.PyDelta_CheckExact(w_delta)
+ assert PyDelta_Check(space, w_delta)
+ assert PyDelta_CheckExact(space, w_delta)
- w_delta = api._PyDelta_FromDelta(10, 20, 30, True,
date_api.c_DeltaType)
- assert api.PyDelta_Check(w_delta)
- assert api.PyDelta_CheckExact(w_delta)
+ w_delta = _PyDelta_FromDelta(space, 10, 20, 30, True,
date_api.c_DeltaType)
+ assert PyDelta_Check(space, w_delta)
+ assert PyDelta_CheckExact(space, w_delta)
- assert api.PyDateTime_DELTA_GET_DAYS(w_delta) == 10
- assert api.PyDateTime_DELTA_GET_SECONDS(w_delta) == 20
- assert api.PyDateTime_DELTA_GET_MICROSECONDS(w_delta) == 30
+ assert PyDateTime_DELTA_GET_DAYS(space, w_delta) == 10
+ assert PyDateTime_DELTA_GET_SECONDS(space, w_delta) == 20
+ assert PyDateTime_DELTA_GET_MICROSECONDS(space, w_delta) == 30
- def test_fromtimestamp(self, space, api):
+ def test_fromtimestamp(self, space):
w_args = space.wrap((0,))
- w_date = api.PyDate_FromTimestamp(w_args)
+ w_date = PyDate_FromTimestamp(space, w_args)
date = datetime.date.fromtimestamp(0)
assert space.unwrap(space.str(w_date)) == str(date)
w_args = space.wrap((0,))
- w_date = api.PyDateTime_FromTimestamp(w_args)
+ w_date = PyDateTime_FromTimestamp(space, w_args)
date = datetime.datetime.fromtimestamp(0)
assert space.unwrap(space.str(w_date)) == str(date)
- def test_tzinfo(self, space, api):
+ def test_tzinfo(self, space):
w_tzinfo = space.appexec(
[], """():
from datetime import tzinfo
return tzinfo()
""")
- assert api.PyTZInfo_Check(w_tzinfo)
- assert api.PyTZInfo_CheckExact(w_tzinfo)
- assert not api.PyTZInfo_Check(space.w_None)
+ assert PyTZInfo_Check(space, w_tzinfo)
+ assert PyTZInfo_CheckExact(space, w_tzinfo)
+ assert not PyTZInfo_Check(space, space.w_None)
class AppTestDatetime(AppTestCpythonExtensionBase):
def test_CAPI(self):
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
