FilesExpand file tree

 master

/

chain.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

182 lines (136 loc) · 4.26 KB

 master

/

chain.py

Copy path

Top

File metadata and controls

• Code
• Blame

182 lines (136 loc) · 4.26 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

#!/usr/bin/env python

# -*- coding: utf-8 -*-

"""http://www.dabeaz.com/coroutines/"""

from contextlib import contextmanager

import os

import sys

import time

import abc

class Handler(object):

__metaclass__ = abc.ABCMeta

def __init__(self, successor=None):

self._successor = successor

def handle(self, request):

res = self._handle(request)

if not res:

self._successor.handle(request)

@abc.abstractmethod

def _handle(self, request):

raise NotImplementedError('Must provide implementation in subclass.')

class ConcreteHandler1(Handler):

def _handle(self, request):

if 0 < request <= 10:

print('request {} handled in handler 1'.format(request))

return True

class ConcreteHandler2(Handler):

def _handle(self, request):

if 10 < request <= 20:

print('request {} handled in handler 2'.format(request))

return True

class ConcreteHandler3(Handler):

def _handle(self, request):

if 20 < request <= 30:

print('request {} handled in handler 3'.format(request))

return True

class DefaultHandler(Handler):

def _handle(self, request):

print('end of chain, no handler for {}'.format(request))

return True

class Client(object):

def __init__(self):

self.handler = ConcreteHandler1(

ConcreteHandler3(ConcreteHandler2(DefaultHandler())))

def delegate(self, requests):

for request in requests:

self.handler.handle(request)

def coroutine(func):

def start(*args, **kwargs):

cr = func(*args, **kwargs)

next(cr)

return cr

return start

@coroutine

def coroutine1(target):

while True:

request = yield

if 0 < request <= 10:

print('request {} handled in coroutine 1'.format(request))

else:

target.send(request)

@coroutine

def coroutine2(target):

while True:

request = yield

if 10 < request <= 20:

print('request {} handled in coroutine 2'.format(request))

else:

target.send(request)

@coroutine

def coroutine3(target):

while True:

request = yield

if 20 < request <= 30:

print('request {} handled in coroutine 3'.format(request))

else:

target.send(request)

@coroutine

def default_coroutine():

while True:

request = yield

print('end of chain, no coroutine for {}'.format(request))

class ClientCoroutine:

def __init__(self):

self.target = coroutine1(coroutine3(coroutine2(default_coroutine())))

def delegate(self, requests):

for request in requests:

self.target.send(request)

def timeit(func):

def count(*args, **kwargs):

start = time.time()

res = func(*args, **kwargs)

count._time = time.time() - start

return res

return count

@contextmanager

def suppress_stdout():

try:

stdout, sys.stdout = sys.stdout, open(os.devnull, 'w')

yield

finally:

sys.stdout = stdout

if __name__ == "__main__":

client1 = Client()

client2 = ClientCoroutine()

requests = [2, 5, 14, 22, 18, 3, 35, 27, 20]

client1.delegate(requests)

print('-' * 30)

client2.delegate(requests)

requests *= 10000

client1_delegate = timeit(client1.delegate)

client2_delegate = timeit(client2.delegate)

with suppress_stdout():

client1_delegate(requests)

client2_delegate(requests)

# lets check which is faster

print(client1_delegate._time, client2_delegate._time)

### OUTPUT ###

# request 2 handled in handler 1

# request 5 handled in handler 1

# request 14 handled in handler 2

# request 22 handled in handler 3

# request 18 handled in handler 2

# request 3 handled in handler 1

# end of chain, no handler for 35

# request 27 handled in handler 3

# request 20 handled in handler 2

# ------------------------------

# request 2 handled in coroutine 1

# request 5 handled in coroutine 1

# request 14 handled in coroutine 2

# request 22 handled in coroutine 3

# request 18 handled in coroutine 2

# request 3 handled in coroutine 1

# end of chain, no coroutine for 35

# request 27 handled in coroutine 3

# request 20 handled in coroutine 2

# (0.2369999885559082, 0.16199994087219238)