FilesExpand file tree

 master

/

flyweight.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

125 lines (95 loc) · 3.13 KB

 master

/

flyweight.py

Copy path

Top

File metadata and controls

• Code
• Blame

125 lines (95 loc) · 3.13 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

#!/usr/bin/env python

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

"""

*References:

http://codesnipers.com/?q=python-flyweights

*TL;DR80

Minimizes memory usage by sharing data with other similar objects.

"""

import weakref

class FlyweightMeta(type):

def __new__(mcs, name, parents, dct):

"""

Set up object pool

:param name: class name

:param parents: class parents

:param dct: dict: includes class attributes, class methods,

static methods, etc

:return: new class

"""

dct['pool'] = weakref.WeakValueDictionary()

return super(FlyweightMeta, mcs).__new__(mcs, name, parents, dct)

@staticmethod

def _serialize_params(cls, *args, **kwargs):

"""

Serialize input parameters to a key.

Simple implementation is just to serialize it as a string

"""

args_list = list(map(str, args))

args_list.extend([str(kwargs), cls.__name__])

key = ''.join(args_list)

return key

def __call__(cls, *args, **kwargs):

key = FlyweightMeta._serialize_params(cls, *args, **kwargs)

pool = getattr(cls, 'pool', {})

instance = pool.get(key)

if instance is None:

instance = super(FlyweightMeta, cls).__call__(*args, **kwargs)

pool[key] = instance

return instance

class Card(object):

"""The object pool. Has builtin reference counting"""

_CardPool = weakref.WeakValueDictionary()

"""Flyweight implementation. If the object exists in the

pool just return it (instead of creating a new one)"""

def __new__(cls, value, suit):

obj = Card._CardPool.get(value + suit)

if not obj:

obj = object.__new__(cls)

Card._CardPool[value + suit] = obj

obj.value, obj.suit = value, suit

return obj

# def __init__(self, value, suit):

# self.value, self.suit = value, suit

def __repr__(self):

return "<Card: %s%s>" % (self.value, self.suit)

def with_metaclass(meta, *bases):

""" Provide python cross-version metaclass compatibility. """

return meta("NewBase", bases, {})

class Card2(with_metaclass(FlyweightMeta)):

def __init__(self, *args, **kwargs):

# print('Init {}: {}'.format(self.__class__, (args, kwargs)))

pass

if __name__ == '__main__':

# comment __new__ and uncomment __init__ to see the difference

c1 = Card('9', 'h')

c2 = Card('9', 'h')

print(c1, c2)

print(c1 == c2, c1 is c2)

print(id(c1), id(c2))

c1.temp = None

c3 = Card('9', 'h')

print(hasattr(c3, 'temp'))

c1 = c2 = c3 = None

c3 = Card('9', 'h')

print(hasattr(c3, 'temp'))

# Tests with metaclass

instances_pool = getattr(Card2, 'pool')

cm1 = Card2('10', 'h', a=1)

cm2 = Card2('10', 'h', a=1)

cm3 = Card2('10', 'h', a=2)

assert (cm1 == cm2) != cm3

assert (cm1 is cm2) is not cm3

assert len(instances_pool) == 2

del cm1

assert len(instances_pool) == 2

del cm2

assert len(instances_pool) == 1

del cm3

assert len(instances_pool) == 0

### OUTPUT ###

# (<Card: 9h>, <Card: 9h>)

# (True, True)

# (31903856, 31903856)

# True

# False