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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
from data_py3.module import YO, YOUPI
import data_py3
class Specialization(YOUPI, YO):
pass
class Metaclass(type):
pass
class Interface:
pass
class MyIFace(Interface):
pass
class AnotherIFace(Interface):
pass
class MyException(Exception):
pass
class MyError(MyException):
pass
class AbstractClass(object):
def to_override(self, whatever):
raise NotImplementedError()
def return_something(self, param):
if param:
return 'toto'
return
class Concrete0:
__implements__ = MyIFace
class Concrete1:
__implements__ = (MyIFace, AnotherIFace)
class Concrete2:
__implements__ = (MyIFace, AnotherIFace)
class Concrete23(Concrete1):
pass
del YO.member
del YO
[SYN1, SYN2] = (Concrete0, Concrete1)
assert repr(1)
b = (1) | (((2) & (3)) ^ (8))
bb = ((1) | (two)) | (6)
ccc = ((one) & (two)) & (three)
dddd = ((x) ^ (o)) ^ (r)
exec('c = 3')
exec('c = 3', {}, {})
def raise_string(a=2, *args, **kwargs):
raise Exception('yo')
yield 'coucou'
yield
a = (b) + (2)
c = (b) * (2)
c = (b) / (2)
c = (b) // (2)
c = (b) - (2)
c = (b) % (2)
c = (b) ** (2)
c = (b) << (2)
c = (b) >> (2)
c = ~b
c = not b
d = [c]
e = d[:]
e = d[a:b:c]
raise_string(*args, **kwargs)
print('bonjour', file=stream)
print('salut', end=' ', file=stream)
def make_class(any, base=data_py3.module.YO, *args, **kwargs):
"""check base is correctly resolved to Concrete0"""
class Aaaa(base):
"""dynamic class"""
return Aaaa
from os.path import abspath
import os as myos
class A:
pass
class A(A):
pass
def generator():
"""A generator."""
yield
def not_a_generator():
"""A function that contains generator, but is not one."""
def generator():
yield
genl = lambda : (yield)
def with_metaclass(meta, *bases):
return meta('NewBase', bases, {})
class NotMetaclass(with_metaclass(Metaclass)):
pass
|
