Python-Dekoratoren und Vererbung

Ich versuche, Dekorateure, um zu verwalten, wie Benutzer möglicherweise oder möglicherweise nicht den Zugriff auf Ressourcen innerhalb einer web-Anwendung (läuft auf der Google App Engine). Bitte beachten Sie, dass ich bin mir nicht erlauben Benutzern, melden sich mit Ihren Google-Konten, so dass Sie bestimmte Zugriffsrechte auf bestimmte Routen innerhalb der app.yaml ist keine option.

Ich verwendet die folgenden Ressourcen zur Verfügung :

- Bruce Eckel ' s guide to Dekorateure

- ALSO : get-class-in-python-decorator2

- ALSO : python-Dekoratoren-und-Vererbung

- ALSO : get-class-in-python-decorator

Aber ich bin noch ein bisschen verwirrt...

Hier ist mein code ! Im folgenden Beispiel, current_user ist ein @property-Methode gehören zu den RequestHandler-Klasse. Es gibt einen Benutzer(db.Modell) - Objekt gespeichert im datenspeicher mit einem level IntProperty().

class FoobarController(RequestHandler):

    # Access decorator
    def requiredLevel(required_level):
        def wrap(func):
            def f(self, *args):
                if self.current_user.level >= required_level:
                    func(self, *args)
                else:
                    raise Exception('Insufficient level to access this resource') 
            return f
        return wrap

    @requiredLevel(100)
    def get(self, someparameters):
        #do stuff here...

    @requiredLevel(200)
    def post(self):
        #do something else here...

Jedoch meine Anwendung nutzt verschiedene Steuerungen für unterschiedliche Arten von Ressourcen. Um die Verwendung der @requiredLevel Dekorateur in allen Unterklassen, die ich brauche, um es zu bewegen, um die übergeordnete Klasse (RequestHandler) :

class RequestHandler(webapp.RequestHandler):

    #Access decorator
    def requiredLevel(required_level):
        #See code above

Meine Idee ist, um die Dekorateur in aller controller-Unterklassen mit den folgenden code :

class FoobarController(RequestHandler):

    @RequestHandler.requiredLevel(100)
    def get(self):
        #do stuff here...

Ich denke, dass ich die Grenze erreicht ist meines Wissens über Dekorateure und Vererbung :). Irgendwelche Gedanken ?

  • Warum ist es eine Methode für die Klasse? Das wird nur dazu führen, Dinge zu brechen, und es wird nur funktionieren, wie eine normale Funktion innerhalb der Klasse definiert wurde. Es sei denn, Sie sind auf 3.x, in welchem Fall es wahrscheinlich gut zu funktionieren.
  • Der decorator ist eine Methode für die Klasse, weil ich nicht dachte noch, wie man code ein Dekorateur als ein class 1/ akzeptiert, argument(en) und 2/, die den Zugriff auf die Methoden der aktuellen Klasse selbst. Ist es das, was du meintest ? Da er sich hauptsächlich selbst beigebracht, ich habe Probleme voll zu verstehen, Bruce Eckell ' s guide, Dekorateure und Vererbung.
  • Könnte man einfach copy-paste die Funktion außerhalb der Klasse, und es würde funktionieren und normal. Wäre das genug, um Ihre Frage zu beantworten?
  • Bewegen requiredLevel Dekorateurin aus FoobarController zu RequestHandler und dekorieren es mit @staticmethod scheint die Lösung zu sein nach stackoverflow.com/questions/3001138/..., aber nicht den trick tun in meiner situation. Wahrscheinlich, weil mein decorator Parameter akzeptiert ?
  • Nein, ich meine, es zu entfernen, die von der Klasse insgesamt. Machen es zu einem regelmäßigen Funktion.
  • Implementiert das decorator als eine Klasse, in der übergeordneten Klasse. Scheint um die Arbeit zu tun ! Siehe meine Antwort unten. Vielen Dank für deinen input :).
  • Aber warum? Das macht keinen Sinn. Mach auch du erkennen, was ich meine?

InformationsquelleAutor jbmusso | 2010-07-31
  1. 4

    Deinen original-code, mit zwei kleinen Verbesserungen, sollte auch funktionieren. Ein Klasse-Ansatz scheint eher schwere Gewicht für so ein einfaches decorator:

    class RequestHandler(webapp.RequestHandler):

    # The decorator is now a class method.
    @classmethod     # Note the 'klass' argument, similar to 'self' on an instance method
    def requiredLevel(klass, required_level):
        def wrap(func):
            def f(self, *args):
                if self.current_user.level >= required_level:
                    func(self, *args)
                else:
                    raise Exception('Insufficient level to access this resource') 
            return f
        return wrap


class FoobarController(RequestHandler):
    @RequestHandler.requiredLevel(100)
    def get(self, someparameters):
        #do stuff here...

    @RequestHandler.requiredLevel(200)
    def post(self):
        #do something else here...

    Alternativ könnte man eine @staticmethod statt:

    class RequestHandler(webapp.RequestHandler):

    # The decorator is now a static method.
    @staticmethod     # No default argument required...
    def requiredLevel(required_level):

    Den Grund, warum der ursprüngliche code hat nicht funktioniert, ist, dass requiredLevel war davon ausgegangen, dass eine Instanz-Methode, die nicht bei class-Deklaration (wenn Sie waren Dekoration, die mit anderen Methoden), noch wird es zur Verfügung von der Klasse object (Inbetriebnahme des decorator auf Ihre RequestHandler base Klasse ist eine ausgezeichnete Idee, und die daraus resultierende Dekorateur nennen ist schön selbsterklärend ist).

    Könnten Sie interessieren, Lesen Sie die Dokumentation über @classmethod und @staticmethod.

    Auch ein wenig boilerplate ich mag meine Dekoratoren: 

        @staticmethod
    def requiredLevel(required_level):
        def wrap(func):
            def f(self, *args):
                if self.current_user.level >= required_level:
                    func(self, *args)
                else:
                    raise Exception('Insufficient level to access this resource') 
            # This will maintain the function name and documentation of the wrapped function.
            # Very helpful when debugging or checking the docs from the python shell:
            wrap.__doc__ = f.__doc__
            wrap.__name__ = f.__name__
            return f
        return wrap
    InformationsquelleAutor David Eyk
  2. 1

    Nach dem Graben durch StackOverflow, und sorgfältig zu Lesen Bruce Eckel ' s guide to Dekorateure, ich denke ich habe eine mögliche Lösung gefunden.

    Es beinhaltet die Umsetzung des decorator als eine Klasse, in der Übergeordneten Klasse :

    class RequestHandler(webapp.RequestHandler):

    # Decorator class :
    class requiredLevel(object):
        def __init__(self, required_level):
            self.required_level = required_level

        def __call__(self, f):
            def wrapped_f(*f_args):
                if f_args[0].current_user.level >= self.required_level:
                    return f(*f_args)
                else:
                    raise Exception('User has insufficient level to access this resource') 
            return wrapped_f

    Dies macht die Arbeit ! Mit f_args[0] scheint ein bisschen schmutzig zu mir, ich werde Bearbeiten, diese Antwort finde ich etwas hübscher.

    Dann können Sie schmücken Methoden in den Unterklassen der folgenden Weise :

    FooController(RequestHandler):
    @RequestHandler.requiredLevel(100)
    def get(self, id):
        # Do something here

    @RequestHandler.requiredLevel(250)
    def post(self)
        # Do some stuff here

BarController(RequestHandler):
    @RequestHandler.requiredLevel(500)
    def get(self, id):
        # Do something here

    Fühlen Sie sich frei zu kommentieren oder einen Vorschlag für eine Verbesserung.

    • könnten Sie wrapped_f(request_handler, *args, **kwargs) als Funktion Unterschrift. Auch gibt es keine Notwendigkeit, legen Sie die Dekorator-Klasse in Ihre RequestHandler-Klasse. Ich würde dies auf Modul-Ebene.
    • Vielen Dank für Ihren Kommentar ! Ich glaube, Sie hat mich einfach zu verstehen, wie Vererbung funktioniert anders (und viel besser). Ich werde zu aktualisieren meinem code entsprechend.
    InformationsquelleAutor jbmusso
Schreibe einen Kommentar