FilesExpand file tree

 master

/

adapter.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

143 lines (108 loc) · 3.79 KB

 master

/

adapter.py

Copy path

Top

File metadata and controls

• Code
• Blame

143 lines (108 loc) · 3.79 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

#!/usr/bin/env python

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

"""

*What is this pattern about?

The Adapter pattern provides a different interface for a class. We can

think about it as a cable adapter that allows you to charge a phone

somewhere that has outlets in a different shape. Following this idea,

the Adapter pattern is useful to integrate classes that couldn't be

integrated due to their incompatible interfaces.

*What does this example do?

The example has classes that represent entities (Dog, Cat, Human, Car)

that make different noises. The Adapter class provides a different

interface to the original methods that make such noises. So the

original interfaces (e.g., bark and meow) are available under a

different name: make_noise.

*Where is the pattern used practically?

The Grok framework uses adapters to make objects work with a

particular API without modifying the objects themselves:

http://grok.zope.org/doc/current/grok_overview.html#adapters

*References:

http://ginstrom.com/scribbles/2008/11/06/generic-adapter-class-in-python/

https://sourcemaking.com/design_patterns/adapter

http://python-3-patterns-idioms-test.readthedocs.io/en/latest/ChangeInterface.html#adapter

*TL;DR80

Allows the interface of an existing class to be used as another interface.

"""

class Dog(object):

def __init__(self):

self.name = "Dog"

def bark(self):

return "woof!"

class Cat(object):

def __init__(self):

self.name = "Cat"

def meow(self):

return "meow!"

class Human(object):

def __init__(self):

self.name = "Human"

def speak(self):

return "'hello'"

class Car(object):

def __init__(self):

self.name = "Car"

def make_noise(self, octane_level):

return "vroom{0}".format("!" * octane_level)

class Adapter(object):

"""

Adapts an object by replacing methods.

Usage:

dog = Dog()

dog = Adapter(dog, make_noise=dog.bark)

>>> objects = []

>>> dog = Dog()

>>> print(dog.__dict__)

{'name': 'Dog'}

>>> objects.append(Adapter(dog, make_noise=dog.bark))

>>> print(objects[0].original_dict())

{'name': 'Dog'}

>>> cat = Cat()

>>> objects.append(Adapter(cat, make_noise=cat.meow))

>>> human = Human()

>>> objects.append(Adapter(human, make_noise=human.speak))

>>> car = Car()

>>> car_noise = lambda: car.make_noise(3)

>>> objects.append(Adapter(car, make_noise=car_noise))

>>> for obj in objects:

... print('A {} goes {}'.format(obj.name, obj.make_noise()))

A Dog goes woof!

A Cat goes meow!

A Human goes 'hello'

A Car goes vroom!!!

"""

def __init__(self, obj, **adapted_methods):

"""We set the adapted methods in the object's dict"""

self.obj = obj

self.__dict__.update(adapted_methods)

def __getattr__(self, attr):

"""All non-adapted calls are passed to the object"""

return getattr(self.obj, attr)

def original_dict(self):

"""Print original object dict"""

return self.obj.__dict__

def main():

objects = []

dog = Dog()

print(dog.__dict__)

objects.append(Adapter(dog, make_noise=dog.bark))

print(objects[0].__dict__)

print(objects[0].original_dict())

cat = Cat()

objects.append(Adapter(cat, make_noise=cat.meow))

human = Human()

objects.append(Adapter(human, make_noise=human.speak))

car = Car()

objects.append(Adapter(car, make_noise=lambda: car.make_noise(3)))

for obj in objects:

print("A {0} goes {1}".format(obj.name, obj.make_noise()))

if __name__ == "__main__":

main()

### OUTPUT ###

# {'name': 'Dog'}

# {'make_noise': <bound method Dog.bark of <__main__.Dog object at 0x7f631ba3fb00>>, 'obj': <__main__.Dog object at 0x7f631ba3fb00>}

# {'name': 'Dog'}

# A Dog goes woof!

# A Cat goes meow!

# A Human goes 'hello'

# A Car goes vroom!!!