How to Implement Namespaced Cache Keys for Tenant Isolation in Python

from keyvaluestore import SimpleCache
from unittest.mock import patch

class TenantCache(SimpleCache):
    def __init__(self, tenant_id, namespace="default"):
        super().__init__()
        self.tenant_id = tenant_id
        self.namespace = namespace

    def _key(self, key):
        return f"tenant:{self.tenant_id}:{self.namespace}:{key}"

    def get(self, key):
        return super().get(self._key(key))

    def set(self, key, value, ttl=None):
        return super().set(self._key(key), value, ttl)

    def delete(self, key):
        return super().delete(self._key(key))

    def __contains__(self, key):
        return self._key(key) in self.cache


class SimpleCache:
    def __init__(self):
        self.cache = {}

    def set(self, key, value, ttl=None):
        self.cache[key] = value
        return True

    def get(self, key):
        return self.cache.get(key)

    def delete(self, key):
        return self.cache.pop(key, None) is not None


if __name__ == "__main__":
    tenant_a = TenantCache("user123", "preferences")
    tenant_b = TenantCache("user456", "preferences")

    tenant_a.set("theme", "dark")
    tenant_b.set("theme", "light")

    print(f"A theme: {tenant_a.get('theme')}")
    print(f"B theme: {tenant_b.get('theme')}")
    print(f"A contains key: {'theme' in tenant_a}")

    with patch.object(tenant_a, "_key", return_value="mocked_key"):
        tenant_a.set("test", "value")
        print(f"Mocked set result: {tenant_a.get('test')}")