Software Design Principles

class DatabaseConnection:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.connection = cls._create_connection()
        return cls._instance
    
    @staticmethod
    def _create_connection():
        return "Connected to DB"

# Both are the same instance
db1 = DatabaseConnection()
db2 = DatabaseConnection()
assert db1 is db2

from abc import ABC, abstractmethod

class Notification(ABC):
    @abstractmethod
    def send(self, message): pass

class EmailNotification(Notification):
    def send(self, message):
        print(f"Email: {message}")

class SMSNotification(Notification):
    def send(self, message):
        print(f"SMS: {message}")

class NotificationFactory:
    @staticmethod
    def create(notification_type: str) -> Notification:
        if notification_type == "email":
            return EmailNotification()
        elif notification_type == "sms":
            return SMSNotification()
        raise ValueError(f"Unknown type: {notification_type}")

# Usage
notification = NotificationFactory.create("email")
notification.send("Hello!")

class QueryBuilder:
    def __init__(self):
        self._select = "*"
        self._from = ""
        self._where = []
        self._order_by = None
        self._limit = None
    
    def select(self, columns):
        self._select = columns
        return self
    
    def from_table(self, table):
        self._from = table
        return self
    
    def where(self, condition):
        self._where.append(condition)
        return self
    
    def order_by(self, column):
        self._order_by = column
        return self
    
    def limit(self, n):
        self._limit = n
        return self
    
    def build(self):
        query = f"SELECT {self._select} FROM {self._from}"
        if self._where:
            query += " WHERE " + " AND ".join(self._where)
        if self._order_by:
            query += f" ORDER BY {self._order_by}"
        if self._limit:
            query += f" LIMIT {self._limit}"
        return query

# Fluent interface
query = (QueryBuilder()
    .select("name, email")
    .from_table("users")
    .where("status = 'active'")
    .where("age > 18")
    .order_by("created_at DESC")
    .limit(10)
    .build())

# Legacy XML service
class LegacyXMLParser:
    def parse_xml(self, xml_string):
        return {"data": "parsed from XML"}

# Modern code expects JSON
class JSONAdapter:
    def __init__(self, xml_parser):
        self.xml_parser = xml_parser
    
    def parse_json(self, json_string):
        # Convert JSON to XML, parse, return result
        xml_data = self._json_to_xml(json_string)
        return self.xml_parser.parse_xml(xml_data)
    
    def _json_to_xml(self, json_string):
        return "<xml>converted</xml>"

# Usage
legacy_parser = LegacyXMLParser()
adapter = JSONAdapter(legacy_parser)
result = adapter.parse_json('{"key": "value"}')

from functools import wraps
import time

def timing_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time() - start:.2f}s")
        return result
    return wrapper

def retry_decorator(max_attempts=3):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise
                    print(f"Attempt {attempt + 1} failed, retrying...")
        return wrapper
    return decorator

@timing_decorator
@retry_decorator(max_attempts=3)
def fetch_data(url):
    # Simulate API call
    return {"data": "fetched"}

class VideoConverter:
    def convert(self, filename, format):
        print(f"Converting {filename} to {format}")

class AudioExtractor:
    def extract(self, video):
        print(f"Extracting audio from {video}")

class ThumbnailGenerator:
    def generate(self, video):
        print(f"Generating thumbnail for {video}")

class UploadService:
    def upload(self, file, platform):
        print(f"Uploading {file} to {platform}")

# Facade simplifies the complex workflow
class VideoPublishingFacade:
    def __init__(self):
        self.converter = VideoConverter()
        self.audio = AudioExtractor()
        self.thumbnail = ThumbnailGenerator()
        self.uploader = UploadService()
    
    def publish(self, video_file, platform):
        self.converter.convert(video_file, "mp4")
        self.audio.extract(video_file)
        self.thumbnail.generate(video_file)
        self.uploader.upload(video_file, platform)

# Simple usage
facade = VideoPublishingFacade()
facade.publish("my_video.mov", "youtube")

from abc import ABC, abstractmethod

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount): pass

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paid ${amount} with credit card")

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paid ${amount} with PayPal")

class CryptoPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paid ${amount} with crypto")

class ShoppingCart:
    def __init__(self, payment_strategy: PaymentStrategy):
        self.payment_strategy = payment_strategy
    
    def checkout(self, amount):
        self.payment_strategy.pay(amount)

# Easy to swap payment methods
cart = ShoppingCart(CreditCardPayment())
cart.checkout(100)

cart = ShoppingCart(CryptoPayment())
cart.checkout(100)

class EventEmitter:
    def __init__(self):
        self._listeners = {}
    
    def on(self, event, callback):
        if event not in self._listeners:
            self._listeners[event] = []
        self._listeners[event].append(callback)
    
    def emit(self, event, data=None):
        if event in self._listeners:
            for callback in self._listeners[event]:
                callback(data)

# Usage
emitter = EventEmitter()

def on_user_created(user):
    print(f"Send welcome email to {user['email']}")

def on_user_created_log(user):
    print(f"Log: User {user['name']} created")

emitter.on("user_created", on_user_created)
emitter.on("user_created", on_user_created_log)

emitter.emit("user_created", {"name": "John", "email": "[email protected]"})

from abc import ABC, abstractmethod

class Command(ABC):
    @abstractmethod
    def execute(self): pass
    
    @abstractmethod
    def undo(self): pass

class AddTextCommand(Command):
    def __init__(self, document, text):
        self.document = document
        self.text = text
    
    def execute(self):
        self.document.content += self.text
    
    def undo(self):
        self.document.content = self.document.content[:-len(self.text)]

class Document:
    def __init__(self):
        self.content = ""
        self.history = []
    
    def execute(self, command):
        command.execute()
        self.history.append(command)
    
    def undo(self):
        if self.history:
            command = self.history.pop()
            command.undo()

# Usage with undo support
doc = Document()
doc.execute(AddTextCommand(doc, "Hello "))
doc.execute(AddTextCommand(doc, "World!"))
print(doc.content)  # "Hello World!"

doc.undo()
print(doc.content)  # "Hello "