class_docstr: Generic supertype for cache implementations.
  
  Defines a dict-like mapping with a maximum size, where as well as mapping
  to a value, each key also maps to a score. When a write would cause the
  dict to exceed its maximum size, it first evicts the existing key with
  the smallest score, then adds the new key to the map.
  
  A key has the following lifecycle:
  
  1. key is written for the first time, the key is given the score
     self.new_entry(key, value)
  2. whenever an existing key is read or written, self.on_access(key, value,
     score) is called. This returns a new score for the key.
  3. When a key is evicted, self.on_evict(key, value, score) is called.
  
  The cache will be in a valid state in all of these cases.
  
  Implementations are expected to implement new_entry and optionally
  on_access and on_evict to implement a specific scoring strategy.
docstr: Undo one previous call to ``pin(key)``. Once all calls are
  undone this key may be evicted as normal.
docstr_tok: ["Undo","one","previous","call","to","``","pin","(","key",")","``",".","Once","all","calls","are","undone","this","key","may","be","evicted","as","normal","."]
code: def unpin(self, key):
      """Undo one previous call to ``pin(key)``. Once all calls are
      undone this key may be evicted as normal."""
      i = self.keys_to_indices[key]
      entry = self.data[i]
      if entry.pins == 0:
          raise ValueError("Key %r has not been pinned" % (key,))
      entry.pins -= 1
      if entry.pins == 0:
          self.__pinned_entry_count -= 1
          self.__balance(i)
  
imports: from __future__ import absolute_import, division, print_function
  import attr
label_desc: Use image node_id 8 for calling the GenericCache obj's underlying member method code with example usage: obj.unpin(key) without return types