File: module2.py

package info (click to toggle)
logilab-astng 0.24.3-2
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd
  • size: 700 kB
  • ctags: 1,300
  • sloc: python: 7,563; makefile: 56; sh: 15
file content (135 lines) | stat: -rw-r--r-- 1,828 bytes parent folder | download
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
from data.module import YO, YOUPI
import data


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 `1`
b = (1) | (((2) & (3)) ^ (8))
bb = ((1) | (two)) | (6)
ccc = ((one) & (two)) & (three)
dddd = ((x) ^ (o)) ^ (r)
exec 'c = 3'
exec 'c = 3' in {}, {}

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 >> stream, 'bonjour'
print >> stream, 'salut',

def make_class(any, base=data.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)