1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
# mode: run
# tag: annotation_typing, pure3.0, mypy
import cython
is_compiled = cython.compiled
MyUnion = cython.union(n=cython.int, x=cython.double)
MyStruct = cython.struct(is_integral=cython.bint, data=MyUnion)
MyStruct2 = cython.typedef(MyStruct[2]) # type: cython.StructType
@cython.annotation_typing(False)
def test_annotation_typing(x: cython.int) -> cython.int:
"""
>>> test_annotation_typing("Petits pains")
'Petits pains'
"""
return x
@cython.ccall # cpdef => C return type
def test_return_type(n: cython.int) -> cython.double:
"""
>>> test_return_type(389)
389.0
"""
assert cython.typeof(n) == 'int', cython.typeof(n)
return n if is_compiled else float(n)
def test_struct(n: cython.int, x: cython.double) -> MyStruct2:
"""
>>> test_struct(389, 1.64493)
(389, 1.64493)
>>> d = test_struct.__annotations__
>>> sorted(d)
['n', 'return', 'x']
"""
assert cython.typeof(n) == 'int', cython.typeof(n)
if is_compiled:
assert cython.typeof(x) == 'double', cython.typeof(x) # C double
else:
assert cython.typeof(x) == 'float', cython.typeof(x) # Python float
a = cython.declare(MyStruct2)
a[0] = MyStruct(is_integral=True, data=MyUnion(n=n))
a[1] = MyStruct(is_integral=False, data={'x': x})
return a[0].data.n, a[1].data.x
@cython.ccall
def c_call(x) -> cython.double:
return x
def call_ccall(x):
"""
Test that a declared return type is honoured when compiled.
>>> result, return_type = call_ccall(1)
>>> (not is_compiled and 'double') or return_type
'double'
>>> (is_compiled and 'int') or return_type
'int'
>>> (not is_compiled and 1.0) or result
1.0
>>> (is_compiled and 1) or result
1
"""
ret = c_call(x)
return ret, cython.typeof(ret)
@cython.cfunc
@cython.inline
def cdef_inline(x) -> cython.double:
return x + 1
def call_cdef_inline(x):
"""
>>> result, return_type = call_cdef_inline(1)
>>> (not is_compiled and 'float') or type(result).__name__
'float'
>>> (not is_compiled and 'double') or return_type
'double'
>>> (is_compiled and 'int') or return_type
'int'
>>> result == 2.0 or result
True
"""
ret = cdef_inline(x)
return ret, cython.typeof(ret)
@cython.cfunc
def test_cdef_return_object(x: object) -> object:
"""
Test support of python object in annotations
>>> test_cdef_return_object(3)
3
>>> test_cdef_return_object(None)
Traceback (most recent call last):
...
RuntimeError
"""
if x:
return x
else:
raise RuntimeError()
|
