Magic Methods and Data Classes

class Money:
    def __init__(self, currency_code: str, amount: float):
        self.currency_code = currency_code.upper()
        self.amount = amount

    # Developer Unambiguous Representation
    def __repr__(self) -> str:
        return f"Money(currency_code='{self.currency_code}', amount={self.amount})"

    # User-Friendly Presentation String
    def __str__(self) -> str:
        symbol = "$" if self.currency_code == "USD" else f"{self.currency_code} "
        return f"{symbol}{self.amount:,.2f}"

m1 = Money("USD", 1250.50)
m2 = Money("EUR", 800.00)

print("=== User-Facing String Output (__str__) ===")
print("m1 via print() :", m1)
print("m2 via f-string:", f"Total Account Balance: {m2}")

print("\n=== Developer Debug Representation (__repr__) ===")
print("repr(m1) Call  :", repr(m1))
print("List of Objects:", [m1, m2])  # Container lists invoke __repr__ on items!

=== User-Facing String Output (__str__) ===
m1 via print() : $1,250.50
m2 via f-string: Total Account Balance: EUR 800.00

=== Developer Debug Representation (__repr__) ===
repr(m1) Call  : Money(currency_code='USD', amount=1250.5)
List of Objects: [Money(currency_code='USD', amount=1250.5), Money(currency_code='EUR', amount=800.0)]

class FinancialWallet:
    def __init__(self, owner: str, balance: float):
        self.owner = owner
        self.balance = balance

    def __repr__(self):
        return f"FinancialWallet(owner='{self.owner}', balance={self.balance})"

    # Overloading Equality Operator (==)
    def __eq__(self, other) -> bool:
        if isinstance(other, FinancialWallet):
            return self.balance == other.balance
        return False

    # Overloading Less Than Operator (<) -> Unlocks sorting!
    def __lt__(self, other) -> bool:
        if isinstance(other, FinancialWallet):
            return self.balance < other.balance
        return NotImplemented

    # Overloading Addition Operator (+)
    def __add__(self, other):
        if isinstance(other, FinancialWallet):
            # Merges two wallets into a combined new wallet instance
            combined_owner = f"{self.owner} & {other.owner}"
            return FinancialWallet(combined_owner, self.balance + other.balance)
        elif isinstance(other, (int, float)):
            # Direct scalar addition
            return FinancialWallet(self.owner, self.balance + float(other))
        return NotImplemented

# Testing Overloaded Operators
w1 = FinancialWallet("Alice", 500.00)
w2 = FinancialWallet("Bob", 1200.00)
w3 = FinancialWallet("Charlie", 500.00)

print("=== Overloaded Equality Checks ===")
print("Is Alice == Charlie? (Same Balance):", w1 == w3)
print("Is Alice == Bob?                   :", w1 == w2)

print("\n=== Overloaded Arithmetic Addition ===")
joint_wallet = w1 + w2
print("Joint Wallet Result:", joint_wallet)

print("\n=== Overloaded Sorting via __lt__ ===")
wallets_list = [w2, w1, w3]
# Calling sorted() dispatches directly to __lt__ under the hood!
sorted_wallets = sorted(wallets_list)
print("Sorted Wallets (Ascending Balance):", sorted_wallets)

=== Overloaded Equality Checks ===
Is Alice == Charlie? (Same Balance): True
Is Alice == Bob?                   : False

=== Overloaded Arithmetic Addition ===
Joint Wallet Result: FinancialWallet(owner='Alice & Bob', balance=1700.0)

=== Overloaded Sorting via __lt__ ===
Sorted Wallets (Ascending Balance): [FinancialWallet(owner='Alice', balance=500.0), FinancialWallet(owner='Charlie', balance=500.0), FinancialWallet(owner='Bob', balance=1200.0)]

from dataclasses import dataclass, field
from datetime import datetime

# Clean, declarative Data Class Definition
@dataclass(order=True)  # order=True automatically generates __lt__, __le__, __gt__, __ge__!
class ProductRecord:
    # Fields defined with type annotations
    product_id: str
    title: str
    price: float
    stock: int = 0  # Field with default value
    
    # Mutable default fields MUST use field(default_factory=...) to avoid shared pointer bugs!
    tags: list[str] = field(default_factory=list, compare=False)

# Instantiating Data Class Objects (Notice __init__ was generated automatically!)
p1 = ProductRecord("P101", "Wireless Mouse", 25.50, 50, ["electronics", "office"])
p2 = ProductRecord("P101", "Wireless Mouse", 25.50, 50, ["electronics", "office"])
p3 = ProductRecord("P102", "Mechanical Keyboard", 89.99, 15, ["hardware"])

print("=== Automatic __repr__ Generation ===")
print("Generated Repr Output:", p1)

print("\n=== Automatic Value-Based __eq__ Comparison ===")
print("Are p1 and p2 equal in value?:", p1 == p2)  # Returns True! Standard class returns False.
print("Are p1 and p3 equal in value?:", p1 == p3)

print("\n=== Automatic Comparison Sorting (order=True) ===")
# Compares objects by field declaration order (product_id first, then title, then price)
products = [p3, p1]
print("Sorted Products:", sorted(products))

=== Automatic __repr__ Generation ===
Generated Repr Output: ProductRecord(product_id='P101', title='Wireless Mouse', price=25.5, stock=50, tags=['electronics', 'office'])

=== Automatic Value-Based __eq__ Comparison ===
Are p1 and p2 equal in value?: True
Are p1 and p3 equal in value?: False

=== Automatic Comparison Sorting (order=True) ===
Sorted Products: [ProductRecord(product_id='P101', title='Wireless Mouse', price=25.5, stock=50, tags=['electronics', 'office']), ProductRecord(product_id='P102', title='Mechanical Keyboard', price=89.99, stock=15, tags=['hardware'])]

from dataclasses import dataclass

@dataclass(frozen=True)
class APIKey:
    key_id: str
    secret_hash: str
    environment: str = "PRODUCTION"

# Instantiating Frozen Data Class
key1 = APIKey("KEY_8801", "a8f9c11...99", "PRODUCTION")
key2 = APIKey("KEY_8801", "a8f9c11...99", "PRODUCTION")

print("=== Hashability Proof ===")
# Hashable objects CAN be placed inside sets or used as dict keys!
active_keys_set = {key1, key2}
print("Set Deduplicated Count:", len(active_keys_set))
print("Object Hash Code     :", hash(key1))

print("\n=== Immutability Protection Test ===")
try:
    key1.environment = "STAGING"  # Triggers exception!
except Exception as err:
    print("Caught Immutability Error:", type(err).__name__, "->", err)

=== Hashability Proof ===
Set Deduplicated Count: 1
Object Hash Code     : 140239482910224
=== Immutability Protection Test ===
Caught Immutability Error: FrozenInstanceError -> cannot assign to field 'environment'

from dataclasses import dataclass

@dataclass
class TransactionPayload:
    tx_id: str
    amount: float
    type: str
    status: str = "PENDING"

def evaluate_transaction_state(payload: TransactionPayload):
    """
    Routes Data Class instances cleanly using Structural Pattern Matching.
    Demonstrates evaluating field attributes and applying guards.
    """
    match payload:
        case TransactionPayload(status="FAILED", tx_id=tid):
            return f"AUDIT_ALERT: Transaction #{tid} failed processing!"

        case TransactionPayload(type="REFUND", amount=amt, tx_id=tid):
            return f"PROCESS_REFUND: Issuing credit return of ${amt:,.2f} for #{tid}"

        case TransactionPayload(amount=amt, status="COMPLETED") if amt >= 10000.0:
            return f"HIGH_VALUE_AUDIT: High-value transaction of ${amt:,.2f} completed."

        case TransactionPayload(amount=amt, status="COMPLETED"):
            return f"STANDARD_PAYMENT: ${amt:,.2f} captured cleanly."

        case _:
            return "UNKNOWN_PAYLOAD: Unrecognized payload status."

# Testing Data Class Pattern Matching
t1 = TransactionPayload("TX_101", 15000.0, "DEBIT", "COMPLETED")
t2 = TransactionPayload("TX_102", 250.0, "REFUND", "PENDING")
t3 = TransactionPayload("TX_103", 50.0, "DEBIT", "FAILED")

print(evaluate_transaction_state(t1))
print(evaluate_transaction_state(t2))
print(evaluate_transaction_state(t3))

HIGH_VALUE_AUDIT: High-value transaction of $15,000.00 completed.
PROCESS_REFUND: Issuing credit return of $250.00 for #TX_102
AUDIT_ALERT: Transaction #TX_103 failed processing!