Borg pattern or just module with functions

Question

I was thinking about using Singleton pattern in my project, so I searched StackOverflow to find a pythonic way to implement it. I found this question with the accepted answer saying that "a module with functions (and not a class) would serve well as a singleton". On other hand the second answer had a suggestion to use the Borg pattern. For me using a module is a simple and straightforward solution, so I'd like to understand when using Borg is preferable.

Answer 1

The difference is that in the Borg pattern you'll have different objects whose attributes are the same while using the module version gets you one object (the module).

Also an object and a module are slightly different: you cannot pickle modules but you can pickle classes. Also, you can have operations on objects (>, <, +, -, etc.)

To be a bit off-topic: with some modification the Borg pattern can be used as a very simple Multiton:

class Multiton(object):
    __shared_states = {}

    def __init__(self, name):
        if not self.__shared_states.has_key(name):
            self.__shared_states[name] = {}

        self.__dict__ = self.__shared_states[name]

Answer 2

A singleton and a module represent only one instance, for all the application lifetime. This instance is kept instantiated, even when it's not needed.

The borg pattern is about shared state. Each client class will create a new instance of the borg, but that instance will be disposed when it's not needed anymore - it is a much more elegant approach.

Beyond that, it is much easier to subclass or mock a borg.

Answer 3

Could you use a static class instead? SO Question

i.e.

class Test(object):
    i = 3 # class (or static) variable
    @classmethod
    def g(cls, arg):
        # here we can use 'cls' instead of the class name (Test)
        if arg > cls.i:
            cls.i = arg # would the the same as  Test.i = arg1

Answer 4

I have one use case where borg pattern shines:

you cannot define function at the module level as a @property. If you want some common data (like config) returning dynamic properties, you can have it derived from Borg and then write property methods.