Implement a size-bounded LRU cache

Problem: Size-Bounded LRU Cache

Design and implement a thread-safe, size-bounded cache that supports storing items with variable sizes. Unlike a standard LRU cache that limits the count of elements, this cache is limited by the total sum of the weights of all stored items.

You must implement the following interface:

class WeightedLRUCache:
    def __init__(self, capacity: int):
        # Initialize the cache with a maximum total weight capacity.
        pass

    def get(self, key: int) -> int:
        # Return the value if the key exists, updating its status to 'most recently used'.
        # Return -1 if the key does not exist.
        pass

    def put(self, key: int, value: int, weight: int) -> None:
        # Add/update the key-value pair with the associated weight.
        # If the total weight exceeds the capacity, evict items from the 'least recently used' 
        # end until the total weight is within the capacity.
        pass

Constraints

• capacity > 0.
• weight > 0 for all items.
• If a single item's weight exceeds the capacity, the cache should not store it (or handle the error appropriately).
• get and put operations should run in O(1) average time complexity.

Example

cache = WeightedLRUCache(10)
cache.put(1, 100, 4) # Cache: {1: 100}, Current weight: 4
cache.put(2, 200, 7) # Cache: {2: 200}, Evicts 1 (Total weight 7  10)
cache.get(1)        # Returns -1
cache.get(2)        # Returns 200

Edge Cases

• Updating an existing key with a new weight that forces eviction of other items.
• A new item weight being larger than the total cache capacity.
• Repeatedly calling put with the same key.