Structural Design Patterns in Python

import json

class JsonView:
    def display(self):
        doc = {"text": "FOO"}
        print("Json object:", doc,'\n')

class TextView:
    def display(self):
        print("Text string:", "FOO",'\n')

class Adapter(JsonView):
    """
    The Adapter converts text string to json object
    """
    def __init__(self, adaptee: TextView) -> None:
        self.adaptee = adaptee

    def display(self, text: str):
        doc = {"text": text}
        print("Adapter:", doc,'\n')

if __name__ == "__main__":
    target = JsonView()
    target.display()

    adaptee = TextView()
    adaptee.display()

    adapter = Adapter(adaptee)
    adapter.display("BAR")

Json object: {'text': 'FOO'} 

Text string: FOO 

Adapter: {'text': 'BAR'}

from abc import ABC, abstractmethod

# Abstraction
class RemoteControl:
    """
    Xây dựng abstract interface, reference đến một đối tượng implementation (ở đây là device)
    """
    def __init__(self, device):
        self._device = device

    @abstractmethod
    def toggle_power(self):
        self._device.toggle_power()

    @abstractmethod
    def volume_up(self):
        self._device.volume_up()

    @abstractmethod
    def volume_down(self):
        self._device.volume_down()

# Implementation
class Device:
    """
    Xây dựng implementation interface
    """
    @abstractmethod
    def toggle_power(self):
        pass

    @abstractmethod
    def volume_up(self):
        pass

    @abstractmethod
    def volume_down(self):
        pass

# Concrete Implementations for Devices
class TV(Device):
    """
    Xây dựng một Concrete Implementation cụ thể, ở đây là TV
    """
    def toggle_power(self):
        print("TV: Toggling power")

    def volume_up(self):
        print("TV: Volume up")

    def volume_down(self):
        print("TV: Volume down")

class DVDPlayer(Device):
    """
    Thêm một Concrete Implementation khác, ở đây là DVD
    """
    def toggle_power(self):
        print("DVD Player: Toggling power")

    def volume_up(self):
        print("DVD Player: Volume up")

    def volume_down(self):
        print("DVD Player: Volume down")

# Abstraction and Refined Abstraction
class BasicRemoteControl(RemoteControl):
    def toggle_power(self):
        print("Basic Remote: Press power button")
        super().toggle_power()

class AdvancedRemoteControl(RemoteControl):
    """
    Mở rộng abstract với các method khác.
    """
    def mute(self):
        print("Advanced Remote: Mute button pressed")
        self._device.volume_down()

# Client Code
if __name__ == "__main__":
    tv = TV()
    dvd_player = DVDPlayer()

    basic_remote_tv = BasicRemoteControl(tv)
    advanced_remote_dvd = AdvancedRemoteControl(dvd_player)

    basic_remote_tv.toggle_power()
    basic_remote_tv.volume_up()

    advanced_remote_dvd.toggle_power()
    advanced_remote_dvd.mute()

Basic Remote: Press power button
TV: Toggling power
TV: Volume up
DVD Player: Toggling power
Advanced Remote: Mute button pressed
DVD Player: Volume down

from abc import ABC, abstractmethod

# Component interface
class FileSystemComponent:
    @abstractmethod
    def display(self):
        pass

# Leaf class
class File(FileSystemComponent):
    def __init__(self, name):
        self.name = name

    def display(self):
        """
        File là đơn vị nhỏ nhất (child element), nên chỉ display chính nó
        """
        print("File:", self.name)

# Composite class
class Directory(FileSystemComponent):
    def __init__(self, name):
        self.name = name
        self.components = []

    def add_component(self, component):
        """
        Thêm một component mới
        """
        self.components.append(component)

    def remove_component(self, component):
        """
        Xóa bỏ một component
        """
        self.components.remove(component)

    def display(self):
        """
        Display tất cả các components con
        """
        print("Directory:", self.name)
        for component in self.components:
            component.display()

# Client code
if __name__ == "__main__":
    # Create files
    file1 = File("file1.txt")
    file2 = File("file2.txt")
    file3 = File("file3.txt")

    # Create directories
    dir1 = Directory("Directory 1")
    dir2 = Directory("Directory 2")

    # Add files to directories
    dir1.add_component(file1)
    dir1.add_component(file2)
    dir2.add_component(file3)

    # Create composite directory
    root_dir = Directory("Root Directory")
    root_dir.add_component(dir1)
    root_dir.add_component(dir2)

    # Display the file system tree
    root_dir.display()

Directory: Root Directory
Directory: Directory 1
File: file1.txt
File: file2.txt
Directory: Directory 2
File: file3.txt

def uppercase_decorator(func):
    def wrapper(text):
        result = func(text)
        return result.upper()
    return wrapper

@uppercase_decorator
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))

HELLO, ALICE!

import time

def log_writer(log_file):
    def decorator(func):
        def wrapper(*args, **kwargs):
            start_time = time.time()
            result = func(*args, **kwargs)
            total_time = time.time() - start_time
            output = f"Result: {result}, Time: {round(total_time, 4)}\n"
            with open(log_file, 'a') as f:
                f.write(output)
            return output
        return wrapper
    return decorator

@log_writer("test.txt")
def test():
    import random
    time.sleep(random.randint(0, 1))
    return random.randrange(0, 10)

@log_writer("test2.txt")
def test2():
    import random
    time.sleep(random.randint(1, 2))
    return random.choice(["apple", "banana", "cherry"])

if __name__ == "__main__":
    for _ in range(3):
        test()
        test2()

!cat test.txt && echo $'\n' && cat test2.txt

Result: 4, Time: 0.0
Result: 3, Time: 1.0011
Result: 9, Time: 0.0

Result: apple, Time: 1.0007
Result: cherry, Time: 1.0011
Result: cherry, Time: 2.0021

"""Facade pattern with an example of WashingMachine"""
class Washing: 
    '''Subsystem # 1'''
    def wash(self): 
        print("Washing...") 

class Rinsing: 
    '''Subsystem # 2'''
    def rinse(self): 
        print("Rinsing...") 

class Spinning: 
    '''Subsystem # 3'''
    def spin(self): 
        print("Spinning...") 

class WashingMachine: 
    '''Facade'''
    def __init__(self): 
        self.washing = Washing() 
        self.rinsing = Rinsing() 
        self.spinning = Spinning() 

    def startWashing(self): 
        self.washing.wash() 
        self.rinsing.rinse() 
        self.spinning.spin() 

""" client code """
if __name__ == "__main__": 
    washingMachine = WashingMachine()
    washingMachine.startWashing()

Washing...
Rinsing...
Spinning...

"""
Ví dụ sử dụng Proxy để làm cache
"""
import time

# Define the interface for the Real Subject
class DatabaseQuery:
    def execute_query(self, query):
        pass

# Real Subject: Represents the actual database
class RealDatabaseQuery(DatabaseQuery):
    def execute_query(self, query):
        print(f"Executing query: {query}")
        # Simulate a database query and return the results
        return f"Results for query: {query}\n"

# Proxy: Caching Proxy for Database Queries
class CacheProxy(DatabaseQuery):
    def __init__(self, real_database_query, cache_duration_seconds):
        self._real_database_query = real_database_query
        self._cache = {}
        self._cache_duration = cache_duration_seconds

    def execute_query(self, query):
        if query in self._cache and time.time() - self._cache[query]["timestamp"] <= self._cache_duration:
            # Return cached result if it's still valid
            print(f"CacheProxy: Returning cached result for query: {query}")
            return self._cache[query]["result"]
        else:
            # Execute the query and cache the result
            result = self._real_database_query.execute_query(query)
            self._cache[query] = {"result": result, "timestamp": time.time()}
            return result

# Client code
if __name__ == "__main__":
    # Create the Real Subject
    real_database_query = RealDatabaseQuery()

    # Create the Cache Proxy with a cache duration of 5 seconds
    cache_proxy = CacheProxy(real_database_query, cache_duration_seconds=5)

    # Perform database queries, some of which will be cached
    print(cache_proxy.execute_query("SELECT * FROM table1"))
    print(cache_proxy.execute_query("SELECT * FROM table2"))
    time.sleep(3)  # Sleep for 3 seconds
    
    # Should return cached result
    print(cache_proxy.execute_query("SELECT * FROM table1"))
    print(cache_proxy.execute_query("SELECT * FROM table3"))

Executing query: SELECT * FROM table1
Results for query: SELECT * FROM table1

Executing query: SELECT * FROM table2
Results for query: SELECT * FROM table2

CacheProxy: Returning cached result for query: SELECT * FROM table1
Results for query: SELECT * FROM table1

Executing query: SELECT * FROM table3
Results for query: SELECT * FROM table3

"""
Ví dụ sử dụng Proxy để kiểm soát truy cập: validation, protection
"""
class College: 
    '''Resource-intensive object'''
    def studyingInCollege(self): 
        print("Studying In College....\n") 

class CollegeProxy: 
    '''Relatively less resource-intensive proxy acting as middleman. 
    Instantiates a College object only if there is no fee due.'''
    def __init__(self): 
        self.feeBalance = 1000
        self.college = None

    def studyingInCollege(self): 
        print(f"Proxy in action. Checking fee balance: {self.feeBalance}")
        if self.feeBalance <= 500:
            # If the balance is less than 500, let him study. 
            self.college = College() 
            self.college.studyingInCollege() 
        else: 
            # Otherwise, don't instantiate the college object. 
            print("Your fee balance is greater than 500, first pay the fee.\n") 

# Client code
if __name__ == "__main__": 
    # Instantiate the Proxy 
    collegeProxy = CollegeProxy() 

    # Client attempting to study in the college at the default balance of 1000. 
    # Logically, since he / she cannot study with such balance, 
    # there is no need to make the college object. 
    collegeProxy.studyingInCollege() 

    # Altering the balance of the student 
    collegeProxy.feeBalance = 100
    # Client attempting to study in college at the balance of 100. Should succeed. 
    collegeProxy.studyingInCollege()

Proxy in action. Checking fee balance: 1000
Your fee balance is greater than 500, first pay the fee.

Proxy in action. Checking fee balance: 100
Studying In College....

class CharFlyweight:
    def __init__(self, char):
        self.char = char

class CharFactory:
    char_flyweights = {}

    @staticmethod
    def get_char(char):
        """
        Kiểm tra char object đã được khởi tạo hay chưa.
        - Đã khởi tạo -> trả về object đã khởi tạo, không tạo thêm để tiết kiệm bộ nhớ
        - Chưa khởi tạo -> khởi tạo -> lưu vào cache để sau dùng lại.
        """
        if char not in CharFactory.char_flyweights:
            CharFactory.char_flyweights[char] = CharFlyweight(char)
        return CharFactory.char_flyweights[char]

class Character:
    def __init__(self, char, font_size):
        # Thông tin về ký tự được chia sẻ
        self.char_flyweight = CharFactory.get_char(char)
        # Thông tin về font size thì có thể thay đổi
        self.font_size = font_size

    def render(self):
        print(f"Object id: {id(self.char_flyweight)}, Character: {self.char_flyweight.char}, Font Size: {self.font_size}\n")

# Client code
if __name__ == "__main__":
    characters = []
    characters.append(Character('A', 12))
    characters.append(Character('B', 13))
    characters.append(Character('A', 14))  # Reusing 'A' from flyweight

    for character in characters:
        character.render()

Object id: 139701667453152, Character: A, Font Size: 12

Object id: 139701666563264, Character: B, Font Size: 13

Object id: 139701667453152, Character: A, Font Size: 14