Performance Cost Optimization & Resource Efficiency Questions

class Node:
    def __init__(self, key, value, size):
        self.key = key
        self.value = value
        self.size = size
        self.prev = None
        self.next = None

class LRUCacheByBytes:
    def __init__(self, capacity_bytes):
        self.cap = capacity_bytes
        self.curr = 0
        self.map = {}           # key -> Node
        self.head = None        # MRU
        self.tail = None        # LRU

    def _remove_node(self, node):
        # unlink node
        if node.prev: node.prev.next = node.next
        else: self.head = node.next
        if node.next: node.next.prev = node.prev
        else: self.tail = node.prev
        node.prev = node.next = None
        self.curr -= node.size
        del self.map[node.key]

    def _add_to_head(self, node):
        node.next = self.head
        if self.head: self.head.prev = node
        self.head = node
        if not self.tail: self.tail = node
        self.map[node.key] = node
        self.curr += node.size

    def get(self, key):
        node = self.map.get(key)
        if not node: return None
        # move to head (MRU)
        self._remove_node(node)        # removal updates curr & map
        self._add_to_head(node)        # re-add updates curr & map
        return node.value

    def put(self, key, value, size):
        # If exists, remove old instance first
        if key in self.map:
            self._remove_node(self.map[key])
        node = Node(key, value, size)
        # Evict until there is room. Policy: allow storing item even if bigger than capacity by evicting all others;
        # alternatively, skip insertion if size > cap (choose based on requirements).
        while self.curr + size > self.cap and self.tail:
            self._remove_node(self.tail)
        # If still doesn't fit (item > cap and cache empty), decide: store single large item or reject.
        self._add_to_head(node)