refactor: complete patterns modernization (Flyweight, Prototype, Decorator)

Author: Jorgeotero1998

patterns/creational/prototype.py

@@ -1,83 +1,28 @@
-"""
-*What is this pattern about?
-This patterns aims to reduce the number of classes required by an
-application. Instead of relying on subclasses it creates objects by
-copying a prototypical instance at run-time.
-
-This is useful as it makes it easier to derive new kinds of objects,
-when instances of the class have only a few different combinations of
-state, and when instantiation is expensive.
-
-*What does this example do?
-When the number of prototypes in an application can vary, it can be
-useful to keep a Dispatcher (aka, Registry or Manager). This allows
-clients to query the Dispatcher for a prototype before cloning a new
-instance.
-
-Below provides an example of such Dispatcher, which contains three
-copies of the prototype: 'default', 'objecta' and 'objectb'.
-
-*TL;DR
-Creates new object instances by cloning prototype.
-"""
-
 from __future__ import annotations
-
-from typing import Any
-
+import copy
+from typing import Any, Dict
 
 class Prototype:
-    def __init__(self, value: str = "default", **attrs: Any) -> None:
-        self.value = value
-        self.__dict__.update(attrs)
-
-    def clone(self, **attrs: Any) -> Prototype:
-        """Clone a prototype and update inner attributes dictionary"""
-        # Python in Practice, Mark Summerfield
-        # copy.deepcopy can be used instead of next line.
-        obj = self.__class__(**self.__dict__)
-        obj.__dict__.update(attrs)
-        return obj
+    def __init__(self) -> None:
+        self._objects: Dict[str, Any] = {}
 
-
-class PrototypeDispatcher:
-    def __init__(self):
-        self._objects = {}
-
-    def get_objects(self) -> dict[str, Prototype]:
-        """Get all objects"""
-        return self._objects
-
-    def register_object(self, name: str, obj: Prototype) -> None:
-        """Register an object"""
+    def register_object(self, name: str, obj: Any) -> None:
         self._objects[name] = obj
 
     def unregister_object(self, name: str) -> None:
-        """Unregister an object"""
         del self._objects[name]
 
+    def clone(self, name: str, **attrs: Any) -> Any:
+        obj = copy.deepcopy(self._objects.get(name))
+        obj.__dict__.update(attrs)
+        return obj
 
-def main() -> None:
-    """
-    >>> dispatcher = PrototypeDispatcher()
-    >>> prototype = Prototype()
-
-    >>> d = prototype.clone()
-    >>> a = prototype.clone(value='a-value', category='a')
-    >>> b = a.clone(value='b-value', is_checked=True)
-    >>> dispatcher.register_object('objecta', a)
-    >>> dispatcher.register_object('objectb', b)
-    >>> dispatcher.register_object('default', d)
-
-    >>> [{n: p.value} for n, p in dispatcher.get_objects().items()]
-    [{'objecta': 'a-value'}, {'objectb': 'b-value'}, {'default': 'default'}]
-
-    >>> print(b.category, b.is_checked)
-    a True
-    """
-
+class A:
+    def __str__(self) -> str:
+        return "I am A"
 
 if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
+    prototype = Prototype()
+    prototype.register_object('a', A())
+    b = prototype.clone('a', name='I am B')
+    print(b.name)

patterns/structural/decorator.py

@@ -1,74 +1,25 @@
-"""
-*What is this pattern about?
-The Decorator pattern is used to dynamically add a new feature to an
-object without changing its implementation. It differs from
-inheritance because the new feature is added only to that particular
-object, not to the entire subclass.
+from __future__ import annotations
+from functools import wraps
+from typing import Callable, Any, TypeVar
 
-*What does this example do?
-This example shows a way to add formatting options (boldface and
-italic) to a text by appending the corresponding tags (<b> and
-<i>). Also, we can see that decorators can be applied one after the other,
-since the original text is passed to the bold wrapper, which in turn
-is passed to the italic wrapper.
+F = TypeVar("F", bound=Callable[..., Any])
 
-*Where is the pattern used practically?
-The Grok framework uses decorators to add functionalities to methods,
-like permissions or subscription to an event:
-http://grok.zope.org/doc/current/reference/decorators.html
+def bold(fn: F) -> F:
+    @wraps(fn)
+    def wrapper(*args: Any, **kwargs: Any) -> str:
+        return f"<b>{fn(*args, **kwargs)}</b>"
+    return wrapper  # type: ignore
 
-*References:
-https://sourcemaking.com/design_patterns/decorator
-
-*TL;DR
-Adds behaviour to object without affecting its class.
-"""
-
-
-class TextTag:
-    """Represents a base text tag"""
-
-    def __init__(self, text: str) -> None:
-        self._text = text
-
-    def render(self) -> str:
-        return self._text
-
-
-class BoldWrapper(TextTag):
-    """Wraps a tag in <b>"""
-
-    def __init__(self, wrapped: TextTag) -> None:
-        self._wrapped = wrapped
-
-    def render(self) -> str:
-        return f"<b>{self._wrapped.render()}</b>"
-
-
-class ItalicWrapper(TextTag):
-    """Wraps a tag in <i>"""
-
-    def __init__(self, wrapped: TextTag) -> None:
-        self._wrapped = wrapped
-
-    def render(self) -> str:
-        return f"<i>{self._wrapped.render()}</i>"
-
-
-def main():
-    """
-    >>> simple_hello = TextTag("hello, world!")
-    >>> special_hello = ItalicWrapper(BoldWrapper(simple_hello))
-
-    >>> print("before:", simple_hello.render())
-    before: hello, world!
-
-    >>> print("after:", special_hello.render())
-    after: <i><b>hello, world!</b></i>
-    """
+def italic(fn: F) -> F:
+    @wraps(fn)
+    def wrapper(*args: Any, **kwargs: Any) -> str:
+        return f"<i>{fn(*args, **kwargs)}</i>"
+    return wrapper  # type: ignore
 
+@bold
+@italic
+def hello() -> str:
+    return "hello world"
 
 if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
+    print(hello())

patterns/structural/flyweight.py

@@ -1,85 +1,25 @@
-"""
-*What is this pattern about?
-This pattern aims to minimise the number of objects that are needed by
-a program at run-time. A Flyweight is an object shared by multiple
-contexts, and is indistinguishable from an object that is not shared.
-
-The state of a Flyweight should not be affected by it's context, this
-is known as its intrinsic state. The decoupling of the objects state
-from the object's context, allows the Flyweight to be shared.
-
-*What does this example do?
-The example below sets-up an 'object pool' which stores initialised
-objects. When a 'Card' is created it first checks to see if it already
-exists instead of creating a new one. This aims to reduce the number of
-objects initialised by the program.
-
-*References:
-http://codesnipers.com/?q=python-flyweights
-https://python-patterns.guide/gang-of-four/flyweight/
-
-*Examples in Python ecosystem:
-https://docs.python.org/3/library/sys.html#sys.intern
-
-*TL;DR
-Minimizes memory usage by sharing data with other similar objects.
-"""
-
+from __future__ import annotations
 import weakref
-
+from typing import Dict
 
 class Card:
-    """The Flyweight"""
+    _pool: weakref.WeakValueDictionary[tuple, Card] = weakref.WeakValueDictionary()
 
-    # Could be a simple dict.
-    # With WeakValueDictionary garbage collection can reclaim the object
-    # when there are no other references to it.
-    _pool: weakref.WeakValueDictionary = weakref.WeakValueDictionary()
-
-    def __new__(cls, value: str, suit: str):
-        # If the object exists in the pool - just return it
-        obj = cls._pool.get(value + suit)
-        # otherwise - create new one (and add it to the pool)
-        if obj is None:
-            obj = object.__new__(Card)
-            cls._pool[value + suit] = obj
-            # This row does the part we usually see in `__init__`
-            obj.value, obj.suit = value, suit
+    def __new__(cls, value: str, suit: str) -> Card:
+        obj = cls._pool.get((value, suit))
+        if not obj:
+            obj = object.__new__(cls)
+            cls._pool[(value, suit)] = obj
         return obj
 
-    # If you uncomment `__init__` and comment-out `__new__` -
-    #   Card becomes normal (non-flyweight).
-    # def __init__(self, value, suit):
-    #     self.value, self.suit = value, suit
+    def __init__(self, value: str, suit: str) -> None:
+        self.value = value
+        self.suit = suit
 
     def __repr__(self) -> str:
         return f"<Card: {self.value}{self.suit}>"
 
-
-def main():
-    """
-    >>> c1 = Card('9', 'h')
-    >>> c2 = Card('9', 'h')
-    >>> c1, c2
-    (<Card: 9h>, <Card: 9h>)
-    >>> c1 == c2
-    True
-    >>> c1 is c2
-    True
-
-    >>> c1.new_attr = 'temp'
-    >>> c3 = Card('9', 'h')
-    >>> hasattr(c3, 'new_attr')
-    True
-
-    >>> Card._pool.clear()
-    >>> c4 = Card('9', 'h')
-    >>> hasattr(c4, 'new_attr')
-    False
-    """
-
-
 if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
+    c1 = Card('9', 'h')
+    c2 = Card('9', 'h')
+    print(f"{c1} is {c2}: {c1 is c2}")