import threading  # For thread-safe Singleton

class DatabaseConnection:
    _instance = None           # Class variable: stores the one instance
    _lock = threading.Lock()   # Prevents race conditions in multi-threaded apps

    def __new__(cls):
        # __new__ is called BEFORE __init__ — controls object creation
        if cls._instance is None:
            with cls._lock:                          # Acquire lock
                if cls._instance is None:            # Double-check after lock
                    cls._instance = super().__new__(cls)
                    cls._instance.connected = False  # Initialize state
        return cls._instance    # Always return the SAME instance

    def connect(self, host: str, database: str):
        if not self.connected:
            print(f"Connecting to {database} on {host}...")
            self.host = host
            self.database = database
            self.connected = True
        else:
            print("Already connected — reusing existing connection")

    def query(self, sql: str) -> str:
        if not self.connected:
            raise RuntimeError("Not connected to database")
        return f"Result of: {sql}"

db1 = DatabaseConnection()
db2 = DatabaseConnection()

db1.connect("localhost", "production_db")
# Connecting to production_db on localhost...

db2.connect("remotehost", "other_db")
# Already connected — reusing existing connection

print(db1 is db2)       # True — same object in memory
print(id(db1) == id(db2))   # True — identical memory address
print(db2.host)         # localhost — db2 IS db1

from abc import ABC, abstractmethod

# Abstract base for all notification types
class Notification(ABC):
    @abstractmethod
    def send(self, recipient: str, message: str):
        pass

# Concrete notification implementations
class EmailNotification(Notification):
    def send(self, recipient: str, message: str):
        print(f"[EMAIL] To: {recipient} | Message: {message}")

class SMSNotification(Notification):
    def send(self, recipient: str, message: str):
        # Truncate long SMS messages to 160 characters
        short_msg = message[:160]
        print(f"[SMS] To: {recipient} | Message: {short_msg}")

class PushNotification(Notification):
    def send(self, recipient: str, message: str):
        print(f"[PUSH] Device: {recipient} | Alert: {message}")


# The Factory — creates the right notification type
class NotificationFactory:
    # Registry maps channel names to their classes
    _registry = {
        "email": EmailNotification,
        "sms": SMSNotification,
        "push": PushNotification,
    }

    @classmethod
    def create(cls, channel: str) -> Notification:
        # Look up the channel type in the registry
        notification_class = cls._registry.get(channel.lower())
        if notification_class is None:
            available = ", ".join(cls._registry.keys())
            raise ValueError(f"Unknown channel '{channel}'. Available: {available}")
        return notification_class()    # Create and return instance

    @classmethod
    def register(cls, channel: str, notification_class: type):
        # Allow new channels to be added without modifying the factory
        cls._registry[channel] = notification_class

# The calling code doesn't import EmailNotification, SMSNotification, etc.
# It only knows about the factory and the abstract interface.

channels = ["email", "sms", "push"]
for channel in channels:
    notifier = NotificationFactory.create(channel)
    notifier.send("user@example.com", "Your order has shipped!")

[EMAIL] To: user@example.com | Message: Your order has shipped!
[SMS] To: user@example.com | Message: Your order has shipped!
[PUSH] Device: user@example.com | Alert: Your order has shipped!

class SQLQuery:
    """Represents a finished SQL query."""
    def __init__(self):
        self._table = ""
        self._columns = ["*"]
        self._conditions = []
        self._order_by = None
        self._limit = None

    def __str__(self) -> str:
        # Assemble the SQL string from all the parts
        cols = ", ".join(self._columns)
        sql = f"SELECT {cols} FROM {self._table}"
        if self._conditions:
            where_clause = " AND ".join(self._conditions)
            sql += f" WHERE {where_clause}"
        if self._order_by:
            sql += f" ORDER BY {self._order_by}"
        if self._limit:
            sql += f" LIMIT {self._limit}"
        return sql


class SQLQueryBuilder:
    """Builds an SQLQuery step by step."""

    def __init__(self):
        self._query = SQLQuery()    # Start with a blank query

    def select(self, *columns: str) -> "SQLQueryBuilder":
        # Specify which columns to retrieve
        self._query._columns = list(columns)
        return self    # Return self to enable method chaining

    def from_table(self, table: str) -> "SQLQueryBuilder":
        # Specify the source table
        self._query._table = table
        return self

    def where(self, condition: str) -> "SQLQueryBuilder":
        # Add a WHERE condition (can be called multiple times)
        self._query._conditions.append(condition)
        return self

    def order_by(self, column: str) -> "SQLQueryBuilder":
        # Specify sort order
        self._query._order_by = column
        return self

    def limit(self, count: int) -> "SQLQueryBuilder":
        # Limit the number of results
        self._query._limit = count
        return self

    def build(self) -> SQLQuery:
        # Validate and return the finished query
        if not self._query._table:
            raise ValueError("Query must specify a table (call .from_table())")
        return self._query

# Readable, step-by-step construction with method chaining
query = (
    SQLQueryBuilder()
    .select("id", "name", "email")
    .from_table("users")
    .where("active = true")
    .where("age >= 18")
    .order_by("name")
    .limit(50)
    .build()
)

print(query)

SELECT id, name, email FROM users WHERE active = true AND age >= 18 ORDER BY name LIMIT 50