updates

Author: Sean-Bradley

facade/reports.py

@@ -4,14 +4,11 @@
 
 class Reports():
     "A Singleton Dictionary of Reported Events"
-    _instance = None
     _reports: dict[int, tuple[float, str]] = {}
     _row_id = 0
 
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = Reports
-        return cls._instance
+        return cls
 
     @classmethod
     def get_history(cls) -> dict:

facade/users.py

@@ -6,13 +6,10 @@
 
 class Users():
     "A Singleton Dictionary of Users"
-    _instance = None
     _users: dict[str, dict[str, str]] = {}
 
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = Users
-        return cls._instance
+        return cls
 
     @classmethod
     def register_user(cls, new_user: dict[str, str]) -> str:

facade/wallets.py

@@ -5,13 +5,10 @@
 
 class Wallets():
     "A Singleton Dictionary of User Wallets"
-    _instance = None
     _wallets: dict[str, Decimal] = {}
 
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = Wallets
-        return cls._instance
+        return cls
 
     @classmethod
     def create_wallet(cls, user_id: str) -> bool:

flyweight/flyweight_concept.py

@@ -16,13 +16,10 @@ def __init__(self, code: int) -> None:
 class FlyweightFactory():
     "Creating the FlyweightFactory as a singleton"
 
-    _instance = None
     _flyweights: dict[int, Flyweight]= {}
 
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = FlyweightFactory
-        return cls._instance
+        return cls
 
     @classmethod
     def get_flyweight(cls, code: int) -> Flyweight:

flyweight/flyweight_factory.py

@@ -5,13 +5,10 @@
 class FlyweightFactory():
     "Creating the FlyweightFactory as a singleton"
 
-    _instance = None
     _flyweights: dict[int, Flyweight] = {}
 
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = FlyweightFactory
-        return cls._instance
+        return cls
 
     @classmethod
     def get_flyweight(cls, code: int) -> Flyweight:

img/flyweight_example.svg

@@ -5,13 +5,10 @@
 class DataController(IDataController):
     "A Subject (a.k.a Observable)"
 
-    _instance = None
     _observers = set()
 
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = DataController
-        return cls._instance
+        return cls
 
     @classmethod
     def subscribe(cls, observer):

img/observer_example.svg

@@ -1,5 +1,13 @@
 # Singleton Design Pattern
 
+## Videos
+
+Section | Video Link
+-|-
+Overview | <a id="ytVideoLink" href="https://youtu.be/wc1b70LueGA" target="_blank" title="Overview"><img src="/img/yt_btn_sm.gif" alt="Overview"/></a> 
+Example Use Case | <a id="ytVideoLink" href="https://youtu.be/-F7OYXMpVJw" target="_blank" title="Use Case"><img src="/img/yt_btn_sm.gif" alt="Use Case"/></a> 
+Dictionary | <a id="ytVideoLink" href="https://youtu.be/L7IPuo6VOjo" target="_blank" title="Dictionary"><img src="/img/yt_btn_sm.gif" alt="Dictionary"/></a> 
+
 ## Book 
 
 Cover | Links |
@@ -8,7 +16,7 @@ Cover | Links |
 
 ## Overview
 
-Sometimes you need an object in an application where there is only one instance. A constant or static variable for example.
+Sometimes you need an object in an application where there is only one instance.
 
 You don't want there to be many versions, for example, you have a game with a score and you want to adjust it. You may have accidentally created several instances of the class holding the score object. Or, you may be opening a database connection, there is no need to create many, when you can use the existing one that is already in memory. You may want a logging component, and you want to ensure all classes use the same instance. So, every class could declare their own logger component, but behind the scenes, they all point to the same memory address (id).
 
@@ -99,7 +107,9 @@ The Dictionary is similar to a [List](/builder#python-list), except that the ite
 
 The Dictionary can store multiple `key:value` pairs, they can be changed, can be added and removed, can be re-ordered, can be pre-filled with `key:value` pairs when instantiated and is very flexible.
 
-Since Python 3.7, dictionaries are ordered in the same way that they are created and the keys are unique.
+Since Python 3.7, dictionaries are ordered in the same way that they are created. 
+
+The keys of the dictionary are unique.
 
 You can refer to the dictionary items by key, which will return the value.
 
@@ -147,8 +157,8 @@ PS> python
 
 ## Summary
 
-* To be a Singleton, there must only be one instance of the Singleton, no matter how many times, or in which class it was instantiated.
+* To be a Singleton, there must only be one copy of the Singleton, no matter how many times, or in which class it was instantiated.
 * You want the attributes or methods to be globally accessible across your application, so that other classes may be able to use the Singleton.
-* You can extend classes with a Singleton method, as I did with the leaderboard, but it still points to the same Singleton memory location regardless.
+* You can use Singletons in other classes, as I did with the leaderboard, and they will all use the same Singleton regardless.
 * You want controlled access to a sole instance.
 * For a class to act as a singleton, it should not contain any references to `self`.

observer/data_controller.py

@@ -3,13 +3,10 @@
 
 class Leaderboard():
     "The Leaderboard as a Singleton"
-    _instance = None
     _table = {}
 
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = Leaderboard
-        return cls._instance
+        return cls
 
     @classmethod
     def print(cls):

singleton/README.md

@@ -2,38 +2,34 @@
 "Singleton Concept Sample Code"
 import copy
 
-
 class Singleton():
     "The Singleton Class"
-    _instance = None
+    value = []
 
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = Singleton
-        return cls._instance
+        return cls
+
+    # def __init__(self):
+    #     print("in init")
+
+    @staticmethod
+    def static_method():
+        "Use @staticmethod if no inner variables required"
 
     @classmethod
     def class_method(cls):
-        "A class level method"
-
+        "Use @classmethod to access class level variables"
+        print(cls.value)
 
 # The Client
 # All uses of singleton point to the same memory address (id)
 print(f"id(Singleton)\t= {id(Singleton)}")
-print(f"id(Singleton())\t= {id(Singleton())}")
 
 OBJECT1 = Singleton()
 print(f"id(OBJECT1)\t= {id(OBJECT1)}")
 
 OBJECT2 = copy.deepcopy(OBJECT1)
 print(f"id(OBJECT2)\t= {id(OBJECT2)}")
 
-# And all singleton class methods will also all point to the same id
-print(
-    f"id(Singleton.class_method())\t= {id(Singleton.class_method())}")
-print(
-    f"id(Singleton().class_method())\t= {id(Singleton().class_method())}")
-print(
-    f"id(OBJECT1.class_method())\t= {id(OBJECT1.class_method())}")
-print(
-    f"id(OBJECT2.class_method())\t= {id(OBJECT2.class_method())}")
+OBJECT3 = Singleton()
+print(f"id(OBJECT1)\t= {id(OBJECT3)}")