Question

So I’m writing a simple heap data structure for my own convienience and realized that to do it correctly, I need to check if many arguments are hashable in order for heapq operations to work correctly.

import heapq


def hashable(func):
    def hidden(self, item):
        try:
            hash(item)
            func(self, item)
        except TypeError as e:
            raise e
    hidden.__doc__ = func.__doc__
    return hidden


class heap(object):
    def __init__(self, heap=[]):
        self.heap = heap
        heapq.heapify(heap)

    def pop(self):
        '''
        Pop and return the smallest item from the heap, maintaining the heap
        invariant. If the heap is empty, IndexError is raised.
        '''
        return heapq.heappop(self.heap)

    @hashable
    def push(self, item):
        '''
        Push the value item onto the heap, maintaining the heap invariant.
        '''
        return heapq.heappush(self.heap, item)

    @hashable
    def pushpop(self, item):
        '''
        Push item on the heap, then pop and return the smallest item from
        the heap.

        The combined actions runs more efficiently than heappush()
        followed by a separate called to heappop().'''
        heapq.heappushpop(self.heap, item)

    @hashable
    def poppush(self, item):
        '''
        Pop and return the smallest item from the heap, then push item on
        the heap.

        The combined actions runs more efficiently than heappop()
        followed by a separate called to heappush().'''
        heapq.heapreplace(self.heap, item)

    def __setitem__(self, i, y):
        self.heap[self.heap.index(i)] = y
        heapq.heapify(self.heap)

    def __len__(self):
        return len(self.heap)

    def __iter__(self):
        while self.heap:
            yield self.pop()

The problem I’m running into is with setitem. While setitem requires also that ‘y’ be hashable, if I were to decorate it with hashable it would only be capable of taking one argument.

The obvious solution is just to change hashable’s hidden function to accept ‘self’ and ‘*args”, but I am hesistant to use such a solution since it’s not pretty and only complicates the code.

My question is then, is it possible to rewrite the code so that hidden adopts the arguments of the function passed to the decorator?

Answer 1

Why make hashable a decorator? Why not just make it a function you can invoke that will raise an exception normally, and then just invoke it in the function body, passing it the thing you want to check?

In fact, judging from how you wrote the decorator, isn’t hash() already exactly that? Why not, instead of this:

@hashable
def push(self, item):
    '''
    Push the value item onto the heap, maintaining the heap invariant.
    '''
    return heapq.heappush(self.heap, item)

just write this?

def push(self, item):
    '''
    Push the value item onto the heap, maintaining the heap invariant.
    '''
    hash(item)
    return heapq.heappush(self.heap, item)

If you do it that way, then it fixes your __setitem__ problem:

def __setitem__(self, i, y):
    hash(i), hash(y)
    self.heap[self.heap.index(i)] = y
    heapq.heapify(self.heap)

---

That said, for your question about ‘returning a function with the same args’ – that is exactly what *args and **kwargs syntax is designed for, so I’m not sure why you think it’s “not pretty” or “complicating the code”.