How to implement a write-behind cache with async queue in Python

import asyncio
from collections import deque
from dataclasses import dataclass

@dataclass
class CacheEntry:
    key: str
    value: str

class WriteBehindCache:
    def __init__(self, flush_interval=1.0):
        self.cache = {}
        self.queue = deque()
        self.flush_interval = flush_interval
        self._flush_task = None

    async def start(self):
        self._flush_task = asyncio.create_task(self._flush_worker())
        return self

    async def stop(self):
        if self._flush_task:
            self._flush_task.cancel()
            await self._flush_worker(force=True)

    async def put(self, key, value):
        self.cache[key] = value
        self.queue.append(CacheEntry(key, value))

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

    async def _flush_worker(self):
        while True:
            await asyncio.sleep(self.flush_interval)
            await self._flush_worker(force=False)

    async def _flush_worker(self, force=False):
        while self.queue:
            entry = self.queue.popleft()
            # Simulate persistent storage write
            await asyncio.sleep(0.05)
            print(f"Flushed: {entry.key} -> {entry.value}")


async def main():
    cache = await WriteBehindCache(flush_interval=0.5).start()
    
    await cache.put("user:1", "Alice")
    await cache.put("user:2", "Bob")
    
    print(f"Immediate read: {await cache.get('user:1')}")
    await asyncio.sleep(1.2)
    
    await cache.put("user:3", "Carol")
    await cache.stop()
    
    print(f"Final read: {await cache.get('user:2')}")


if __name__ == "__main__":
    asyncio.run(main())