Is it possible for a decorator to return a function with the same parameters as the wrapped function?

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()
        follo开发者_运维百科wed 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?

---

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".

---

First, I would do it another way:

def hashable(func):
    def hidden(self, item):
        try:
            hash(item)
        except TypeError as e:
            raise e
        else:
            return func(self, item) # return might be important!
    hidden.__doc__ = func.__doc__
    return hidden

It does quite the same (but only because the except suite does "nothing"), but it shows a different intention to the human reader: you are not interested in exceptions occurring in func(). (Or even omit the try ... except ... else and just do

hash(item)
return func(...)

which would as well raise on error and return on success.

Also, the wrapper should return func()'s return value in order to be really flexible.

Then you could write a hashable2() which does the same with 2 parameters. Or you could even write a "indirect decorator", i. e. a function returning a decorator. So you could work with

@hashable(2)
def ...

or even

@hashable(1, 2)
def ...

in order to indicate the parameter indexes which should be hashable.

---

I would agree with Amber that possibly just using hash directly is simpler in this case.

But for the general case of your question, have a a look at the wraps decorator in the functools standard library module. You can do:

def hashable(func):
    @functools.wraps(func)
    def hidden(self, item):
        ...
    return hidden

This means the returned funcion's name, docstring, and module are copied over from func. That's probably not enough to get tab completion, but it does at least help the wrapper function look more like the original.