Priority Queue with update-able values
1. Bug

You can't pop an item from the queue if it's the only item:

&gt;&gt;&gt; q = PriorityQueueUpdateable()
&gt;&gt;&gt; q[1] = 1
&gt;&gt;&gt; q.pop()
Traceback (most recent call last):
  File "&lt;stdin&gt;", line 1, in &lt;module&gt;
  File "cr163560.py", line 41, in pop
    self._clear_heap()
  File "cr163560.py", line 25, in _clear_heap
    value, key = self._heap[0]
IndexError: list index out of range


The problem is in the pop method: it calls _clear_heap after popping the item (as well as before). But at this point there might be no items left in the queue. In your simple test, you add both keys to the queue multiple times, so that when you pop an item it's never the last item (because there are more items with the same key remaining in the queue).

2. Review


The Python library documentation has a section "Priority Queue Implementation Notes" which gives some advice on implementing a priority queue using a heap. This is well worth reading.
The docstring for the class doesn't give much of a clue as to how to use it. Docstrings should be written from the user's point of view, and shouldn't include implementation details (like "implemented with heapq module") — these are only needed by developers and so can be mentioned in comments.
There are no docstrings for the __init__, pop and peek methods.
It would be convenient if the __init__ method accepted an optional iterable of (key, priority) pairs. This would make it easier to create priority queues.
In __init__, there's no need to call heapq.heapify — this does nothing on an empty heap.
Using __setitem__ to add an item to the queue seems strange — normally one would expect a method adding something to a queue to be named something like push, append, or put. (Compare heapq.heappush, collections.deque.append, queue.Queue.put.)
The second argument to __setitem__ is named value, but this is misleading — actually it's the priority of the key.
Priorities work in reverse — if you want an item to have a higher priority then you have to give it a lower value (this happens because Python's heaps are min-heaps). It would probably suit more applications if priorities worked in the usual way. (You'd have to negate the priority values to make higher values mean higher priorities.)
You give a test case, which is great! It would be convenient to turn this into a unit test (perhaps using the unittest module) so that it can be automatically run.