Tuples & Sequence Unpacking

def calculate_waypoint_routes():
    # Immutable GPS waypoints: (latitude, longitude, city_name)
    waypoints = [
        (37.7749, -122.4194, "San Francisco"),
        (34.0522, -118.2437, "Los Angeles"),
        (47.6062, -122.3321, "Seattle"),
        (39.7392, -104.9903, "Denver")
    ]
    
    print("=" * 52)
    print(f"{'GPS WAYPOINT TELEMETRY NAVIGATOR':^52}")
    print("=" * 52)
    
    # 1. Unpack starting point
    start_lat, start_lon, start_city = waypoints[0]
    print(f"Origin: {start_city} ({start_lat:.4f}°N, {abs(start_lon):.4f}°W)")
    print("-" * 52)
    
    # 2. Identify northernmost destination (highest latitude)
    northernmost = max(waypoints, key=lambda wp: wp[0])
    print(f"Northernmost Destination: {northernmost[2]} (Lat: {northernmost[0]:.4f}°N)")
    print("-" * 52)
    
    # 3. Calculate Euclidean distance to all destinations
    print("Legs from Origin:")
    for wp in waypoints[1:]:
        # Tuple unpacking directly in loop header
        dest_lat, dest_lon, dest_city = wp
        
        # Approximate planar coordinate distance
        d_lat = dest_lat - start_lat
        d_lon = dest_lon - start_lon
        dist = round((d_lat**2 + d_lon**2)**0.5, 4)
        
        print(f"  -> Destination: {dest_city:<15} Distance Index: {dist:>8.4f}")
        
    print("=" * 52)
    return waypoints, northernmost

routes, north_city = calculate_waypoint_routes()

class DatabaseConnectionRouter:
    def __init__(self):
        # Composite (host, port) tuples used as dictionary keys
        self.connection_pool = {
            ("db-primary.internal", 5432): "PG_PRIMARY_ACTIVE",
            ("db-replica-01.internal", 5432): "PG_REPLICA_READONLY",
            ("redis-cache.internal", 6379): "REDIS_CACHE_ACTIVE"
        }
        
    def route_query(self, host: str, port: int) -> str:
        endpoint_key = (host, port)  # Tuple packing
        return self.connection_pool.get(endpoint_key, "ERROR_HOST_NOT_FOUND")
        
def execute_auth_query() -> list[tuple]:
    # Simulated SQL rows returned from psycopg/sqlite driver
    # Schema: (user_id, username, role, (client_ip, client_port))
    return [
        (101, "alice", "administrator", ("10.0.0.15", 44322)),
        (102, "bob", "developer", ("10.0.0.28", 51230)),
        (103, "charlie", "contractor", ("192.168.1.100", 60102))
    ]

router = DatabaseConnectionRouter()
print("Connection Pool Routing:")
print(f"  Master DB: {router.route_query('db-primary.internal', 5432)}")
print(f"  Replica:   {router.route_query('db-replica-01.internal', 5432)}")
print(f"  Unknown:   {router.route_query('external.com', 80)}")

print("\nProcessing Database Cursor Records:")
rows = execute_auth_query()
for row in rows:
    # Nested tuple unpacking: extracts nested socket (client_ip, client_port)
    uid, uname, role, (ip, port) = row
    print(f"  User #{uid}: {uname:<10} [{role:<13}] Source: {ip}:{port}")
    
# Verify security invariant: Attempting to mutate database row record fails
try:
    rows[0][2] = "superuser"  # Unauthorized privilege escalation attempt!
except TypeError as ex:
    print(f"\nSecurity Invariant Verified: Mutating tuple raised {type(ex).__name__}!")

import hashlib
import time

def create_audit_block(index: int, prev_hash: str, timestamp: int, transactions: tuple) -> tuple:
    """
    Generates an immutable ledger block tuple with cryptographic SHA-256 seal.
    """
    # 1. Enforce payload immutability: transactions MUST be a hashable tuple
    try:
        hash(transactions)
    except TypeError:
        raise ValueError("Transaction payload must consist solely of immutable, hashable elements!")
        
    # 2. Compute deterministic cryptographic block hash
    hasher = hashlib.sha256()
    payload_repr = f"{index}|{prev_hash}|{timestamp}|{transactions}"
    hasher.update(payload_repr.encode("utf-8"))
    block_hash = hasher.hexdigest()
    
    # 3. Return sealed 5-element block tuple
    return (index, prev_hash, timestamp, transactions, block_hash)

# Immutable transaction records: ((sender, receiver, amount), ...)
ledger_transactions = (
    ("corp_treasury", "vendor_aws", 14250.00),
    ("corp_treasury", "vendor_cloudflare", 3200.50),
    ("client_alpha", "corp_treasury", 50000.00)
)

genesis_block = create_audit_block(
    index=0,
    prev_hash="0" * 64,
    timestamp=1773680000000,
    transactions=ledger_transactions
)

print("=" * 66)
print(f"{'SEALED AUDIT LEDGER BLOCK':^66}")
print("=" * 66)

# Starred unpacking: extracts block indices, header, and hash
block_idx, parent_hash, block_time, *tx_data, seal_hash = genesis_block

print(f"Block Index: {block_idx}")
print(f"Parent Hash: {parent_hash[:16]}...{parent_hash[-16:]}")
print(f"Timestamp:   {block_time}ms")
print(f"Block Hash:  {seal_hash}")
print("-" * 66)
print(f"Sealed Transactions ({len(tx_data[0])} records):")

for tx in tx_data[0]:
    src, dst, val = tx
    print(f"  * {src:<16} -> {dst:<20} : ${val:>10.2f}")
    
print("=" * 66)