Используя тот же декоратор (с аргументами) с функциями и методами

Ответ 1

Чтобы расширить подход __get__. Это можно обобщить в декоратор-декоратор.

class _MethodDecoratorAdaptor(object):
    def __init__(self, decorator, func):
        self.decorator = decorator
        self.func = func
    def __call__(self, *args, **kwargs):
        return self.decorator(self.func)(*args, **kwargs)
    def __get__(self, instance, owner):
        return self.decorator(self.func.__get__(instance, owner))

def auto_adapt_to_methods(decorator):
    """Allows you to use the same decorator on methods and functions,
    hiding the self argument from the decorator."""
    def adapt(func):
        return _MethodDecoratorAdaptor(decorator, func)
    return adapt

Таким образом, вы можете просто сделать свой декоратор автоматически адаптированным к условиям, в которых он используется.

def allowed(*allowed_methods):
    @auto_adapt_to_methods
    def wrapper(func):
        def wrapped(request):
            if request not in allowed_methods:
                raise ValueError("Invalid method %s" % request)
            return func(request)
        return wrapped
    return wrapper

Обратите внимание, что функция обёртки вызывается во всех вызовах функций, поэтому не делайте там ничего дорогого.

Использование декоратора:

class Foo(object):
    @allowed('GET', 'POST')
    def do(self, request):
        print "Request %s on %s" % (request, self)

@allowed('GET')
def do(request):
    print "Plain request %s" % request

Foo().do('GET')  # Works
Foo().do('POST') # Raises

Ответ 2

Декоратор всегда применяется к объекту функции - имеет декоратор print тип его аргумента, и вы сможете это подтвердить; и он должен вообще возвращать объект функции (который уже является декоратором с правильным __get__! -), хотя есть исключения для последнего.

I.e, в коде:

class X(object):

  @deco
  def f(self): pass

deco(f) вызывается внутри тела класса, и, пока вы все еще там, f - это функция, а не экземпляр типа метода. (Метод создается и возвращается в f __get__, когда более поздний f получает доступ как атрибут X или его экземпляр).

Может быть, вы можете лучше объяснить использование одной игрушки для своего декоратора, чтобы мы могли больше помочь...?

Изменить: это также для декораторов с аргументами, т.е.

class X(object):

  @deco(23)
  def f(self): pass

то он deco(23)(f), который вызывается в теле класса, f по-прежнему является объектом функции, когда он передается в качестве аргумента для любого вызываемого deco(23), и что вызываемый должен возвращать объект функции (обычно - с исключения; -).

Ответ 3

Поскольку вы уже определяете __get__, чтобы использовать ваш декоратор в методе Bound, вы можете передать флаг, говорящий об этом, если он используется для метода или функции.

class methods(object):
    def __init__(self, *_methods, called_on_method=False):
        self.methods = _methods
        self.called_on_method

    def __call__(self, func):
        if self.called_on_method:
            def inner(self, request, *args, **kwargs):
                print request
                return func(request, *args, **kwargs)
        else:
            def inner(request, *args, **kwargs):
                print request
                return func(request, *args, **kwargs)
        return inner

    def __get__(self, obj, type=None):
        if obj is None:
            return self
        new_func = self.func.__get__(obj, type)
        return self.__class__(new_func, called_on_method=True)

Ответ 4

Частичное (конкретное) решение, которое я придумал, полагается на обработку исключений. Я пытаюсь создать декоратор, чтобы использовать только определенные методы HttpRequest, но заставляю его работать как с функциями, так и с представлениями.

Итак, этот класс будет делать то, что я хочу:

class methods(object):
    def __init__(self, *_methods):
        self.methods = _methods

    def __call__(self, func): 
        @wraps(func)
        def inner(*args, **kwargs):
            try:
                if args[0].method in self.methods:
                    return func(*args, **kwargs)
            except AttributeError:
                if args[1].method in self.methods:
                    return func(*args, **kwargs)
            return HttpResponseMethodNotAllowed(self.methods)
        return inner

Вот два варианта использования: украшение функции:

@methods("GET")
def view_func(request, *args, **kwargs):
    pass

и методы украшения класса:

class ViewContainer(object):
    # ...

    @methods("GET", "PUT")
    def object(self, request, pk, *args, **kwargs):
        # stuff that needs a reference to self...
        pass

Есть ли лучшее решение, чем использовать обработку исключений?

Ответ 5

Вот общий способ, который я обнаружил, чтобы определить, является ли украшенная вызываемая функция или метод:

import functools

class decorator(object):

  def __init__(self, func):
    self._func = func
    self._obj = None
    self._wrapped = None

  def __call__(self, *args, **kwargs):
    if not self._wrapped:
      if self._obj:
        self._wrapped = self._wrap_method(self._func)
        self._wrapped = functools.partial(self._wrapped, self._obj)
      else:
        self._wrapped = self._wrap_function(self._func)
    return self._wrapped(*args, **kwargs)

  def __get__(self, obj, type=None):
    self._obj = obj
    return self

  def _wrap_method(self, method):
    @functools.wraps(method)
    def inner(self, *args, **kwargs):
      print('Method called on {}:'.format(type(self).__name__))
      return method(self, *args, **kwargs)
    return inner

  def _wrap_function(self, function):
    @functools.wraps(function)
    def inner(*args, **kwargs):
      print('Function called:')
      return function(*args, **kwargs)
    return inner

Пример использования:

class Foo(object):
  @decorator
  def foo(self, foo, bar):
    print(foo, bar)

@decorator
def foo(foo, bar):
  print(foo, bar)

foo(12, bar=42)      # Function called: 12 42
foo(12, 42)          # Function called: 12 42
obj = Foo()
obj.foo(12, bar=42)  # Method called on Foo: 12 42
obj.foo(12, 42)      # Method called on Foo: 12 42