FilesExpand file tree

 master

/

borg.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

110 lines (85 loc) · 3.21 KB

 master

/

borg.py

Copy path

Top

File metadata and controls

• Code
• Blame

110 lines (85 loc) · 3.21 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

"""

*What is this pattern about?

The Borg pattern (also known as the Monostate pattern) is a way to

implement singleton behavior, but instead of having only one instance

of a class, there are multiple instances that share the same state. In

other words, the focus is on sharing state instead of sharing instance

identity.

*What does this example do?

To understand the implementation of this pattern in Python, it is

important to know that, in Python, instance attributes are stored in a

attribute dictionary called __dict__. Usually, each instance will have

its own dictionary, but the Borg pattern modifies this so that all

instances have the same dictionary.

In this example, the __shared_state attribute will be the dictionary

shared between all instances, and this is ensured by assigning

__shared_state to the __dict__ variable when initializing a new

instance (i.e., in the __init__ method). Other attributes are usually

added to the instance's attribute dictionary, but, since the attribute

dictionary itself is shared (which is __shared_state), all other

attributes will also be shared.

*Where is the pattern used practically?

Sharing state is useful in applications like managing database connections:

https://github.com/onetwopunch/pythonDbTemplate/blob/master/database.py

*References:

- https://fkromer.github.io/python-pattern-references/design/#singleton

- https://learning.oreilly.com/library/view/python-cookbook/0596001673/ch05s23.html

- http://www.aleax.it/5ep.html

*TL;DR

Provides singleton-like behavior sharing state between instances.

"""

from typing import Dict

class Borg:

_shared_state: Dict[str, str] = {}

def __init__(self) -> None:

self.__dict__ = self._shared_state

class YourBorg(Borg):

def __init__(self, state: str = None) -> None:

super().__init__()

if state:

self.state = state

else:

# initiate the first instance with default state

if not hasattr(self, "state"):

self.state = "Init"

def __str__(self) -> str:

return self.state

def main():

"""

>>> rm1 = YourBorg()

>>> rm2 = YourBorg()

>>> rm1.state = 'Idle'

>>> rm2.state = 'Running'

>>> print('rm1: {0}'.format(rm1))

rm1: Running

>>> print('rm2: {0}'.format(rm2))

rm2: Running

# When the `state` attribute is modified from instance `rm2`,

# the value of `state` in instance `rm1` also changes

>>> rm2.state = 'Zombie'

>>> print('rm1: {0}'.format(rm1))

rm1: Zombie

>>> print('rm2: {0}'.format(rm2))

rm2: Zombie

# Even though `rm1` and `rm2` share attributes, the instances are not the same

>>> rm1 is rm2

False

# New instances also get the same shared state

>>> rm3 = YourBorg()

>>> print('rm1: {0}'.format(rm1))

rm1: Zombie

>>> print('rm2: {0}'.format(rm2))

rm2: Zombie

>>> print('rm3: {0}'.format(rm3))

rm3: Zombie

# A new instance can explicitly change the state during creation

>>> rm4 = YourBorg('Running')

>>> print('rm4: {0}'.format(rm4))

rm4: Running

# Existing instances reflect that change as well

>>> print('rm3: {0}'.format(rm3))

rm3: Running

"""

if __name__ == "__main__":

import doctest

doctest.testmod()