Dictionary Methods & Key Merging

def resolve_service_deployment(
    global_defaults: dict,
    cluster_overrides: dict,
    container_local: dict
) -> dict:
    """
    Merges configuration layers with precedence:
    container_local > cluster_overrides > global_defaults.
    """
    # Chain the merge operator '|'; rightmost operand takes precedence on conflict
    final_config = global_defaults | cluster_overrides | container_local
    return final_config

defaults = {
    "image": "pylabs/base:3.12",
    "replicas": 2,
    "timeout_sec": 30,
    "enable_ssl": True,
    "region": "global"
}

cluster = {
    "replicas": 10,
    "region": "us-east-1",
    "vpc_id": "vpc-08129a"
}

container = {
    "replicas": 16,               # Local scaling override
    "profiler_enabled": True
}

print("=" * 65)
print(f"{'CONTAINER DEPLOYMENT CONFIGURATION RESOLVER':^65}")
print("=" * 65)

resolved = resolve_service_deployment(defaults, cluster, container)

for param, val in resolved.items():
    print(f"{param:<22}: {val}")
print("=" * 65)

assert resolved["replicas"] == 16          # Container won
assert resolved["region"] == "us-east-1"   # Cluster won
assert resolved["enable_ssl"] is True       # Default preserved
assert resolved["vpc_id"] == "vpc-08129a"   # Cluster addition preserved
print("Multi-Tier Layered Configuration Successfully Resolved!")

def organize_transactions_by_category(transactions: list[dict]) -> dict[str, list[dict]]:
    """
    Groups transactions by category using the setdefault accumulator idiom.
    """
    grouped_ledger = {}
    
    for tx in transactions:
        # Extract category with safe fallback
        category = tx.get("category", "Uncategorized")
        
        # Single-pass accumulator: initializes empty list if missing, returns reference
        grouped_ledger.setdefault(category, []).append({
            "tx_id": tx["id"],
            "amount": tx["amount"],
            "vendor": tx.get("vendor", "Unknown")
        })
        
    return grouped_ledger

raw_transactions = [
    {"id": "TX101", "category": "Infrastructure", "amount": 420.00, "vendor": "AWS"},
    {"id": "TX102", "category": "Marketing", "amount": 1500.00, "vendor": "Google"},
    {"id": "TX103", "category": "Infrastructure", "amount": 85.00, "vendor": "Cloudflare"},
    {"id": "TX104", "amount": 24.50, "vendor": "Coffee Shop"},  # Missing category
    {"id": "TX105", "category": "Marketing", "amount": 300.00, "vendor": "Meta"}
]

print("=" * 65)
print(f"{'FINANCIAL TRANSACTION CATEGORY ACCUMULATOR':^65}")
print("=" * 65)

ledger = organize_transactions_by_category(raw_transactions)

for cat in sorted(ledger.keys()):
    items = ledger[cat]
    total_spent = sum(i["amount"] for i in items)
    print(f"Category: {cat:<16} | Entries: {len(items)} | Total: ${total_spent:.2f}")
    for it in items:
        print(f"   [{it['tx_id']}] {it['vendor']:<15} -> ${it['amount']:.2f}")
    print("-" * 65)

def deep_merge(base: dict, overrides: dict) -> dict:
    """
    Recursively merges overrides into base without destroying inner dictionaries.
    """
    merged = base.copy()
    for key, val in overrides.items():
        # If both are dictionaries, recurse down the tree
        if key in merged and isinstance(merged[key], dict) and isinstance(val, dict):
            merged[key] = deep_merge(merged[key], val)
        else:
            merged[key] = val
    return merged

def compute_dict_diff(old_dict: dict, new_dict: dict) -> dict:
    """
    Calculates top-level schema changes using dictionary view set algebra.
    """
    old_keys = old_dict.keys()
    new_keys = new_dict.keys()
    
    added_keys = sorted(new_keys - old_keys)
    removed_keys = sorted(old_keys - new_keys)
    common_keys = old_keys & new_keys
    
    modified_keys = sorted([
        k for k in common_keys if old_dict[k] != new_dict[k]
    ])
    
    return {
        "added": added_keys,
        "removed": removed_keys,
        "modified": modified_keys
    }

base_system_config = {
    "database": {
        "host": "db.internal.pylabs.org",
        "port": 5432,
        "pool": {"min": 5, "max": 20}
    },
    "telemetry": {"enabled": True, "sample_rate": 0.1},
    "legacy_flag": True
}

production_overrides = {
    "database": {
        "pool": {"max": 100}  # Should only modify pool.max!
    },
    "telemetry": {"sample_rate": 1.0},
    "new_audit_log": True
}

print("=" * 65)
print(f"{'RECURSIVE DEEP MERGE & SCHEMA DIFF CALCULATOR':^65}")
print("=" * 65)

merged_config = deep_merge(base_system_config, production_overrides)
print("Merged Database Settings:")
print(json.dumps(merged_config["database"], indent=2))
print("-" * 65)

diff = compute_dict_diff(base_system_config, merged_config)
print("Schema Evolution Diff:")
print(f"  Added Keys:    {diff['added']}")
print(f"  Removed Keys:  {diff['removed']}")
print(f"  Modified Keys: {diff['modified']}")
print("=" * 65)

# Verify deep merge integrity
assert merged_config["database"]["host"] == "db.internal.pylabs.org"
assert merged_config["database"]["port"] == 5432
assert merged_config["database"]["pool"]["min"] == 5
assert merged_config["database"]["pool"]["max"] == 100
print("Nested Sub-Dictionary Fields Successfully Preserved & Merged!")