Initial commit

Author: robertbenson

.gitignore

@@ -0,0 +1,2 @@
+.idea/
+__pycache__/

monostate.py

@@ -0,0 +1,50 @@
+class Monostate:
+    """
+    The Monostate or Borg pattern. This is another way to represent the
+    Singleton pattern in Python. Instances will share the same state among
+    instances,they do not occupy the same memory location. Changes to the
+    shared state in one instance will be reflected in all instances. This
+    allows instances to share data while maintaining their individuality.
+    Usually, each instance will have its own dictionary, but the Borg
+    pattern modifies this so that all instances have the same dictionary.
+    While being individuals in their own right.  It is often referred to as
+    the Borg pattern in reference to The Borg in Star Trek. They all share
+    the same collective consciousness (in this case, _shared_state).
+    """
+
+    _shared_state = {'comment': 'Resistance is futile'}
+
+    def __init__(self):
+        self.__dict__ = self._shared_state
+
+
+def process_monostate():
+    """ This method will create 3 monostate objects.
+    """
+    borg1 = Monostate()
+    borg2 = Monostate()
+    borg3 = Monostate()
+
+    # these are different objects, different memory locations
+
+    print(f"different, expected for Monostate objects correctly: ")
+    print('Borg1 object:{}'.format(borg1))
+    print('Borg2 object:{}'.format(borg2))
+    print('Borg3 object:{}'.format(borg3))
+
+    borg1.counter = 27
+
+    # counter has been set to 27 for only 1 borg object, however all
+    # instances have the value 27 as they all share the same internal state.
+
+    print('Borg1 state:{}'.format(borg1.__dict__))
+    print('Borg2 state:{}'.format(borg2.__dict__))
+    print('Borg3 state:{}'.format(borg2.__dict__))
+
+
+def main():
+    process_monostate()
+
+
+if __name__ == '__main__':
+    main()

observer.py

@@ -0,0 +1,66 @@
+class Observer:
+    """Observer interface"""
+
+    def __init__(self):
+        self.name = None
+
+    def update(self):
+        print("Subclass must implement update()")
+
+
+class Subscriber(Observer):
+    """ Subscriber class implemented the Observer interface"""
+
+    def __init__(self, name: str) -> None:
+        super().__init__()
+        self.name = name
+
+    def update(self):
+        s = F"new youtube video released {self.name}"
+        print(s)
+        return s
+
+class Publisher:
+    def register(self, subscriber: Subscriber) -> None:
+        raise NotImplemented("Subclass must implement register()")
+
+    def unregister(self, subscriber: Subscriber) -> None:
+        raise NotImplemented("Subclass must implement unregister()")
+
+    def notify(self) -> None:
+        raise NotImplemented("Subclass must implement notify()")
+
+
+class ChannelPublisher(Publisher):
+    def __init__(self) -> None:
+        super().__init__()
+        self.subscribers = []  # observers
+
+    def register(self, subscriber: Subscriber) -> None:
+        self.subscribers.append(subscriber)
+
+    def unregister(self, subscriber: Subscriber) -> None:
+        self.subscribers.remove(subscriber)
+
+    def notify(self) -> None:
+        for subscriber in self.subscribers:
+            subscriber.update()
+
+
+def main():
+    bob = Subscriber("Bob")
+    cody = Subscriber("Cody")
+    channelPublisher = ChannelPublisher()
+
+    channelPublisher.register(bob)
+    channelPublisher.register(cody)
+    channelPublisher.notify()   # new youtube released, notify all
+    # subscribers/observers
+    channelPublisher.unregister(cody)
+    channelPublisher.notify()
+    channelPublisher.unregister(bob)
+    channelPublisher.notify()
+
+
+if __name__ == '__main__':
+    main()

readme.md

@@ -0,0 +1,56 @@
+# Using Classes for encapsulation compared to global variables
+
+This is quick reference for using alternatives to global variables. 
+It is not a guide as to which pattern is the best.
+
+The choice between using classes and encapsulation versus global variables depends on the specific requirements and design principles of your code. 
+
+In general, using classes and encapsulation is often considered a better practice than relying heavily on global variables. 
+
+## Modularity and Organisation:
+Classes allow you to encapsulate related data and behaviour into a single unit, promoting a modular and organised code structure.
+
+With global variables, it can be challenging to maintain a clear structure, and it's easier for variables to be modified unexpectedly, leading to potential bugs.
+
+## Code Reusability:
+Classes promote code reusability since you can create instances of a class in different parts of your code, and each instance can maintain its state independently. 
+
+
+Global variables can lead to code that is tightly coupled and less reusable, 
+as any part of the code can modify them, making it harder to reason about the behavior of the program.
+
+## Encapsulation:
+Encapsulation, a fundamental principle of object-oriented programming (OOP), 
+allows you to hide the implementation details of a class and expose only what is necessary. This helps in reducing dependencies between different parts of the code. 
+Global variables lack encapsulation, making it harder to control access to and modification of data, which can lead to unintended side effects.
+
+## Testing and Debugging:
+
+Classes make it easier to test and debug code because you can isolate and test individual components (methods) of a class independently.
+Global variables can make testing and debugging more challenging, as changes to global state can affect the behavior of different parts of the code.
+
+## Namespace Pollution:
+
+Overuse of global variables can lead to namespace pollution, 
+where variable names clash and cause unintended consequences.
+Classes provide a way to create isolated namespaces, 
+reducing the risk of naming conflicts.
+
+
+While classes and encapsulation are generally recommended, 
+it's essential to consider the specific requirements of your project. 
+In some cases, using global variables might be appropriate, but it's crucial to be mindful of the potential drawbacks mentioned above. Striking a balance and following good design principles will contribute to more maintainable and scalable code.
+
+
+## Singleton pattern
+
+
+The singleton pattern is a software design pattern that restricts the instantiation of a class to a singular instance. 
+One of the well-known "Gang of Four" design patterns. 
+A singleton implementation may use lazy initialization in which the instance is created when the static method is first invoked.
+
+## Monostate pattern
+
+The monostate pattern will create instances or objects with their own identity that all share the same internal state. 
+It is often referred to as the Borg pattern in reference to The Borg in Star Trek. 
+While being individuals in their own right, they all share the same collective consciousness or shared state.

singleton.py

@@ -0,0 +1,36 @@
+class Singleton:
+    """A singleton class. Lazy instantiation, it is only created when needed"""
+    __instance = None
+
+    def __init__(self):
+        if Singleton.__instance is not None:
+            raise Exception(
+                "Singleton already created, use get_instance() instead")
+        else:
+            Singleton.__instance = self
+
+    @staticmethod
+    def get_instance():
+        """ this static method is associated with the class"""
+        if Singleton.__instance is None:
+            Singleton()
+        return Singleton.__instance
+
+
+def main():
+    singleton1 = Singleton.get_instance()
+    singleton2 = Singleton.get_instance()
+    singleton3 = Singleton.get_instance()
+
+    print(singleton1)
+    print(singleton2)
+    print(singleton3)
+    if singleton1 == singleton2 == singleton3:
+        print("same memory location, pattern implemented correctly")
+
+    singleton1.counter = 27    # one instance is updated
+    print(singleton2.counter)  # change reflected in others
+
+
+if __name__ == '__main__':
+    main()

tests/__init__.py

@@ -0,0 +1,36 @@
+import unittest
+from monostate import Monostate
+
+
+class MyTestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.borg1 = Monostate()
+        cls.borg2 = Monostate()
+        cls.borg3 = Monostate()
+
+    def test_not_equal(self):
+        """ different instances, memory will be different"""
+
+        self.assertNotEqual(self.borg1, self.borg2)
+        self.assertNotEqual(self.borg1, self.borg3)
+
+    def test_multiple_instances(self):
+        """all instances share the same internal state, should be equal"""
+
+        self.borg1.some_variable = "Resistance is futile"
+
+        self.assertEqual(self.borg1.some_variable, self.borg2.some_variable)
+        self.assertEqual(self.borg1.some_variable, self.borg3.some_variable)
+
+    def test_same_internal_state_dict(self):
+        """all instances share the same internal state, should be equal
+        verify __dict__ are the same for all instances"""
+
+        self.borg1.counter = 27
+        self.assertEqual(id(self.borg1.__dict__), id(self.borg2.__dict__))
+        self.assertEqual(id(self.borg2.__dict__), id(self.borg3.__dict__))
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_monostate.py

@@ -0,0 +1,44 @@
+import unittest
+from observer import ChannelPublisher
+from observer import Subscriber
+
+
+class MyTestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        print("setUpClass")
+        cls.channelPublisher = ChannelPublisher()
+        cls.bob = Subscriber("Bob")
+        cls.FooBar = Subscriber("FooBar")
+
+    def test_register_2_observers(self):
+        """ register 2 observers """
+        self.channelPublisher.register(self.bob)
+        self.assertEqual(len(self.channelPublisher.subscribers), 1)
+
+        # register second observer
+        self.channelPublisher.register(self.FooBar)
+        self.assertEqual(len(self.channelPublisher.subscribers), 2)
+
+    def test_sequence(self):
+        """ register , unregister, notify"""
+        self.channelPublisher.notify()
+        self.channelPublisher.unregister(self.bob)
+        self.assertEqual(len(self.channelPublisher.subscribers), 1)
+        subscribers = self.channelPublisher.subscribers
+
+        for subscriber in self.channelPublisher.subscribers:
+            self.assertEqual(subscriber.name, "FooBar")
+            self.assertEqual(subscriber.update(),
+                             "new youtube video released FooBar")
+
+        # verify that bob has actually been removed
+        self.assertNotIn(self.bob, self.channelPublisher.subscribers)
+
+        self.channelPublisher.unregister(self.FooBar)
+        self.assertNotIn(self.FooBar, self.channelPublisher.subscribers)
+
+        # assert that no more subscibers are left
+        self.assertEqual(len(self.channelPublisher.subscribers), 0)
+
+

tests/test_observer.py

@@ -0,0 +1,38 @@
+import unittest
+from singleton import Singleton
+
+
+class MyTestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.s1 = Singleton.get_instance()
+        cls.s2 = Singleton.get_instance()
+        cls.s3 = Singleton.get_instance()
+
+    def test_equal(self):
+        """ same memory, instances will be same """
+
+        self.assertEqual(self.s1, self.s2)
+        self.assertEqual(self.s1, self.s3)
+
+    def test_multiple_instances(self):
+        """ all instances share the same internal state, should be equal """
+
+        self.s1.some_variable = "I'm the only one"
+
+        self.assertEqual(self.s1.some_variable, self.s2.some_variable)
+        self.assertEqual(self.s1.some_variable, self.s3.some_variable)
+
+    def test_incorrect_instantiation(self):
+        """the singleton can only be created with get_instance, if a singleton
+        is created using the __init__ an exception will be thrown.
+        Test to verify the exception is thrown correctly."""
+
+        with self.assertRaises(Exception) as context:
+            s4 = Singleton()
+        self.assertEqual(str(context.exception), "Singleton already created, "
+                                                 "use get_instance() instead")
+
+
+if __name__ == '__main__':
+    unittest.main()