Welches Ereignissystem für Python verwenden Sie? Ich kenne Pydispatcher bereits , habe mich aber gefragt, was sonst noch zu finden ist oder häufig verwendet wird.

Ich interessiere mich nicht für Event-Manager, die Teil großer Frameworks sind, sondern verwende lieber eine kleine Bare-Bones-Lösung, die ich problemlos erweitern kann.

PyPI-Pakete

Ab Juni 2020 sind dies die ereignisbezogenen Pakete, die auf PyPI verfügbar sind und nach dem letzten Veröffentlichungsdatum sortiert sind.

• RxPy3 1.0.1 : Juni 2020
• Pluggy 0.13.1 : Juni 2020 (Beta)
• Louie 2.0 : September 2019
• Python-Versand 0.1.2 : Februar 2019
• PyPubSub 4.0.3 : Januar 2019
• zope.event 4.4 : 2018
• pyeventdispatcher 0.2.3a0 : 2018
• Busbahn 0.0.5 : 2018
• PyPyDispatcher 2.1.2 : 2017
• Achse 0.0.7 : 2016
• Blinker 1.4 : 2015
• PyDispatcher 2.0.5 : 2015
• Pymitter 0.2.3 : 2014
• Dispatcher 1.0 : 2012
• py-notify 0.3.1 : 2008

Es gibt mehr

Das sind viele Bibliotheken zur Auswahl, die eine sehr unterschiedliche Terminologie verwenden (Ereignisse, Signale, Handler, Methodenversand, Hooks, ...).

Ich versuche, einen Überblick über die oben genannten Pakete sowie die in den Antworten hier genannten Techniken zu behalten.

Zunächst einige Begriffe ...

Beobachtermuster

Der grundlegendste Stil des Ereignissystems ist die 'Bag of Handler-Methode', die eine einfache Implementierung des Observer-Musters darstellt .

Grundsätzlich werden die Handler-Methoden (Callables) in einem Array gespeichert und jeweils aufgerufen, wenn das Ereignis 'ausgelöst' wird.

Veröffentlichen-Abonnieren

Der Nachteil von Observer-Ereignissystemen besteht darin, dass Sie die Handler nur für das tatsächliche Ereignisobjekt (oder die Handlerliste) registrieren können. Zum Zeitpunkt der Registrierung muss die Veranstaltung also bereits vorhanden sein.

Aus diesem Grund gibt es den zweiten Stil von Ereignissystemen: das Publish-Subscribe-Muster . Hier registrieren sich die Handler nicht für ein Ereignisobjekt (oder eine Handlerliste), sondern für einen zentralen Dispatcher. Auch die Benachrichtiger sprechen nur mit dem Dispatcher. Was zu hören oder zu veröffentlichen ist, wird durch 'Signal' bestimmt, das nichts weiter als ein Name (Zeichenfolge) ist.

Vermittlermuster

Könnte auch von Interesse sein: das Mediator-Muster .

Haken

Ein 'Hook'-System wird üblicherweise im Zusammenhang mit Anwendungs-Plugins verwendet. Die Anwendung enthält feste Integrationspunkte (Hooks), und jedes Plugin kann eine Verbindung zu diesem Hook herstellen und bestimmte Aktionen ausführen.

Andere Ereignisse'

Hinweis: threading.Event ist kein 'Ereignissystem' im obigen Sinne. Es ist ein Thread-Synchronisationssystem, bei dem ein Thread wartet, bis ein anderer Thread das Ereignisobjekt "signalisiert".

Netzwerk-Messaging-Bibliotheken verwenden häufig auch den Begriff "Ereignisse". manchmal sind diese im Konzept ähnlich; manchmal nicht. Sie können natürlich Thread-, Prozess- und Computergrenzen überschreiten. Siehe zB pyzmq , pymq , Twisted , Tornado , gevent , eventlet .

Schwache Referenzen

Wenn Sie in Python einen Verweis auf eine Methode oder ein Objekt halten, wird sichergestellt, dass dieser nicht vom Garbage Collector gelöscht wird. Dies kann wünschenswert sein, kann aber auch zu Speicherverlusten führen: Die verknüpften Handler werden niemals bereinigt.

Einige Ereignissysteme verwenden schwache Referenzen anstelle regulärer Referenzen, um dies zu lösen.

Einige Worte zu den verschiedenen Bibliotheken

Ereignissysteme im Beobachterstil:

• zope.event zeigt, wie das funktioniert (siehe Lennarts Antwort ). Hinweis: Dieses Beispiel unterstützt nicht einmal Handlerargumente.
• Die 'Callable List'- Implementierung von LongPoke zeigt, dass ein solches Ereignissystem durch Unterklassen sehr minimalistisch implementiert werden kann list.
• Felks Variation EventHook sorgt auch für die Signaturen von Anrufern und Anrufern.
• spassigs EventHook (Michael Foords Event Pattern) ist eine einfache Implementierung.
• Die Ereignisklasse "Wertvolle Lektionen" von Josip ist im Grunde dieselbe, verwendet jedoch a setanstelle von a list, um die Tasche zu speichern, und implementiert Geräte, __call__die beide sinnvolle Ergänzungen sind.
• PyNotify hat ein ähnliches Konzept und bietet zusätzliche Konzepte für Variablen und Bedingungen ('variabel geändertes Ereignis'). Die Homepage funktioniert nicht.
• axel ist im Grunde ein Bag-of-Handler mit mehr Funktionen in Bezug auf Threading, Fehlerbehandlung, ...
• Für Python-Dispatch müssen die geraden Quellklassen abgeleitet werden pydispatch.Dispatcher.
• buslane ist klassenbasiert, unterstützt Einzel- oder Mehrfachhandler und ermöglicht umfangreiche Typhinweise.
• Pithikos ' Observer / Event ist ein leichtes Design.

Publish-Subscribe-Bibliotheken:

• Blinker hat einige raffinierte Funktionen wie automatische Trennung und Filterung basierend auf dem Absender.
• PyPubSub ist ein stabiles Paket und verspricht "erweiterte Funktionen, die das Debuggen und Verwalten von Themen und Nachrichten erleichtern".
• pymitter ist ein Python-Port von Node.js EventEmitter2 und bietet Namespaces, Platzhalter und TTL.
• PyDispatcher scheint die Flexibilität in Bezug auf viele-zu-viele-Veröffentlichungen usw. zu betonen. Unterstützt schwache Referenzen.
• louie ist ein überarbeiteter PyDispatcher und sollte "in einer Vielzahl von Kontexten" arbeiten.
• pypydispatcher basiert auf (Sie haben es erraten ...) PyDispatcher und funktioniert auch in PyPy.
• django.dispatch ist ein umgeschriebener PyDispatcher "mit einer eingeschränkteren Oberfläche, aber höherer Leistung".
• pyeventdispatcher basiert auf dem Event-Dispatcher des Symfony-Frameworks von PHP.
• Der Dispatcher wurde aus django.dispatch extrahiert, wird aber ziemlich alt.
• Cristian Garcias EventManger ist eine sehr kurze Implementierung.

Andere:

• pluggy enthält ein Hook-System, das von pytestPlugins verwendet wird .
• RxPy3 implementiert das Observable-Muster und ermöglicht das Zusammenführen von Ereignissen, erneuten Versuchen usw.
• Die Signale und Slots von Qt sind bei PyQt oder PySide2 erhältlich . Sie funktionieren als Rückruf, wenn sie im selben Thread verwendet werden, oder als Ereignisse (mithilfe einer Ereignisschleife) zwischen zwei verschiedenen Threads. Signale und Slots haben die Einschränkung, dass sie nur in Objekten von Klassen funktionieren, von denen abgeleitet ist QObject.

Ich habe es so gemacht:

class Event(list):
    """Event subscription.

    A list of callable objects. Calling an instance of this will cause a
    call to each item in the list in ascending order by index.

    Example Usage:
    >>> def f(x):
    ...     print 'f(%s)' % x
    >>> def g(x):
    ...     print 'g(%s)' % x
    >>> e = Event()
    >>> e()
    >>> e.append(f)
    >>> e(123)
    f(123)
    >>> e.remove(f)
    >>> e()
    >>> e += (f, g)
    >>> e(10)
    f(10)
    g(10)
    >>> del e[0]
    >>> e(2)
    g(2)

    """
    def __call__(self, *args, **kwargs):
        for f in self:
            f(*args, **kwargs)

    def __repr__(self):
        return "Event(%s)" % list.__repr__(self)

Wie bei allem anderen, was ich gesehen habe, gibt es dafür kein automatisch generiertes Pydoc und keine Signaturen, was wirklich scheiße ist.

Wir verwenden einen EventHook, wie von Michael Foord in seinem Event-Muster vorgeschlagen :

Fügen Sie einfach EventHooks zu Ihren Klassen hinzu mit:

class MyBroadcaster()
    def __init__():
        self.onChange = EventHook()

theBroadcaster = MyBroadcaster()

# add a listener to the event
theBroadcaster.onChange += myFunction

# remove listener from the event
theBroadcaster.onChange -= myFunction

# fire event
theBroadcaster.onChange.fire()

Wir haben die Funktionalität hinzugefügt, um alle Listener von einem Objekt zur Michaels-Klasse zu entfernen.

class EventHook(object):

    def __init__(self):
        self.__handlers = []

    def __iadd__(self, handler):
        self.__handlers.append(handler)
        return self

    def __isub__(self, handler):
        self.__handlers.remove(handler)
        return self

    def fire(self, *args, **keywargs):
        for handler in self.__handlers:
            handler(*args, **keywargs)

    def clearObjectHandlers(self, inObject):
        for theHandler in self.__handlers:
            if theHandler.im_self == inObject:
                self -= theHandler

Ich benutze zope.event . Es sind die nacktesten Knochen, die Sie sich vorstellen können. :-) Tatsächlich ist hier der vollständige Quellcode:

subscribers = []

def notify(event):
    for subscriber in subscribers:
        subscriber(event)

Beachten Sie, dass Sie beispielsweise keine Nachrichten zwischen Prozessen senden können. Es ist kein Nachrichtensystem, nur ein Ereignissystem, nicht mehr und nicht weniger.

Ich habe dieses kleine Skript in Valued Lessons gefunden . Es scheint genau das richtige Verhältnis von Einfachheit und Leistung zu haben, nach dem ich suche. Peter Thatcher ist der Autor des folgenden Codes (es wird keine Lizenzierung erwähnt).

class Event:
    def __init__(self):
        self.handlers = set()

    def handle(self, handler):
        self.handlers.add(handler)
        return self

    def unhandle(self, handler):
        try:
            self.handlers.remove(handler)
        except:
            raise ValueError("Handler is not handling this event, so cannot unhandle it.")
        return self

    def fire(self, *args, **kargs):
        for handler in self.handlers:
            handler(*args, **kargs)

    def getHandlerCount(self):
        return len(self.handlers)

    __iadd__ = handle
    __isub__ = unhandle
    __call__ = fire
    __len__  = getHandlerCount

class MockFileWatcher:
    def __init__(self):
        self.fileChanged = Event()

    def watchFiles(self):
        source_path = "foo"
        self.fileChanged(source_path)

def log_file_change(source_path):
    print "%r changed." % (source_path,)

def log_file_change2(source_path):
    print "%r changed!" % (source_path,)

watcher              = MockFileWatcher()
watcher.fileChanged += log_file_change2
watcher.fileChanged += log_file_change
watcher.fileChanged -= log_file_change2
watcher.watchFiles()

Hier ist ein minimales Design, das gut funktionieren sollte. Was Sie tun müssen, ist einfach Observerin einer Klasse zu erben und anschließend zu verwenden observe(event_name, callback_fn), um auf ein bestimmtes Ereignis zu warten. Immer wenn dieses bestimmte Ereignis irgendwo im Code ausgelöst wird (dh Event('USB connected')), wird der entsprechende Rückruf ausgelöst .

class Observer():
    _observers = []
    def __init__(self):
        self._observers.append(self)
        self._observed_events = []
    def observe(self, event_name, callback_fn):
        self._observed_events.append({'event_name' : event_name, 'callback_fn' : callback_fn})


class Event():
    def __init__(self, event_name, *callback_args):
        for observer in Observer._observers:
            for observable in observer._observed_events:
                if observable['event_name'] == event_name:
                    observable['callback_fn'](*callback_args)

Beispiel:

class Room(Observer):
    def __init__(self):
        print("Room is ready.")
        Observer.__init__(self) # DON'T FORGET THIS
    def someone_arrived(self, who):
        print(who + " has arrived!")

# Observe for specific event
room = Room()
room.observe('someone arrived',  room.someone_arrived)

# Fire some events
Event('someone left',    'John')
Event('someone arrived', 'Lenard') # will output "Lenard has arrived!"
Event('someone Farted',  'Lenard')

Ich habe eine EventManagerKlasse erstellt (Code am Ende). Die Syntax lautet wie folgt:

#Create an event with no listeners assigned to it
EventManager.addEvent( eventName = [] )

#Create an event with listeners assigned to it
EventManager.addEvent( eventName = [fun1, fun2,...] )

#Create any number event with listeners assigned to them
EventManager.addEvent( eventName1 = [e1fun1, e1fun2,...], eventName2 = [e2fun1, e2fun2,...], ... )

#Add or remove listener to an existing event
EventManager.eventName += extra_fun
EventManager.eventName -= removed_fun

#Delete an event
del EventManager.eventName

#Fire the event
EventManager.eventName()

Hier ist ein Beispiel:

def hello(name):
    print "Hello {}".format(name)
    
def greetings(name):
    print "Greetings {}".format(name)

EventManager.addEvent( salute = [greetings] )
EventManager.salute += hello

print "\nInitial salute"
EventManager.salute('Oscar')

print "\nNow remove greetings"
EventManager.salute -= greetings
EventManager.salute('Oscar')

Ausgabe:

Erster Gruß
Grüße Oscar
Hallo Oscar

Entfernen Sie jetzt Grüße
Hallo Oscar

EventManger-Code:

class EventManager:
    
    class Event:
        def __init__(self,functions):
            if type(functions) is not list:
                raise ValueError("functions parameter has to be a list")
            self.functions = functions
            
        def __iadd__(self,func):
            self.functions.append(func)
            return self
            
        def __isub__(self,func):
            self.functions.remove(func)
            return self
            
        def __call__(self,*args,**kvargs):
            for func in self.functions : func(*args,**kvargs)
            
    @classmethod
    def addEvent(cls,**kvargs):
        """
        addEvent( event1 = [f1,f2,...], event2 = [g1,g2,...], ... )
        creates events using **kvargs to create any number of events. Each event recieves a list of functions,
        where every function in the list recieves the same parameters.
        
        Example:
        
        def hello(): print "Hello ",
        def world(): print "World"
        
        EventManager.addEvent( salute = [hello] )
        EventManager.salute += world
        
        EventManager.salute()
        
        Output:
        Hello World
        """
        for key in kvargs.keys():
            if type(kvargs[key]) is not list:
                raise ValueError("value has to be a list")
            else:
                kvargs[key] = cls.Event(kvargs[key])
        
        cls.__dict__.update(kvargs)

Sie können einen Blick auf Pymitter ( Pypi ) werfen . Es handelt sich um einen kleinen Single-File-Ansatz (~ 250 loc), der "Namespaces, Platzhalter und TTL bereitstellt".

Hier ist ein einfaches Beispiel:

from pymitter import EventEmitter

ee = EventEmitter()

# decorator usage
@ee.on("myevent")
def handler1(arg):
   print "handler1 called with", arg

# callback usage
def handler2(arg):
    print "handler2 called with", arg
ee.on("myotherevent", handler2)

# emit
ee.emit("myevent", "foo")
# -> "handler1 called with foo"

ee.emit("myotherevent", "bar")
# -> "handler2 called with bar"

Ich habe eine Variation von Longpokes minimalistischem Ansatz gemacht, die auch die Signaturen sowohl für Anrufer als auch für Anrufer sicherstellt:

class EventHook(object):
    '''
    A simple implementation of the Observer-Pattern.
    The user can specify an event signature upon inizializazion,
    defined by kwargs in the form of argumentname=class (e.g. id=int).
    The arguments' types are not checked in this implementation though.
    Callables with a fitting signature can be added with += or removed with -=.
    All listeners can be notified by calling the EventHook class with fitting
    arguments.

    >>> event = EventHook(id=int, data=dict)
    >>> event += lambda id, data: print("%d %s" % (id, data))
    >>> event(id=5, data={"foo": "bar"})
    5 {'foo': 'bar'}

    >>> event = EventHook(id=int)
    >>> event += lambda wrong_name: None
    Traceback (most recent call last):
        ...
    ValueError: Listener must have these arguments: (id=int)

    >>> event = EventHook(id=int)
    >>> event += lambda id: None
    >>> event(wrong_name=0)
    Traceback (most recent call last):
        ...
    ValueError: This EventHook must be called with these arguments: (id=int)
    '''
    def __init__(self, **signature):
        self._signature = signature
        self._argnames = set(signature.keys())
        self._handlers = []

    def _kwargs_str(self):
        return ", ".join(k+"="+v.__name__ for k, v in self._signature.items())

    def __iadd__(self, handler):
        params = inspect.signature(handler).parameters
        valid = True
        argnames = set(n for n in params.keys())
        if argnames != self._argnames:
            valid = False
        for p in params.values():
            if p.kind == p.VAR_KEYWORD:
                valid = True
                break
            if p.kind not in (p.POSITIONAL_OR_KEYWORD, p.KEYWORD_ONLY):
                valid = False
                break
        if not valid:
            raise ValueError("Listener must have these arguments: (%s)"
                             % self._kwargs_str())
        self._handlers.append(handler)
        return self

    def __isub__(self, handler):
        self._handlers.remove(handler)
        return self

    def __call__(self, *args, **kwargs):
        if args or set(kwargs.keys()) != self._argnames:
            raise ValueError("This EventHook must be called with these " +
                             "keyword arguments: (%s)" % self._kwargs_str())
        for handler in self._handlers[:]:
            handler(**kwargs)

    def __repr__(self):
        return "EventHook(%s)" % self._kwargs_str()

Wenn ich in pyQt codiere, verwende ich das QT-Sockets / Signal-Paradigma, dasselbe gilt für Django

Wenn ich asynchrone E / A-Vorgänge durchführe, verwenden Sie das native Auswahlmodul

Wenn ich einen SAX-Python-Parser verwende, verwende ich die von SAX bereitgestellte Ereignis-API. Es sieht also so aus, als wäre ich Opfer der zugrunde liegenden API :-)

Vielleicht sollten Sie sich fragen, was Sie von Event Framework / Modul erwarten. Meine persönliche Präferenz ist die Verwendung des Socket / Signal-Paradigmas von QT. Weitere Infos dazu finden Sie hier

Hier ist ein weiteres Modul zur Prüfung. Es scheint eine gute Wahl für anspruchsvollere Anwendungen zu sein.

Py-notify ist ein Python-Paket, das Tools zum Implementieren des Observer-Programmiermusters bietet. Diese Tools umfassen Signale, Bedingungen und Variablen.

Signale sind Listen von Handlern, die aufgerufen werden, wenn ein Signal ausgegeben wird. Bedingungen sind im Grunde boolesche Variablen, die mit einem Signal gekoppelt sind, das ausgegeben wird, wenn sich der Zustandszustand ändert. Sie können unter Verwendung von logischen Standardoperatoren (nicht und usw.) zu zusammengesetzten Bedingungen kombiniert werden. Im Gegensatz zu Bedingungen können Variablen jedes Python-Objekt enthalten, nicht nur Boolesche Werte, sondern können auch nicht kombiniert werden.

Wenn Sie kompliziertere Dinge wie das Zusammenführen von Ereignissen oder das Wiederholen von Ereignissen ausführen möchten, können Sie das Observable-Muster und eine ausgereifte Bibliothek verwenden, die dies implementiert. https://github.com/ReactiveX/RxPY . Observables sind in Javascript und Java sehr verbreitet und für einige asynchrone Aufgaben sehr praktisch.

from rx import Observable, Observer


def push_five_strings(observer):
        observer.on_next("Alpha")
        observer.on_next("Beta")
        observer.on_next("Gamma")
        observer.on_next("Delta")
        observer.on_next("Epsilon")
        observer.on_completed()


class PrintObserver(Observer):

    def on_next(self, value):
        print("Received {0}".format(value))

    def on_completed(self):
        print("Done!")

    def on_error(self, error):
        print("Error Occurred: {0}".format(error))

source = Observable.create(push_five_strings)

source.subscribe(PrintObserver())

AUSGABE :

Received Alpha
Received Beta
Received Gamma
Received Delta
Received Epsilon
Done!

Wenn Sie einen Eventbus benötigen, der über Prozess- oder Netzwerkgrenzen hinweg funktioniert, können Sie PyMQ ausprobieren . Derzeit werden Pub / Sub, Nachrichtenwarteschlangen und synchroner RPC unterstützt. Die Standardversion funktioniert auf einem Redis-Backend, sodass Sie einen laufenden Redis-Server benötigen. Es gibt auch ein In-Memory-Backend zum Testen. Sie können auch Ihr eigenes Backend schreiben.

import pymq

# common code
class MyEvent:
    pass

# subscribe code
@pymq.subscriber
def on_event(event: MyEvent):
    print('event received')

# publisher code
pymq.publish(MyEvent())

# you can also customize channels
pymq.subscribe(on_event, channel='my_channel')
pymq.publish(MyEvent(), channel='my_channel')

So initialisieren Sie das System:

from pymq.provider.redis import RedisConfig

# starts a new thread with a Redis event loop
pymq.init(RedisConfig())

# main application control loop

pymq.shutdown()

Haftungsausschluss: Ich bin der Autor dieser Bibliothek

Sie können das buslaneModul ausprobieren .

Diese Bibliothek erleichtert die Implementierung eines nachrichtenbasierten Systems. Es unterstützt den Ansatz von Befehlen (einzelner Handler) und Ereignissen (0 oder mehrere Handler). Buslane verwendet Anmerkungen vom Typ Python, um den Handler ordnungsgemäß zu registrieren.

Einfaches Beispiel:

from dataclasses import dataclass

from buslane.commands import Command, CommandHandler, CommandBus


@dataclass(frozen=True)
class RegisterUserCommand(Command):
    email: str
    password: str


class RegisterUserCommandHandler(CommandHandler[RegisterUserCommand]):

    def handle(self, command: RegisterUserCommand) -> None:
        assert command == RegisterUserCommand(
            email='[email protected]',
            password='secret',
        )


command_bus = CommandBus()
command_bus.register(handler=RegisterUserCommandHandler())
command_bus.execute(command=RegisterUserCommand(
    email='[email protected]',
    password='secret',
))

Verwenden Sie zum Installieren der Busbahn einfach pip:

$ pip install buslane

Vor einiger Zeit habe ich eine Bibliothek geschrieben, die für Sie nützlich sein könnte. Es ermöglicht Ihnen lokale und globale Listener, verschiedene Arten der Registrierung, Ausführungspriorität usw.

from pyeventdispatcher import register

register("foo.bar", lambda event: print("second"))
register("foo.bar", lambda event: print("first "), -100)

dispatch(Event("foo.bar", {"id": 1}))
# first second

Schauen Sie sich pyeventdispatcher an